1
16
17
18
19
20 package v1beta1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
29 k8s_io_api_core_v1 "k8s.io/api/core/v1"
30 v11 "k8s.io/api/core/v1"
31 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
32
33 math "math"
34 math_bits "math/bits"
35 reflect "reflect"
36 strings "strings"
37
38 intstr "k8s.io/apimachinery/pkg/util/intstr"
39 )
40
41
42 var _ = proto.Marshal
43 var _ = fmt.Errorf
44 var _ = math.Inf
45
46
47
48
49
50 const _ = proto.GoGoProtoPackageIsVersion3
51
52 func (m *ControllerRevision) Reset() { *m = ControllerRevision{} }
53 func (*ControllerRevision) ProtoMessage() {}
54 func (*ControllerRevision) Descriptor() ([]byte, []int) {
55 return fileDescriptor_2747f709ac7c95e7, []int{0}
56 }
57 func (m *ControllerRevision) XXX_Unmarshal(b []byte) error {
58 return m.Unmarshal(b)
59 }
60 func (m *ControllerRevision) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
61 b = b[:cap(b)]
62 n, err := m.MarshalToSizedBuffer(b)
63 if err != nil {
64 return nil, err
65 }
66 return b[:n], nil
67 }
68 func (m *ControllerRevision) XXX_Merge(src proto.Message) {
69 xxx_messageInfo_ControllerRevision.Merge(m, src)
70 }
71 func (m *ControllerRevision) XXX_Size() int {
72 return m.Size()
73 }
74 func (m *ControllerRevision) XXX_DiscardUnknown() {
75 xxx_messageInfo_ControllerRevision.DiscardUnknown(m)
76 }
77
78 var xxx_messageInfo_ControllerRevision proto.InternalMessageInfo
79
80 func (m *ControllerRevisionList) Reset() { *m = ControllerRevisionList{} }
81 func (*ControllerRevisionList) ProtoMessage() {}
82 func (*ControllerRevisionList) Descriptor() ([]byte, []int) {
83 return fileDescriptor_2747f709ac7c95e7, []int{1}
84 }
85 func (m *ControllerRevisionList) XXX_Unmarshal(b []byte) error {
86 return m.Unmarshal(b)
87 }
88 func (m *ControllerRevisionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
89 b = b[:cap(b)]
90 n, err := m.MarshalToSizedBuffer(b)
91 if err != nil {
92 return nil, err
93 }
94 return b[:n], nil
95 }
96 func (m *ControllerRevisionList) XXX_Merge(src proto.Message) {
97 xxx_messageInfo_ControllerRevisionList.Merge(m, src)
98 }
99 func (m *ControllerRevisionList) XXX_Size() int {
100 return m.Size()
101 }
102 func (m *ControllerRevisionList) XXX_DiscardUnknown() {
103 xxx_messageInfo_ControllerRevisionList.DiscardUnknown(m)
104 }
105
106 var xxx_messageInfo_ControllerRevisionList proto.InternalMessageInfo
107
108 func (m *Deployment) Reset() { *m = Deployment{} }
109 func (*Deployment) ProtoMessage() {}
110 func (*Deployment) Descriptor() ([]byte, []int) {
111 return fileDescriptor_2747f709ac7c95e7, []int{2}
112 }
113 func (m *Deployment) XXX_Unmarshal(b []byte) error {
114 return m.Unmarshal(b)
115 }
116 func (m *Deployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
117 b = b[:cap(b)]
118 n, err := m.MarshalToSizedBuffer(b)
119 if err != nil {
120 return nil, err
121 }
122 return b[:n], nil
123 }
124 func (m *Deployment) XXX_Merge(src proto.Message) {
125 xxx_messageInfo_Deployment.Merge(m, src)
126 }
127 func (m *Deployment) XXX_Size() int {
128 return m.Size()
129 }
130 func (m *Deployment) XXX_DiscardUnknown() {
131 xxx_messageInfo_Deployment.DiscardUnknown(m)
132 }
133
134 var xxx_messageInfo_Deployment proto.InternalMessageInfo
135
136 func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} }
137 func (*DeploymentCondition) ProtoMessage() {}
138 func (*DeploymentCondition) Descriptor() ([]byte, []int) {
139 return fileDescriptor_2747f709ac7c95e7, []int{3}
140 }
141 func (m *DeploymentCondition) XXX_Unmarshal(b []byte) error {
142 return m.Unmarshal(b)
143 }
144 func (m *DeploymentCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
145 b = b[:cap(b)]
146 n, err := m.MarshalToSizedBuffer(b)
147 if err != nil {
148 return nil, err
149 }
150 return b[:n], nil
151 }
152 func (m *DeploymentCondition) XXX_Merge(src proto.Message) {
153 xxx_messageInfo_DeploymentCondition.Merge(m, src)
154 }
155 func (m *DeploymentCondition) XXX_Size() int {
156 return m.Size()
157 }
158 func (m *DeploymentCondition) XXX_DiscardUnknown() {
159 xxx_messageInfo_DeploymentCondition.DiscardUnknown(m)
160 }
161
162 var xxx_messageInfo_DeploymentCondition proto.InternalMessageInfo
163
164 func (m *DeploymentList) Reset() { *m = DeploymentList{} }
165 func (*DeploymentList) ProtoMessage() {}
166 func (*DeploymentList) Descriptor() ([]byte, []int) {
167 return fileDescriptor_2747f709ac7c95e7, []int{4}
168 }
169 func (m *DeploymentList) XXX_Unmarshal(b []byte) error {
170 return m.Unmarshal(b)
171 }
172 func (m *DeploymentList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
173 b = b[:cap(b)]
174 n, err := m.MarshalToSizedBuffer(b)
175 if err != nil {
176 return nil, err
177 }
178 return b[:n], nil
179 }
180 func (m *DeploymentList) XXX_Merge(src proto.Message) {
181 xxx_messageInfo_DeploymentList.Merge(m, src)
182 }
183 func (m *DeploymentList) XXX_Size() int {
184 return m.Size()
185 }
186 func (m *DeploymentList) XXX_DiscardUnknown() {
187 xxx_messageInfo_DeploymentList.DiscardUnknown(m)
188 }
189
190 var xxx_messageInfo_DeploymentList proto.InternalMessageInfo
191
192 func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} }
193 func (*DeploymentRollback) ProtoMessage() {}
194 func (*DeploymentRollback) Descriptor() ([]byte, []int) {
195 return fileDescriptor_2747f709ac7c95e7, []int{5}
196 }
197 func (m *DeploymentRollback) XXX_Unmarshal(b []byte) error {
198 return m.Unmarshal(b)
199 }
200 func (m *DeploymentRollback) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
201 b = b[:cap(b)]
202 n, err := m.MarshalToSizedBuffer(b)
203 if err != nil {
204 return nil, err
205 }
206 return b[:n], nil
207 }
208 func (m *DeploymentRollback) XXX_Merge(src proto.Message) {
209 xxx_messageInfo_DeploymentRollback.Merge(m, src)
210 }
211 func (m *DeploymentRollback) XXX_Size() int {
212 return m.Size()
213 }
214 func (m *DeploymentRollback) XXX_DiscardUnknown() {
215 xxx_messageInfo_DeploymentRollback.DiscardUnknown(m)
216 }
217
218 var xxx_messageInfo_DeploymentRollback proto.InternalMessageInfo
219
220 func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} }
221 func (*DeploymentSpec) ProtoMessage() {}
222 func (*DeploymentSpec) Descriptor() ([]byte, []int) {
223 return fileDescriptor_2747f709ac7c95e7, []int{6}
224 }
225 func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error {
226 return m.Unmarshal(b)
227 }
228 func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
229 b = b[:cap(b)]
230 n, err := m.MarshalToSizedBuffer(b)
231 if err != nil {
232 return nil, err
233 }
234 return b[:n], nil
235 }
236 func (m *DeploymentSpec) XXX_Merge(src proto.Message) {
237 xxx_messageInfo_DeploymentSpec.Merge(m, src)
238 }
239 func (m *DeploymentSpec) XXX_Size() int {
240 return m.Size()
241 }
242 func (m *DeploymentSpec) XXX_DiscardUnknown() {
243 xxx_messageInfo_DeploymentSpec.DiscardUnknown(m)
244 }
245
246 var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo
247
248 func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} }
249 func (*DeploymentStatus) ProtoMessage() {}
250 func (*DeploymentStatus) Descriptor() ([]byte, []int) {
251 return fileDescriptor_2747f709ac7c95e7, []int{7}
252 }
253 func (m *DeploymentStatus) XXX_Unmarshal(b []byte) error {
254 return m.Unmarshal(b)
255 }
256 func (m *DeploymentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
257 b = b[:cap(b)]
258 n, err := m.MarshalToSizedBuffer(b)
259 if err != nil {
260 return nil, err
261 }
262 return b[:n], nil
263 }
264 func (m *DeploymentStatus) XXX_Merge(src proto.Message) {
265 xxx_messageInfo_DeploymentStatus.Merge(m, src)
266 }
267 func (m *DeploymentStatus) XXX_Size() int {
268 return m.Size()
269 }
270 func (m *DeploymentStatus) XXX_DiscardUnknown() {
271 xxx_messageInfo_DeploymentStatus.DiscardUnknown(m)
272 }
273
274 var xxx_messageInfo_DeploymentStatus proto.InternalMessageInfo
275
276 func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} }
277 func (*DeploymentStrategy) ProtoMessage() {}
278 func (*DeploymentStrategy) Descriptor() ([]byte, []int) {
279 return fileDescriptor_2747f709ac7c95e7, []int{8}
280 }
281 func (m *DeploymentStrategy) XXX_Unmarshal(b []byte) error {
282 return m.Unmarshal(b)
283 }
284 func (m *DeploymentStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
285 b = b[:cap(b)]
286 n, err := m.MarshalToSizedBuffer(b)
287 if err != nil {
288 return nil, err
289 }
290 return b[:n], nil
291 }
292 func (m *DeploymentStrategy) XXX_Merge(src proto.Message) {
293 xxx_messageInfo_DeploymentStrategy.Merge(m, src)
294 }
295 func (m *DeploymentStrategy) XXX_Size() int {
296 return m.Size()
297 }
298 func (m *DeploymentStrategy) XXX_DiscardUnknown() {
299 xxx_messageInfo_DeploymentStrategy.DiscardUnknown(m)
300 }
301
302 var xxx_messageInfo_DeploymentStrategy proto.InternalMessageInfo
303
304 func (m *RollbackConfig) Reset() { *m = RollbackConfig{} }
305 func (*RollbackConfig) ProtoMessage() {}
306 func (*RollbackConfig) Descriptor() ([]byte, []int) {
307 return fileDescriptor_2747f709ac7c95e7, []int{9}
308 }
309 func (m *RollbackConfig) XXX_Unmarshal(b []byte) error {
310 return m.Unmarshal(b)
311 }
312 func (m *RollbackConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
313 b = b[:cap(b)]
314 n, err := m.MarshalToSizedBuffer(b)
315 if err != nil {
316 return nil, err
317 }
318 return b[:n], nil
319 }
320 func (m *RollbackConfig) XXX_Merge(src proto.Message) {
321 xxx_messageInfo_RollbackConfig.Merge(m, src)
322 }
323 func (m *RollbackConfig) XXX_Size() int {
324 return m.Size()
325 }
326 func (m *RollbackConfig) XXX_DiscardUnknown() {
327 xxx_messageInfo_RollbackConfig.DiscardUnknown(m)
328 }
329
330 var xxx_messageInfo_RollbackConfig proto.InternalMessageInfo
331
332 func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} }
333 func (*RollingUpdateDeployment) ProtoMessage() {}
334 func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
335 return fileDescriptor_2747f709ac7c95e7, []int{10}
336 }
337 func (m *RollingUpdateDeployment) XXX_Unmarshal(b []byte) error {
338 return m.Unmarshal(b)
339 }
340 func (m *RollingUpdateDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
341 b = b[:cap(b)]
342 n, err := m.MarshalToSizedBuffer(b)
343 if err != nil {
344 return nil, err
345 }
346 return b[:n], nil
347 }
348 func (m *RollingUpdateDeployment) XXX_Merge(src proto.Message) {
349 xxx_messageInfo_RollingUpdateDeployment.Merge(m, src)
350 }
351 func (m *RollingUpdateDeployment) XXX_Size() int {
352 return m.Size()
353 }
354 func (m *RollingUpdateDeployment) XXX_DiscardUnknown() {
355 xxx_messageInfo_RollingUpdateDeployment.DiscardUnknown(m)
356 }
357
358 var xxx_messageInfo_RollingUpdateDeployment proto.InternalMessageInfo
359
360 func (m *RollingUpdateStatefulSetStrategy) Reset() { *m = RollingUpdateStatefulSetStrategy{} }
361 func (*RollingUpdateStatefulSetStrategy) ProtoMessage() {}
362 func (*RollingUpdateStatefulSetStrategy) Descriptor() ([]byte, []int) {
363 return fileDescriptor_2747f709ac7c95e7, []int{11}
364 }
365 func (m *RollingUpdateStatefulSetStrategy) XXX_Unmarshal(b []byte) error {
366 return m.Unmarshal(b)
367 }
368 func (m *RollingUpdateStatefulSetStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
369 b = b[:cap(b)]
370 n, err := m.MarshalToSizedBuffer(b)
371 if err != nil {
372 return nil, err
373 }
374 return b[:n], nil
375 }
376 func (m *RollingUpdateStatefulSetStrategy) XXX_Merge(src proto.Message) {
377 xxx_messageInfo_RollingUpdateStatefulSetStrategy.Merge(m, src)
378 }
379 func (m *RollingUpdateStatefulSetStrategy) XXX_Size() int {
380 return m.Size()
381 }
382 func (m *RollingUpdateStatefulSetStrategy) XXX_DiscardUnknown() {
383 xxx_messageInfo_RollingUpdateStatefulSetStrategy.DiscardUnknown(m)
384 }
385
386 var xxx_messageInfo_RollingUpdateStatefulSetStrategy proto.InternalMessageInfo
387
388 func (m *Scale) Reset() { *m = Scale{} }
389 func (*Scale) ProtoMessage() {}
390 func (*Scale) Descriptor() ([]byte, []int) {
391 return fileDescriptor_2747f709ac7c95e7, []int{12}
392 }
393 func (m *Scale) XXX_Unmarshal(b []byte) error {
394 return m.Unmarshal(b)
395 }
396 func (m *Scale) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
397 b = b[:cap(b)]
398 n, err := m.MarshalToSizedBuffer(b)
399 if err != nil {
400 return nil, err
401 }
402 return b[:n], nil
403 }
404 func (m *Scale) XXX_Merge(src proto.Message) {
405 xxx_messageInfo_Scale.Merge(m, src)
406 }
407 func (m *Scale) XXX_Size() int {
408 return m.Size()
409 }
410 func (m *Scale) XXX_DiscardUnknown() {
411 xxx_messageInfo_Scale.DiscardUnknown(m)
412 }
413
414 var xxx_messageInfo_Scale proto.InternalMessageInfo
415
416 func (m *ScaleSpec) Reset() { *m = ScaleSpec{} }
417 func (*ScaleSpec) ProtoMessage() {}
418 func (*ScaleSpec) Descriptor() ([]byte, []int) {
419 return fileDescriptor_2747f709ac7c95e7, []int{13}
420 }
421 func (m *ScaleSpec) XXX_Unmarshal(b []byte) error {
422 return m.Unmarshal(b)
423 }
424 func (m *ScaleSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
425 b = b[:cap(b)]
426 n, err := m.MarshalToSizedBuffer(b)
427 if err != nil {
428 return nil, err
429 }
430 return b[:n], nil
431 }
432 func (m *ScaleSpec) XXX_Merge(src proto.Message) {
433 xxx_messageInfo_ScaleSpec.Merge(m, src)
434 }
435 func (m *ScaleSpec) XXX_Size() int {
436 return m.Size()
437 }
438 func (m *ScaleSpec) XXX_DiscardUnknown() {
439 xxx_messageInfo_ScaleSpec.DiscardUnknown(m)
440 }
441
442 var xxx_messageInfo_ScaleSpec proto.InternalMessageInfo
443
444 func (m *ScaleStatus) Reset() { *m = ScaleStatus{} }
445 func (*ScaleStatus) ProtoMessage() {}
446 func (*ScaleStatus) Descriptor() ([]byte, []int) {
447 return fileDescriptor_2747f709ac7c95e7, []int{14}
448 }
449 func (m *ScaleStatus) XXX_Unmarshal(b []byte) error {
450 return m.Unmarshal(b)
451 }
452 func (m *ScaleStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
453 b = b[:cap(b)]
454 n, err := m.MarshalToSizedBuffer(b)
455 if err != nil {
456 return nil, err
457 }
458 return b[:n], nil
459 }
460 func (m *ScaleStatus) XXX_Merge(src proto.Message) {
461 xxx_messageInfo_ScaleStatus.Merge(m, src)
462 }
463 func (m *ScaleStatus) XXX_Size() int {
464 return m.Size()
465 }
466 func (m *ScaleStatus) XXX_DiscardUnknown() {
467 xxx_messageInfo_ScaleStatus.DiscardUnknown(m)
468 }
469
470 var xxx_messageInfo_ScaleStatus proto.InternalMessageInfo
471
472 func (m *StatefulSet) Reset() { *m = StatefulSet{} }
473 func (*StatefulSet) ProtoMessage() {}
474 func (*StatefulSet) Descriptor() ([]byte, []int) {
475 return fileDescriptor_2747f709ac7c95e7, []int{15}
476 }
477 func (m *StatefulSet) XXX_Unmarshal(b []byte) error {
478 return m.Unmarshal(b)
479 }
480 func (m *StatefulSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
481 b = b[:cap(b)]
482 n, err := m.MarshalToSizedBuffer(b)
483 if err != nil {
484 return nil, err
485 }
486 return b[:n], nil
487 }
488 func (m *StatefulSet) XXX_Merge(src proto.Message) {
489 xxx_messageInfo_StatefulSet.Merge(m, src)
490 }
491 func (m *StatefulSet) XXX_Size() int {
492 return m.Size()
493 }
494 func (m *StatefulSet) XXX_DiscardUnknown() {
495 xxx_messageInfo_StatefulSet.DiscardUnknown(m)
496 }
497
498 var xxx_messageInfo_StatefulSet proto.InternalMessageInfo
499
500 func (m *StatefulSetCondition) Reset() { *m = StatefulSetCondition{} }
501 func (*StatefulSetCondition) ProtoMessage() {}
502 func (*StatefulSetCondition) Descriptor() ([]byte, []int) {
503 return fileDescriptor_2747f709ac7c95e7, []int{16}
504 }
505 func (m *StatefulSetCondition) XXX_Unmarshal(b []byte) error {
506 return m.Unmarshal(b)
507 }
508 func (m *StatefulSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
509 b = b[:cap(b)]
510 n, err := m.MarshalToSizedBuffer(b)
511 if err != nil {
512 return nil, err
513 }
514 return b[:n], nil
515 }
516 func (m *StatefulSetCondition) XXX_Merge(src proto.Message) {
517 xxx_messageInfo_StatefulSetCondition.Merge(m, src)
518 }
519 func (m *StatefulSetCondition) XXX_Size() int {
520 return m.Size()
521 }
522 func (m *StatefulSetCondition) XXX_DiscardUnknown() {
523 xxx_messageInfo_StatefulSetCondition.DiscardUnknown(m)
524 }
525
526 var xxx_messageInfo_StatefulSetCondition proto.InternalMessageInfo
527
528 func (m *StatefulSetList) Reset() { *m = StatefulSetList{} }
529 func (*StatefulSetList) ProtoMessage() {}
530 func (*StatefulSetList) Descriptor() ([]byte, []int) {
531 return fileDescriptor_2747f709ac7c95e7, []int{17}
532 }
533 func (m *StatefulSetList) XXX_Unmarshal(b []byte) error {
534 return m.Unmarshal(b)
535 }
536 func (m *StatefulSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
537 b = b[:cap(b)]
538 n, err := m.MarshalToSizedBuffer(b)
539 if err != nil {
540 return nil, err
541 }
542 return b[:n], nil
543 }
544 func (m *StatefulSetList) XXX_Merge(src proto.Message) {
545 xxx_messageInfo_StatefulSetList.Merge(m, src)
546 }
547 func (m *StatefulSetList) XXX_Size() int {
548 return m.Size()
549 }
550 func (m *StatefulSetList) XXX_DiscardUnknown() {
551 xxx_messageInfo_StatefulSetList.DiscardUnknown(m)
552 }
553
554 var xxx_messageInfo_StatefulSetList proto.InternalMessageInfo
555
556 func (m *StatefulSetOrdinals) Reset() { *m = StatefulSetOrdinals{} }
557 func (*StatefulSetOrdinals) ProtoMessage() {}
558 func (*StatefulSetOrdinals) Descriptor() ([]byte, []int) {
559 return fileDescriptor_2747f709ac7c95e7, []int{18}
560 }
561 func (m *StatefulSetOrdinals) XXX_Unmarshal(b []byte) error {
562 return m.Unmarshal(b)
563 }
564 func (m *StatefulSetOrdinals) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
565 b = b[:cap(b)]
566 n, err := m.MarshalToSizedBuffer(b)
567 if err != nil {
568 return nil, err
569 }
570 return b[:n], nil
571 }
572 func (m *StatefulSetOrdinals) XXX_Merge(src proto.Message) {
573 xxx_messageInfo_StatefulSetOrdinals.Merge(m, src)
574 }
575 func (m *StatefulSetOrdinals) XXX_Size() int {
576 return m.Size()
577 }
578 func (m *StatefulSetOrdinals) XXX_DiscardUnknown() {
579 xxx_messageInfo_StatefulSetOrdinals.DiscardUnknown(m)
580 }
581
582 var xxx_messageInfo_StatefulSetOrdinals proto.InternalMessageInfo
583
584 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Reset() {
585 *m = StatefulSetPersistentVolumeClaimRetentionPolicy{}
586 }
587 func (*StatefulSetPersistentVolumeClaimRetentionPolicy) ProtoMessage() {}
588 func (*StatefulSetPersistentVolumeClaimRetentionPolicy) Descriptor() ([]byte, []int) {
589 return fileDescriptor_2747f709ac7c95e7, []int{19}
590 }
591 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Unmarshal(b []byte) error {
592 return m.Unmarshal(b)
593 }
594 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
595 b = b[:cap(b)]
596 n, err := m.MarshalToSizedBuffer(b)
597 if err != nil {
598 return nil, err
599 }
600 return b[:n], nil
601 }
602 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Merge(src proto.Message) {
603 xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.Merge(m, src)
604 }
605 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_Size() int {
606 return m.Size()
607 }
608 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) XXX_DiscardUnknown() {
609 xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy.DiscardUnknown(m)
610 }
611
612 var xxx_messageInfo_StatefulSetPersistentVolumeClaimRetentionPolicy proto.InternalMessageInfo
613
614 func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} }
615 func (*StatefulSetSpec) ProtoMessage() {}
616 func (*StatefulSetSpec) Descriptor() ([]byte, []int) {
617 return fileDescriptor_2747f709ac7c95e7, []int{20}
618 }
619 func (m *StatefulSetSpec) XXX_Unmarshal(b []byte) error {
620 return m.Unmarshal(b)
621 }
622 func (m *StatefulSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
623 b = b[:cap(b)]
624 n, err := m.MarshalToSizedBuffer(b)
625 if err != nil {
626 return nil, err
627 }
628 return b[:n], nil
629 }
630 func (m *StatefulSetSpec) XXX_Merge(src proto.Message) {
631 xxx_messageInfo_StatefulSetSpec.Merge(m, src)
632 }
633 func (m *StatefulSetSpec) XXX_Size() int {
634 return m.Size()
635 }
636 func (m *StatefulSetSpec) XXX_DiscardUnknown() {
637 xxx_messageInfo_StatefulSetSpec.DiscardUnknown(m)
638 }
639
640 var xxx_messageInfo_StatefulSetSpec proto.InternalMessageInfo
641
642 func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} }
643 func (*StatefulSetStatus) ProtoMessage() {}
644 func (*StatefulSetStatus) Descriptor() ([]byte, []int) {
645 return fileDescriptor_2747f709ac7c95e7, []int{21}
646 }
647 func (m *StatefulSetStatus) XXX_Unmarshal(b []byte) error {
648 return m.Unmarshal(b)
649 }
650 func (m *StatefulSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
651 b = b[:cap(b)]
652 n, err := m.MarshalToSizedBuffer(b)
653 if err != nil {
654 return nil, err
655 }
656 return b[:n], nil
657 }
658 func (m *StatefulSetStatus) XXX_Merge(src proto.Message) {
659 xxx_messageInfo_StatefulSetStatus.Merge(m, src)
660 }
661 func (m *StatefulSetStatus) XXX_Size() int {
662 return m.Size()
663 }
664 func (m *StatefulSetStatus) XXX_DiscardUnknown() {
665 xxx_messageInfo_StatefulSetStatus.DiscardUnknown(m)
666 }
667
668 var xxx_messageInfo_StatefulSetStatus proto.InternalMessageInfo
669
670 func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} }
671 func (*StatefulSetUpdateStrategy) ProtoMessage() {}
672 func (*StatefulSetUpdateStrategy) Descriptor() ([]byte, []int) {
673 return fileDescriptor_2747f709ac7c95e7, []int{22}
674 }
675 func (m *StatefulSetUpdateStrategy) XXX_Unmarshal(b []byte) error {
676 return m.Unmarshal(b)
677 }
678 func (m *StatefulSetUpdateStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
679 b = b[:cap(b)]
680 n, err := m.MarshalToSizedBuffer(b)
681 if err != nil {
682 return nil, err
683 }
684 return b[:n], nil
685 }
686 func (m *StatefulSetUpdateStrategy) XXX_Merge(src proto.Message) {
687 xxx_messageInfo_StatefulSetUpdateStrategy.Merge(m, src)
688 }
689 func (m *StatefulSetUpdateStrategy) XXX_Size() int {
690 return m.Size()
691 }
692 func (m *StatefulSetUpdateStrategy) XXX_DiscardUnknown() {
693 xxx_messageInfo_StatefulSetUpdateStrategy.DiscardUnknown(m)
694 }
695
696 var xxx_messageInfo_StatefulSetUpdateStrategy proto.InternalMessageInfo
697
698 func init() {
699 proto.RegisterType((*ControllerRevision)(nil), "k8s.io.api.apps.v1beta1.ControllerRevision")
700 proto.RegisterType((*ControllerRevisionList)(nil), "k8s.io.api.apps.v1beta1.ControllerRevisionList")
701 proto.RegisterType((*Deployment)(nil), "k8s.io.api.apps.v1beta1.Deployment")
702 proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.apps.v1beta1.DeploymentCondition")
703 proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.apps.v1beta1.DeploymentList")
704 proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.apps.v1beta1.DeploymentRollback")
705 proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.apps.v1beta1.DeploymentRollback.UpdatedAnnotationsEntry")
706 proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.apps.v1beta1.DeploymentSpec")
707 proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.apps.v1beta1.DeploymentStatus")
708 proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.apps.v1beta1.DeploymentStrategy")
709 proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.apps.v1beta1.RollbackConfig")
710 proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.apps.v1beta1.RollingUpdateDeployment")
711 proto.RegisterType((*RollingUpdateStatefulSetStrategy)(nil), "k8s.io.api.apps.v1beta1.RollingUpdateStatefulSetStrategy")
712 proto.RegisterType((*Scale)(nil), "k8s.io.api.apps.v1beta1.Scale")
713 proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.apps.v1beta1.ScaleSpec")
714 proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.apps.v1beta1.ScaleStatus")
715 proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.apps.v1beta1.ScaleStatus.SelectorEntry")
716 proto.RegisterType((*StatefulSet)(nil), "k8s.io.api.apps.v1beta1.StatefulSet")
717 proto.RegisterType((*StatefulSetCondition)(nil), "k8s.io.api.apps.v1beta1.StatefulSetCondition")
718 proto.RegisterType((*StatefulSetList)(nil), "k8s.io.api.apps.v1beta1.StatefulSetList")
719 proto.RegisterType((*StatefulSetOrdinals)(nil), "k8s.io.api.apps.v1beta1.StatefulSetOrdinals")
720 proto.RegisterType((*StatefulSetPersistentVolumeClaimRetentionPolicy)(nil), "k8s.io.api.apps.v1beta1.StatefulSetPersistentVolumeClaimRetentionPolicy")
721 proto.RegisterType((*StatefulSetSpec)(nil), "k8s.io.api.apps.v1beta1.StatefulSetSpec")
722 proto.RegisterType((*StatefulSetStatus)(nil), "k8s.io.api.apps.v1beta1.StatefulSetStatus")
723 proto.RegisterType((*StatefulSetUpdateStrategy)(nil), "k8s.io.api.apps.v1beta1.StatefulSetUpdateStrategy")
724 }
725
726 func init() {
727 proto.RegisterFile("k8s.io/api/apps/v1beta1/generated.proto", fileDescriptor_2747f709ac7c95e7)
728 }
729
730 var fileDescriptor_2747f709ac7c95e7 = []byte{
731
732 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xcd, 0x6f, 0x1b, 0xc7,
733 0x15, 0xf7, 0x52, 0xa2, 0x44, 0x3d, 0x45, 0x94, 0x3d, 0x52, 0x2d, 0x46, 0x69, 0x25, 0x61, 0x63,
734 0xc4, 0x4a, 0x62, 0x2f, 0x63, 0x25, 0x0d, 0x12, 0xbb, 0x75, 0x21, 0x4a, 0x6e, 0xec, 0x40, 0x8a,
735 0x94, 0x91, 0x64, 0xa3, 0xe9, 0x07, 0x32, 0x22, 0xc7, 0xd4, 0x46, 0xfb, 0x85, 0xdd, 0x21, 0x63,
736 0xa2, 0x97, 0xfe, 0x01, 0x05, 0xd2, 0x73, 0xff, 0x8a, 0xf6, 0xd4, 0xa2, 0x45, 0x2f, 0x3d, 0x14,
737 0x3e, 0x06, 0xbd, 0x34, 0x27, 0xa2, 0x66, 0xae, 0xed, 0xad, 0xbd, 0x18, 0x28, 0x50, 0xcc, 0xec,
738 0xec, 0xf7, 0xae, 0xb4, 0x2c, 0x60, 0x01, 0xcd, 0x8d, 0x3b, 0xef, 0xbd, 0xdf, 0x7b, 0xf3, 0xe6,
739 0xbd, 0x37, 0xef, 0x0d, 0xe1, 0xfa, 0xe9, 0x7b, 0x9e, 0xa6, 0xdb, 0x4d, 0xe2, 0xe8, 0x4d, 0xe2,
740 0x38, 0x5e, 0xb3, 0x7f, 0xeb, 0x98, 0x32, 0x72, 0xab, 0xd9, 0xa5, 0x16, 0x75, 0x09, 0xa3, 0x1d,
741 0xcd, 0x71, 0x6d, 0x66, 0xa3, 0x25, 0x9f, 0x51, 0x23, 0x8e, 0xae, 0x71, 0x46, 0x4d, 0x32, 0x2e,
742 0xdf, 0xec, 0xea, 0xec, 0xa4, 0x77, 0xac, 0xb5, 0x6d, 0xb3, 0xd9, 0xb5, 0xbb, 0x76, 0x53, 0xf0,
743 0x1f, 0xf7, 0x1e, 0x8b, 0x2f, 0xf1, 0x21, 0x7e, 0xf9, 0x38, 0xcb, 0x6a, 0x4c, 0x61, 0xdb, 0x76,
744 0x69, 0xb3, 0x9f, 0xd1, 0xb5, 0xfc, 0x4e, 0xc4, 0x63, 0x92, 0xf6, 0x89, 0x6e, 0x51, 0x77, 0xd0,
745 0x74, 0x4e, 0xbb, 0x7c, 0xc1, 0x6b, 0x9a, 0x94, 0x91, 0x3c, 0xa9, 0x66, 0x91, 0x94, 0xdb, 0xb3,
746 0x98, 0x6e, 0xd2, 0x8c, 0xc0, 0xbb, 0xe7, 0x09, 0x78, 0xed, 0x13, 0x6a, 0x92, 0x8c, 0xdc, 0xdb,
747 0x45, 0x72, 0x3d, 0xa6, 0x1b, 0x4d, 0xdd, 0x62, 0x1e, 0x73, 0xd3, 0x42, 0xea, 0xbf, 0x15, 0x40,
748 0x5b, 0xb6, 0xc5, 0x5c, 0xdb, 0x30, 0xa8, 0x8b, 0x69, 0x5f, 0xf7, 0x74, 0xdb, 0x42, 0x9f, 0x42,
749 0x8d, 0xef, 0xa7, 0x43, 0x18, 0x69, 0x28, 0x6b, 0xca, 0xfa, 0xec, 0xc6, 0x5b, 0x5a, 0xe4, 0xe9,
750 0x10, 0x5e, 0x73, 0x4e, 0xbb, 0x7c, 0xc1, 0xd3, 0x38, 0xb7, 0xd6, 0xbf, 0xa5, 0xed, 0x1d, 0x7f,
751 0x46, 0xdb, 0x6c, 0x97, 0x32, 0xd2, 0x42, 0x4f, 0x87, 0xab, 0x97, 0x46, 0xc3, 0x55, 0x88, 0xd6,
752 0x70, 0x88, 0x8a, 0xf6, 0x60, 0x52, 0xa0, 0x57, 0x04, 0xfa, 0xcd, 0x42, 0x74, 0xb9, 0x69, 0x0d,
753 0x93, 0xcf, 0xef, 0x3d, 0x61, 0xd4, 0xe2, 0xe6, 0xb5, 0x5e, 0x92, 0xd0, 0x93, 0xdb, 0x84, 0x11,
754 0x2c, 0x80, 0xd0, 0x0d, 0xa8, 0xb9, 0xd2, 0xfc, 0xc6, 0xc4, 0x9a, 0xb2, 0x3e, 0xd1, 0xba, 0x2c,
755 0xb9, 0x6a, 0xc1, 0xb6, 0x70, 0xc8, 0xa1, 0x3e, 0x55, 0xe0, 0x6a, 0x76, 0xdf, 0x3b, 0xba, 0xc7,
756 0xd0, 0x4f, 0x32, 0x7b, 0xd7, 0xca, 0xed, 0x9d, 0x4b, 0x8b, 0x9d, 0x87, 0x8a, 0x83, 0x95, 0xd8,
757 0xbe, 0xf7, 0xa1, 0xaa, 0x33, 0x6a, 0x7a, 0x8d, 0xca, 0xda, 0xc4, 0xfa, 0xec, 0xc6, 0x9b, 0x5a,
758 0x41, 0x00, 0x6b, 0x59, 0xeb, 0x5a, 0x73, 0x12, 0xb7, 0xfa, 0x80, 0x23, 0x60, 0x1f, 0x48, 0xfd,
759 0x65, 0x05, 0x60, 0x9b, 0x3a, 0x86, 0x3d, 0x30, 0xa9, 0xc5, 0x2e, 0xe0, 0xe8, 0x1e, 0xc0, 0xa4,
760 0xe7, 0xd0, 0xb6, 0x3c, 0xba, 0xeb, 0x85, 0x3b, 0x88, 0x8c, 0x3a, 0x70, 0x68, 0x3b, 0x3a, 0x34,
761 0xfe, 0x85, 0x05, 0x04, 0xfa, 0x18, 0xa6, 0x3c, 0x46, 0x58, 0xcf, 0x13, 0x47, 0x36, 0xbb, 0xf1,
762 0x7a, 0x19, 0x30, 0x21, 0xd0, 0xaa, 0x4b, 0xb8, 0x29, 0xff, 0x1b, 0x4b, 0x20, 0xf5, 0x6f, 0x13,
763 0xb0, 0x10, 0x31, 0x6f, 0xd9, 0x56, 0x47, 0x67, 0x3c, 0xa4, 0xef, 0xc0, 0x24, 0x1b, 0x38, 0x54,
764 0xf8, 0x64, 0xa6, 0x75, 0x3d, 0x30, 0xe6, 0x70, 0xe0, 0xd0, 0xe7, 0xc3, 0xd5, 0xa5, 0x1c, 0x11,
765 0x4e, 0xc2, 0x42, 0x08, 0xed, 0x84, 0x76, 0x56, 0x84, 0xf8, 0x3b, 0x49, 0xe5, 0xcf, 0x87, 0xab,
766 0x39, 0x05, 0x44, 0x0b, 0x91, 0x92, 0x26, 0xa2, 0xcf, 0xa0, 0x6e, 0x10, 0x8f, 0x1d, 0x39, 0x1d,
767 0xc2, 0xe8, 0xa1, 0x6e, 0xd2, 0xc6, 0x94, 0xd8, 0xfd, 0x1b, 0xe5, 0x0e, 0x8a, 0x4b, 0xb4, 0xae,
768 0x4a, 0x0b, 0xea, 0x3b, 0x09, 0x24, 0x9c, 0x42, 0x46, 0x7d, 0x40, 0x7c, 0xe5, 0xd0, 0x25, 0x96,
769 0xe7, 0xef, 0x8a, 0xeb, 0x9b, 0x1e, 0x5b, 0xdf, 0xb2, 0xd4, 0x87, 0x76, 0x32, 0x68, 0x38, 0x47,
770 0x03, 0x7a, 0x0d, 0xa6, 0x5c, 0x4a, 0x3c, 0xdb, 0x6a, 0x4c, 0x0a, 0x8f, 0x85, 0xc7, 0x85, 0xc5,
771 0x2a, 0x96, 0x54, 0xf4, 0x3a, 0x4c, 0x9b, 0xd4, 0xf3, 0x48, 0x97, 0x36, 0xaa, 0x82, 0x71, 0x5e,
772 0x32, 0x4e, 0xef, 0xfa, 0xcb, 0x38, 0xa0, 0xab, 0xbf, 0x57, 0xa0, 0x1e, 0x1d, 0xd3, 0x05, 0xe4,
773 0xea, 0xfd, 0x64, 0xae, 0xbe, 0x5a, 0x22, 0x38, 0x0b, 0x72, 0xf4, 0x1f, 0x15, 0x40, 0x11, 0x13,
774 0xb6, 0x0d, 0xe3, 0x98, 0xb4, 0x4f, 0xd1, 0x1a, 0x4c, 0x5a, 0xc4, 0x0c, 0x62, 0x32, 0x4c, 0x90,
775 0x8f, 0x88, 0x49, 0xb1, 0xa0, 0xa0, 0x2f, 0x14, 0x40, 0x3d, 0x71, 0x9a, 0x9d, 0x4d, 0xcb, 0xb2,
776 0x19, 0xe1, 0x0e, 0x0e, 0x0c, 0xda, 0x2a, 0x61, 0x50, 0xa0, 0x4b, 0x3b, 0xca, 0xa0, 0xdc, 0xb3,
777 0x98, 0x3b, 0x88, 0x0e, 0x36, 0xcb, 0x80, 0x73, 0x54, 0xa3, 0x1f, 0x03, 0xb8, 0x12, 0xf3, 0xd0,
778 0x96, 0x69, 0x5b, 0x5c, 0x03, 0x02, 0xf5, 0x5b, 0xb6, 0xf5, 0x58, 0xef, 0x46, 0x85, 0x05, 0x87,
779 0x10, 0x38, 0x06, 0xb7, 0x7c, 0x0f, 0x96, 0x0a, 0xec, 0x44, 0x97, 0x61, 0xe2, 0x94, 0x0e, 0x7c,
780 0x57, 0x61, 0xfe, 0x13, 0x2d, 0x42, 0xb5, 0x4f, 0x8c, 0x1e, 0xf5, 0x73, 0x12, 0xfb, 0x1f, 0xb7,
781 0x2b, 0xef, 0x29, 0xea, 0x6f, 0xaa, 0xf1, 0x48, 0xe1, 0xf5, 0x06, 0xad, 0xf3, 0xeb, 0xc1, 0x31,
782 0xf4, 0x36, 0xf1, 0x04, 0x46, 0xb5, 0xf5, 0x92, 0x7f, 0x35, 0xf8, 0x6b, 0x38, 0xa4, 0xa2, 0x9f,
783 0x42, 0xcd, 0xa3, 0x06, 0x6d, 0x33, 0xdb, 0x95, 0x25, 0xee, 0xed, 0x92, 0x31, 0x45, 0x8e, 0xa9,
784 0x71, 0x20, 0x45, 0x7d, 0xf8, 0xe0, 0x0b, 0x87, 0x90, 0xe8, 0x63, 0xa8, 0x31, 0x6a, 0x3a, 0x06,
785 0x61, 0x54, 0x7a, 0x2f, 0x11, 0x57, 0xbc, 0x76, 0x70, 0xb0, 0x7d, 0xbb, 0x73, 0x28, 0xd9, 0x44,
786 0xf5, 0x0c, 0xe3, 0x34, 0x58, 0xc5, 0x21, 0x0c, 0xfa, 0x11, 0xd4, 0x3c, 0xc6, 0x6f, 0xf5, 0xee,
787 0x40, 0x64, 0xdb, 0x59, 0xd7, 0x4a, 0xbc, 0x8e, 0xfa, 0x22, 0x11, 0x74, 0xb0, 0x82, 0x43, 0x38,
788 0xb4, 0x09, 0xf3, 0xa6, 0x6e, 0x61, 0x4a, 0x3a, 0x83, 0x03, 0xda, 0xb6, 0xad, 0x8e, 0x27, 0xd2,
789 0xb4, 0xda, 0x5a, 0x92, 0x42, 0xf3, 0xbb, 0x49, 0x32, 0x4e, 0xf3, 0xa3, 0x1d, 0x58, 0x0c, 0xae,
790 0xdd, 0xfb, 0xba, 0xc7, 0x6c, 0x77, 0xb0, 0xa3, 0x9b, 0x3a, 0x13, 0x35, 0xaf, 0xda, 0x6a, 0x8c,
791 0x86, 0xab, 0x8b, 0x38, 0x87, 0x8e, 0x73, 0xa5, 0x78, 0x5d, 0x71, 0x48, 0xcf, 0xa3, 0x1d, 0x51,
792 0xc3, 0x6a, 0x51, 0x5d, 0xd9, 0x17, 0xab, 0x58, 0x52, 0xd1, 0xa3, 0x44, 0x98, 0xd6, 0xc6, 0x0b,
793 0xd3, 0x7a, 0x71, 0x88, 0xa2, 0x23, 0x58, 0x72, 0x5c, 0xbb, 0xeb, 0x52, 0xcf, 0xdb, 0xa6, 0xa4,
794 0x63, 0xe8, 0x16, 0x0d, 0x3c, 0x33, 0x23, 0x76, 0xf4, 0xca, 0x68, 0xb8, 0xba, 0xb4, 0x9f, 0xcf,
795 0x82, 0x8b, 0x64, 0xd5, 0x3f, 0x4f, 0xc2, 0xe5, 0xf4, 0x1d, 0x87, 0x3e, 0x04, 0x64, 0x1f, 0x7b,
796 0xd4, 0xed, 0xd3, 0xce, 0x07, 0x7e, 0xe3, 0xc6, 0xbb, 0x1b, 0x45, 0x74, 0x37, 0x61, 0xde, 0xee,
797 0x65, 0x38, 0x70, 0x8e, 0x94, 0xdf, 0x1f, 0xc9, 0x04, 0xa8, 0x08, 0x43, 0x63, 0xfd, 0x51, 0x26,
798 0x09, 0x36, 0x61, 0x5e, 0xe6, 0x7e, 0x40, 0x14, 0xc1, 0x1a, 0x3b, 0xf7, 0xa3, 0x24, 0x19, 0xa7,
799 0xf9, 0xd1, 0x1d, 0x98, 0x73, 0x79, 0x1c, 0x84, 0x00, 0xd3, 0x02, 0xe0, 0x5b, 0x12, 0x60, 0x0e,
800 0xc7, 0x89, 0x38, 0xc9, 0x8b, 0x3e, 0x80, 0x2b, 0xa4, 0x4f, 0x74, 0x83, 0x1c, 0x1b, 0x34, 0x04,
801 0x98, 0x14, 0x00, 0x2f, 0x4b, 0x80, 0x2b, 0x9b, 0x69, 0x06, 0x9c, 0x95, 0x41, 0xbb, 0xb0, 0xd0,
802 0xb3, 0xb2, 0x50, 0x7e, 0x10, 0xbf, 0x22, 0xa1, 0x16, 0x8e, 0xb2, 0x2c, 0x38, 0x4f, 0x0e, 0x7d,
803 0x0a, 0xd0, 0x0e, 0x6e, 0x75, 0xaf, 0x31, 0x25, 0xca, 0xf0, 0x8d, 0x12, 0xc9, 0x16, 0xb6, 0x02,
804 0x51, 0x09, 0x0c, 0x97, 0x3c, 0x1c, 0xc3, 0x44, 0xb7, 0xa1, 0xde, 0xb6, 0x0d, 0x43, 0x44, 0xfe,
805 0x96, 0xdd, 0xb3, 0x98, 0x08, 0xde, 0x6a, 0x0b, 0xf1, 0xcb, 0x7e, 0x2b, 0x41, 0xc1, 0x29, 0x4e,
806 0xf5, 0x8f, 0x4a, 0xfc, 0x9a, 0x09, 0xd2, 0x19, 0xdd, 0x4e, 0xb4, 0x3e, 0xaf, 0xa5, 0x5a, 0x9f,
807 0xab, 0x59, 0x89, 0x58, 0xe7, 0xa3, 0xc3, 0x1c, 0x0f, 0x7e, 0xdd, 0xea, 0xfa, 0x07, 0x2e, 0x4b,
808 0xe2, 0x5b, 0x67, 0xa6, 0x52, 0xc8, 0x1d, 0xbb, 0x18, 0xaf, 0x88, 0x33, 0x8f, 0x13, 0x71, 0x12,
809 0x59, 0xbd, 0x0b, 0xf5, 0x64, 0x1e, 0x26, 0x7a, 0x7a, 0xe5, 0xdc, 0x9e, 0xfe, 0x6b, 0x05, 0x96,
810 0x0a, 0xb4, 0x23, 0x03, 0xea, 0x26, 0x79, 0x12, 0x3b, 0xe6, 0x73, 0x7b, 0x63, 0x3e, 0x35, 0x69,
811 0xfe, 0xd4, 0xa4, 0x3d, 0xb0, 0xd8, 0x9e, 0x7b, 0xc0, 0x5c, 0xdd, 0xea, 0xfa, 0xe7, 0xb0, 0x9b,
812 0xc0, 0xc2, 0x29, 0x6c, 0xf4, 0x09, 0xd4, 0x4c, 0xf2, 0xe4, 0xa0, 0xe7, 0x76, 0xf3, 0xfc, 0x55,
813 0x4e, 0x8f, 0xb8, 0x3f, 0x76, 0x25, 0x0a, 0x0e, 0xf1, 0xd4, 0x3f, 0x29, 0xb0, 0x96, 0xd8, 0x25,
814 0xaf, 0x15, 0xf4, 0x71, 0xcf, 0x38, 0xa0, 0xd1, 0x89, 0xbf, 0x09, 0x33, 0x0e, 0x71, 0x99, 0x1e,
815 0xd6, 0x8b, 0x6a, 0x6b, 0x6e, 0x34, 0x5c, 0x9d, 0xd9, 0x0f, 0x16, 0x71, 0x44, 0xcf, 0xf1, 0x4d,
816 0xe5, 0xc5, 0xf9, 0x46, 0xfd, 0x8f, 0x02, 0xd5, 0x83, 0x36, 0x31, 0xe8, 0x05, 0x4c, 0x2a, 0xdb,
817 0x89, 0x49, 0x45, 0x2d, 0x8c, 0x59, 0x61, 0x4f, 0xe1, 0x90, 0xb2, 0x93, 0x1a, 0x52, 0xae, 0x9d,
818 0x83, 0x73, 0xf6, 0x7c, 0xf2, 0x3e, 0xcc, 0x84, 0xea, 0x12, 0x45, 0x59, 0x39, 0xaf, 0x28, 0xab,
819 0xbf, 0xae, 0xc0, 0x6c, 0x4c, 0xc5, 0x78, 0xd2, 0xdc, 0xdd, 0xb1, 0xbe, 0x86, 0x17, 0xae, 0x8d,
820 0x32, 0x1b, 0xd1, 0x82, 0x1e, 0xc6, 0x6f, 0x17, 0xa3, 0x66, 0x21, 0xdb, 0xda, 0xdc, 0x85, 0x3a,
821 0x23, 0x6e, 0x97, 0xb2, 0x80, 0x26, 0x1c, 0x36, 0x13, 0xcd, 0x2a, 0x87, 0x09, 0x2a, 0x4e, 0x71,
822 0x2f, 0xdf, 0x81, 0xb9, 0x84, 0xb2, 0xb1, 0x7a, 0xbe, 0x2f, 0xb8, 0x73, 0xa2, 0x54, 0xb8, 0x80,
823 0xe8, 0xfa, 0x30, 0x11, 0x5d, 0xeb, 0xc5, 0xce, 0x8c, 0x25, 0x68, 0x51, 0x8c, 0xe1, 0x54, 0x8c,
824 0xbd, 0x51, 0x0a, 0xed, 0xec, 0x48, 0xfb, 0x67, 0x05, 0x16, 0x63, 0xdc, 0xd1, 0x28, 0xfc, 0xbd,
825 0xc4, 0x7d, 0xb0, 0x9e, 0xba, 0x0f, 0x1a, 0x79, 0x32, 0x2f, 0x6c, 0x16, 0xce, 0x9f, 0x4f, 0x27,
826 0xfe, 0x1f, 0xe7, 0xd3, 0x3f, 0x28, 0x30, 0x1f, 0xf3, 0xdd, 0x05, 0x0c, 0xa8, 0x0f, 0x92, 0x03,
827 0xea, 0xb5, 0x32, 0x41, 0x53, 0x30, 0xa1, 0xde, 0x86, 0x85, 0x18, 0xd3, 0x9e, 0xdb, 0xd1, 0x2d,
828 0x62, 0x78, 0xe8, 0x55, 0xa8, 0x7a, 0x8c, 0xb8, 0x2c, 0xb8, 0x44, 0x02, 0xd9, 0x03, 0xbe, 0x88,
829 0x7d, 0x9a, 0xfa, 0x2f, 0x05, 0x9a, 0x31, 0xe1, 0x7d, 0xea, 0x7a, 0xba, 0xc7, 0xa8, 0xc5, 0x1e,
830 0xda, 0x46, 0xcf, 0xa4, 0x5b, 0x06, 0xd1, 0x4d, 0x4c, 0xf9, 0x82, 0x6e, 0x5b, 0xfb, 0xb6, 0xa1,
831 0xb7, 0x07, 0x88, 0xc0, 0xec, 0xe7, 0x27, 0xd4, 0xda, 0xa6, 0x06, 0x65, 0xb4, 0x23, 0x43, 0xf1,
832 0x07, 0x12, 0x7e, 0xf6, 0x51, 0x44, 0x7a, 0x3e, 0x5c, 0x5d, 0x2f, 0x83, 0x28, 0x22, 0x34, 0x8e,
833 0x89, 0x7e, 0x06, 0xc0, 0x3f, 0x45, 0x2d, 0xeb, 0xc8, 0x60, 0xbd, 0x1b, 0x64, 0xf4, 0xa3, 0x90,
834 0x32, 0x96, 0x82, 0x18, 0xa2, 0xfa, 0xdb, 0x5a, 0xe2, 0xbc, 0xbf, 0xf1, 0x63, 0xe6, 0xcf, 0x61,
835 0xb1, 0x1f, 0x79, 0x27, 0x60, 0xe0, 0x6d, 0xf9, 0x44, 0xfa, 0xe9, 0x2e, 0x84, 0xcf, 0xf3, 0x6b,
836 0xeb, 0xdb, 0x52, 0xc9, 0xe2, 0xc3, 0x1c, 0x38, 0x9c, 0xab, 0x04, 0x7d, 0x17, 0x66, 0xf9, 0x48,
837 0xa3, 0xb7, 0xe9, 0x47, 0xc4, 0x0c, 0x72, 0x71, 0x21, 0x88, 0x97, 0x83, 0x88, 0x84, 0xe3, 0x7c,
838 0xe8, 0x04, 0x16, 0x1c, 0xbb, 0xb3, 0x4b, 0x2c, 0xd2, 0xa5, 0xbc, 0x11, 0xf4, 0x8f, 0x52, 0xcc,
839 0x9e, 0x33, 0xad, 0x77, 0x83, 0xf6, 0x7f, 0x3f, 0xcb, 0xf2, 0x9c, 0x0f, 0x71, 0xd9, 0x65, 0x11,
840 0x04, 0x79, 0x90, 0xc8, 0x85, 0x7a, 0x4f, 0xf6, 0x63, 0x72, 0x14, 0xf7, 0x1f, 0xd9, 0x36, 0xca,
841 0x24, 0xe5, 0x51, 0x42, 0x32, 0xba, 0x30, 0x93, 0xeb, 0x38, 0xa5, 0xa1, 0x70, 0xb4, 0xae, 0xfd,
842 0x4f, 0xa3, 0x75, 0xce, 0xac, 0x3f, 0x33, 0xe6, 0xac, 0xff, 0x17, 0x05, 0xae, 0x39, 0x25, 0x72,
843 0xa9, 0x01, 0xc2, 0x37, 0xf7, 0xcb, 0xf8, 0xa6, 0x4c, 0x6e, 0xb6, 0xd6, 0x47, 0xc3, 0xd5, 0x6b,
844 0x65, 0x38, 0x71, 0x29, 0xfb, 0xd0, 0x43, 0xa8, 0xd9, 0xb2, 0x06, 0x36, 0x66, 0x85, 0xad, 0x37,
845 0xca, 0xd8, 0x1a, 0xd4, 0x4d, 0x3f, 0x2d, 0x83, 0x2f, 0x1c, 0x62, 0xa9, 0xbf, 0xab, 0xc2, 0x95,
846 0xcc, 0x0d, 0x8e, 0x7e, 0x78, 0xc6, 0x9c, 0x7f, 0xf5, 0x85, 0xcd, 0xf8, 0x99, 0x01, 0x7d, 0x62,
847 0x8c, 0x01, 0x7d, 0x13, 0xe6, 0xdb, 0x3d, 0xd7, 0xa5, 0x16, 0x4b, 0x8d, 0xe7, 0x61, 0xb0, 0x6c,
848 0x25, 0xc9, 0x38, 0xcd, 0x9f, 0xf7, 0xc6, 0x50, 0x1d, 0xf3, 0x8d, 0x21, 0x6e, 0x85, 0x9c, 0x13,
849 0xfd, 0xd4, 0xce, 0x5a, 0x21, 0xc7, 0xc5, 0x34, 0x3f, 0x6f, 0x5a, 0x7d, 0xd4, 0x10, 0x61, 0x3a,
850 0xd9, 0xb4, 0x1e, 0x25, 0xa8, 0x38, 0xc5, 0x9d, 0x33, 0xaf, 0xcf, 0x94, 0x9d, 0xd7, 0x11, 0x49,
851 0xbc, 0x26, 0x80, 0xa8, 0xa3, 0x37, 0xcb, 0xc4, 0x59, 0xf9, 0xe7, 0x84, 0xdc, 0x87, 0x94, 0xd9,
852 0xf1, 0x1f, 0x52, 0xd4, 0xbf, 0x2a, 0xf0, 0x72, 0x61, 0xc5, 0x42, 0x9b, 0x89, 0x96, 0xf2, 0x66,
853 0xaa, 0xa5, 0xfc, 0x4e, 0xa1, 0x60, 0xac, 0xaf, 0x74, 0xf3, 0x5f, 0x1a, 0xde, 0x2f, 0xf7, 0xd2,
854 0x90, 0x33, 0x05, 0x9f, 0xff, 0xe4, 0xd0, 0xfa, 0xfe, 0xd3, 0x67, 0x2b, 0x97, 0xbe, 0x7c, 0xb6,
855 0x72, 0xe9, 0xab, 0x67, 0x2b, 0x97, 0x7e, 0x31, 0x5a, 0x51, 0x9e, 0x8e, 0x56, 0x94, 0x2f, 0x47,
856 0x2b, 0xca, 0x57, 0xa3, 0x15, 0xe5, 0xef, 0xa3, 0x15, 0xe5, 0x57, 0x5f, 0xaf, 0x5c, 0xfa, 0x64,
857 0xa9, 0xe0, 0xdf, 0xe8, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0xb9, 0xc9, 0xe6, 0x8c, 0xa7, 0x1e,
858 0x00, 0x00,
859 }
860
861 func (m *ControllerRevision) Marshal() (dAtA []byte, err error) {
862 size := m.Size()
863 dAtA = make([]byte, size)
864 n, err := m.MarshalToSizedBuffer(dAtA[:size])
865 if err != nil {
866 return nil, err
867 }
868 return dAtA[:n], nil
869 }
870
871 func (m *ControllerRevision) MarshalTo(dAtA []byte) (int, error) {
872 size := m.Size()
873 return m.MarshalToSizedBuffer(dAtA[:size])
874 }
875
876 func (m *ControllerRevision) MarshalToSizedBuffer(dAtA []byte) (int, error) {
877 i := len(dAtA)
878 _ = i
879 var l int
880 _ = l
881 i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
882 i--
883 dAtA[i] = 0x18
884 {
885 size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
886 if err != nil {
887 return 0, err
888 }
889 i -= size
890 i = encodeVarintGenerated(dAtA, i, uint64(size))
891 }
892 i--
893 dAtA[i] = 0x12
894 {
895 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
896 if err != nil {
897 return 0, err
898 }
899 i -= size
900 i = encodeVarintGenerated(dAtA, i, uint64(size))
901 }
902 i--
903 dAtA[i] = 0xa
904 return len(dAtA) - i, nil
905 }
906
907 func (m *ControllerRevisionList) Marshal() (dAtA []byte, err error) {
908 size := m.Size()
909 dAtA = make([]byte, size)
910 n, err := m.MarshalToSizedBuffer(dAtA[:size])
911 if err != nil {
912 return nil, err
913 }
914 return dAtA[:n], nil
915 }
916
917 func (m *ControllerRevisionList) MarshalTo(dAtA []byte) (int, error) {
918 size := m.Size()
919 return m.MarshalToSizedBuffer(dAtA[:size])
920 }
921
922 func (m *ControllerRevisionList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
923 i := len(dAtA)
924 _ = i
925 var l int
926 _ = l
927 if len(m.Items) > 0 {
928 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
929 {
930 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
931 if err != nil {
932 return 0, err
933 }
934 i -= size
935 i = encodeVarintGenerated(dAtA, i, uint64(size))
936 }
937 i--
938 dAtA[i] = 0x12
939 }
940 }
941 {
942 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
943 if err != nil {
944 return 0, err
945 }
946 i -= size
947 i = encodeVarintGenerated(dAtA, i, uint64(size))
948 }
949 i--
950 dAtA[i] = 0xa
951 return len(dAtA) - i, nil
952 }
953
954 func (m *Deployment) Marshal() (dAtA []byte, err error) {
955 size := m.Size()
956 dAtA = make([]byte, size)
957 n, err := m.MarshalToSizedBuffer(dAtA[:size])
958 if err != nil {
959 return nil, err
960 }
961 return dAtA[:n], nil
962 }
963
964 func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
965 size := m.Size()
966 return m.MarshalToSizedBuffer(dAtA[:size])
967 }
968
969 func (m *Deployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
970 i := len(dAtA)
971 _ = i
972 var l int
973 _ = l
974 {
975 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
976 if err != nil {
977 return 0, err
978 }
979 i -= size
980 i = encodeVarintGenerated(dAtA, i, uint64(size))
981 }
982 i--
983 dAtA[i] = 0x1a
984 {
985 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
986 if err != nil {
987 return 0, err
988 }
989 i -= size
990 i = encodeVarintGenerated(dAtA, i, uint64(size))
991 }
992 i--
993 dAtA[i] = 0x12
994 {
995 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
996 if err != nil {
997 return 0, err
998 }
999 i -= size
1000 i = encodeVarintGenerated(dAtA, i, uint64(size))
1001 }
1002 i--
1003 dAtA[i] = 0xa
1004 return len(dAtA) - i, nil
1005 }
1006
1007 func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
1008 size := m.Size()
1009 dAtA = make([]byte, size)
1010 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1011 if err != nil {
1012 return nil, err
1013 }
1014 return dAtA[:n], nil
1015 }
1016
1017 func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
1018 size := m.Size()
1019 return m.MarshalToSizedBuffer(dAtA[:size])
1020 }
1021
1022 func (m *DeploymentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1023 i := len(dAtA)
1024 _ = i
1025 var l int
1026 _ = l
1027 {
1028 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1029 if err != nil {
1030 return 0, err
1031 }
1032 i -= size
1033 i = encodeVarintGenerated(dAtA, i, uint64(size))
1034 }
1035 i--
1036 dAtA[i] = 0x3a
1037 {
1038 size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
1039 if err != nil {
1040 return 0, err
1041 }
1042 i -= size
1043 i = encodeVarintGenerated(dAtA, i, uint64(size))
1044 }
1045 i--
1046 dAtA[i] = 0x32
1047 i -= len(m.Message)
1048 copy(dAtA[i:], m.Message)
1049 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1050 i--
1051 dAtA[i] = 0x2a
1052 i -= len(m.Reason)
1053 copy(dAtA[i:], m.Reason)
1054 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1055 i--
1056 dAtA[i] = 0x22
1057 i -= len(m.Status)
1058 copy(dAtA[i:], m.Status)
1059 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1060 i--
1061 dAtA[i] = 0x12
1062 i -= len(m.Type)
1063 copy(dAtA[i:], m.Type)
1064 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1065 i--
1066 dAtA[i] = 0xa
1067 return len(dAtA) - i, nil
1068 }
1069
1070 func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
1071 size := m.Size()
1072 dAtA = make([]byte, size)
1073 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1074 if err != nil {
1075 return nil, err
1076 }
1077 return dAtA[:n], nil
1078 }
1079
1080 func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
1081 size := m.Size()
1082 return m.MarshalToSizedBuffer(dAtA[:size])
1083 }
1084
1085 func (m *DeploymentList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1086 i := len(dAtA)
1087 _ = i
1088 var l int
1089 _ = l
1090 if len(m.Items) > 0 {
1091 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1092 {
1093 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1094 if err != nil {
1095 return 0, err
1096 }
1097 i -= size
1098 i = encodeVarintGenerated(dAtA, i, uint64(size))
1099 }
1100 i--
1101 dAtA[i] = 0x12
1102 }
1103 }
1104 {
1105 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1106 if err != nil {
1107 return 0, err
1108 }
1109 i -= size
1110 i = encodeVarintGenerated(dAtA, i, uint64(size))
1111 }
1112 i--
1113 dAtA[i] = 0xa
1114 return len(dAtA) - i, nil
1115 }
1116
1117 func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) {
1118 size := m.Size()
1119 dAtA = make([]byte, size)
1120 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1121 if err != nil {
1122 return nil, err
1123 }
1124 return dAtA[:n], nil
1125 }
1126
1127 func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) {
1128 size := m.Size()
1129 return m.MarshalToSizedBuffer(dAtA[:size])
1130 }
1131
1132 func (m *DeploymentRollback) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1133 i := len(dAtA)
1134 _ = i
1135 var l int
1136 _ = l
1137 {
1138 size, err := m.RollbackTo.MarshalToSizedBuffer(dAtA[:i])
1139 if err != nil {
1140 return 0, err
1141 }
1142 i -= size
1143 i = encodeVarintGenerated(dAtA, i, uint64(size))
1144 }
1145 i--
1146 dAtA[i] = 0x1a
1147 if len(m.UpdatedAnnotations) > 0 {
1148 keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations))
1149 for k := range m.UpdatedAnnotations {
1150 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k))
1151 }
1152 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
1153 for iNdEx := len(keysForUpdatedAnnotations) - 1; iNdEx >= 0; iNdEx-- {
1154 v := m.UpdatedAnnotations[string(keysForUpdatedAnnotations[iNdEx])]
1155 baseI := i
1156 i -= len(v)
1157 copy(dAtA[i:], v)
1158 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1159 i--
1160 dAtA[i] = 0x12
1161 i -= len(keysForUpdatedAnnotations[iNdEx])
1162 copy(dAtA[i:], keysForUpdatedAnnotations[iNdEx])
1163 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForUpdatedAnnotations[iNdEx])))
1164 i--
1165 dAtA[i] = 0xa
1166 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
1167 i--
1168 dAtA[i] = 0x12
1169 }
1170 }
1171 i -= len(m.Name)
1172 copy(dAtA[i:], m.Name)
1173 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1174 i--
1175 dAtA[i] = 0xa
1176 return len(dAtA) - i, nil
1177 }
1178
1179 func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
1180 size := m.Size()
1181 dAtA = make([]byte, size)
1182 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1183 if err != nil {
1184 return nil, err
1185 }
1186 return dAtA[:n], nil
1187 }
1188
1189 func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
1190 size := m.Size()
1191 return m.MarshalToSizedBuffer(dAtA[:size])
1192 }
1193
1194 func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1195 i := len(dAtA)
1196 _ = i
1197 var l int
1198 _ = l
1199 if m.ProgressDeadlineSeconds != nil {
1200 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
1201 i--
1202 dAtA[i] = 0x48
1203 }
1204 if m.RollbackTo != nil {
1205 {
1206 size, err := m.RollbackTo.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] = 0x42
1215 }
1216 i--
1217 if m.Paused {
1218 dAtA[i] = 1
1219 } else {
1220 dAtA[i] = 0
1221 }
1222 i--
1223 dAtA[i] = 0x38
1224 if m.RevisionHistoryLimit != nil {
1225 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
1226 i--
1227 dAtA[i] = 0x30
1228 }
1229 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
1230 i--
1231 dAtA[i] = 0x28
1232 {
1233 size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i])
1234 if err != nil {
1235 return 0, err
1236 }
1237 i -= size
1238 i = encodeVarintGenerated(dAtA, i, uint64(size))
1239 }
1240 i--
1241 dAtA[i] = 0x22
1242 {
1243 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
1244 if err != nil {
1245 return 0, err
1246 }
1247 i -= size
1248 i = encodeVarintGenerated(dAtA, i, uint64(size))
1249 }
1250 i--
1251 dAtA[i] = 0x1a
1252 if m.Selector != nil {
1253 {
1254 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
1255 if err != nil {
1256 return 0, err
1257 }
1258 i -= size
1259 i = encodeVarintGenerated(dAtA, i, uint64(size))
1260 }
1261 i--
1262 dAtA[i] = 0x12
1263 }
1264 if m.Replicas != nil {
1265 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
1266 i--
1267 dAtA[i] = 0x8
1268 }
1269 return len(dAtA) - i, nil
1270 }
1271
1272 func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
1273 size := m.Size()
1274 dAtA = make([]byte, size)
1275 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1276 if err != nil {
1277 return nil, err
1278 }
1279 return dAtA[:n], nil
1280 }
1281
1282 func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
1283 size := m.Size()
1284 return m.MarshalToSizedBuffer(dAtA[:size])
1285 }
1286
1287 func (m *DeploymentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1288 i := len(dAtA)
1289 _ = i
1290 var l int
1291 _ = l
1292 if m.CollisionCount != nil {
1293 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1294 i--
1295 dAtA[i] = 0x40
1296 }
1297 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
1298 i--
1299 dAtA[i] = 0x38
1300 if len(m.Conditions) > 0 {
1301 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1302 {
1303 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1304 if err != nil {
1305 return 0, err
1306 }
1307 i -= size
1308 i = encodeVarintGenerated(dAtA, i, uint64(size))
1309 }
1310 i--
1311 dAtA[i] = 0x32
1312 }
1313 }
1314 i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
1315 i--
1316 dAtA[i] = 0x28
1317 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1318 i--
1319 dAtA[i] = 0x20
1320 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
1321 i--
1322 dAtA[i] = 0x18
1323 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1324 i--
1325 dAtA[i] = 0x10
1326 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
1327 i--
1328 dAtA[i] = 0x8
1329 return len(dAtA) - i, nil
1330 }
1331
1332 func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
1333 size := m.Size()
1334 dAtA = make([]byte, size)
1335 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1336 if err != nil {
1337 return nil, err
1338 }
1339 return dAtA[:n], nil
1340 }
1341
1342 func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
1343 size := m.Size()
1344 return m.MarshalToSizedBuffer(dAtA[:size])
1345 }
1346
1347 func (m *DeploymentStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1348 i := len(dAtA)
1349 _ = i
1350 var l int
1351 _ = l
1352 if m.RollingUpdate != nil {
1353 {
1354 size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
1355 if err != nil {
1356 return 0, err
1357 }
1358 i -= size
1359 i = encodeVarintGenerated(dAtA, i, uint64(size))
1360 }
1361 i--
1362 dAtA[i] = 0x12
1363 }
1364 i -= len(m.Type)
1365 copy(dAtA[i:], m.Type)
1366 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1367 i--
1368 dAtA[i] = 0xa
1369 return len(dAtA) - i, nil
1370 }
1371
1372 func (m *RollbackConfig) Marshal() (dAtA []byte, err error) {
1373 size := m.Size()
1374 dAtA = make([]byte, size)
1375 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1376 if err != nil {
1377 return nil, err
1378 }
1379 return dAtA[:n], nil
1380 }
1381
1382 func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) {
1383 size := m.Size()
1384 return m.MarshalToSizedBuffer(dAtA[:size])
1385 }
1386
1387 func (m *RollbackConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1388 i := len(dAtA)
1389 _ = i
1390 var l int
1391 _ = l
1392 i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
1393 i--
1394 dAtA[i] = 0x8
1395 return len(dAtA) - i, nil
1396 }
1397
1398 func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
1399 size := m.Size()
1400 dAtA = make([]byte, size)
1401 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1402 if err != nil {
1403 return nil, err
1404 }
1405 return dAtA[:n], nil
1406 }
1407
1408 func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
1409 size := m.Size()
1410 return m.MarshalToSizedBuffer(dAtA[:size])
1411 }
1412
1413 func (m *RollingUpdateDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1414 i := len(dAtA)
1415 _ = i
1416 var l int
1417 _ = l
1418 if m.MaxSurge != nil {
1419 {
1420 size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
1421 if err != nil {
1422 return 0, err
1423 }
1424 i -= size
1425 i = encodeVarintGenerated(dAtA, i, uint64(size))
1426 }
1427 i--
1428 dAtA[i] = 0x12
1429 }
1430 if m.MaxUnavailable != nil {
1431 {
1432 size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
1433 if err != nil {
1434 return 0, err
1435 }
1436 i -= size
1437 i = encodeVarintGenerated(dAtA, i, uint64(size))
1438 }
1439 i--
1440 dAtA[i] = 0xa
1441 }
1442 return len(dAtA) - i, nil
1443 }
1444
1445 func (m *RollingUpdateStatefulSetStrategy) Marshal() (dAtA []byte, err error) {
1446 size := m.Size()
1447 dAtA = make([]byte, size)
1448 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1449 if err != nil {
1450 return nil, err
1451 }
1452 return dAtA[:n], nil
1453 }
1454
1455 func (m *RollingUpdateStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) {
1456 size := m.Size()
1457 return m.MarshalToSizedBuffer(dAtA[:size])
1458 }
1459
1460 func (m *RollingUpdateStatefulSetStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1461 i := len(dAtA)
1462 _ = i
1463 var l int
1464 _ = l
1465 if m.MaxUnavailable != nil {
1466 {
1467 size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
1468 if err != nil {
1469 return 0, err
1470 }
1471 i -= size
1472 i = encodeVarintGenerated(dAtA, i, uint64(size))
1473 }
1474 i--
1475 dAtA[i] = 0x12
1476 }
1477 if m.Partition != nil {
1478 i = encodeVarintGenerated(dAtA, i, uint64(*m.Partition))
1479 i--
1480 dAtA[i] = 0x8
1481 }
1482 return len(dAtA) - i, nil
1483 }
1484
1485 func (m *Scale) Marshal() (dAtA []byte, err error) {
1486 size := m.Size()
1487 dAtA = make([]byte, size)
1488 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1489 if err != nil {
1490 return nil, err
1491 }
1492 return dAtA[:n], nil
1493 }
1494
1495 func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
1496 size := m.Size()
1497 return m.MarshalToSizedBuffer(dAtA[:size])
1498 }
1499
1500 func (m *Scale) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1501 i := len(dAtA)
1502 _ = i
1503 var l int
1504 _ = l
1505 {
1506 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1507 if err != nil {
1508 return 0, err
1509 }
1510 i -= size
1511 i = encodeVarintGenerated(dAtA, i, uint64(size))
1512 }
1513 i--
1514 dAtA[i] = 0x1a
1515 {
1516 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1517 if err != nil {
1518 return 0, err
1519 }
1520 i -= size
1521 i = encodeVarintGenerated(dAtA, i, uint64(size))
1522 }
1523 i--
1524 dAtA[i] = 0x12
1525 {
1526 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1527 if err != nil {
1528 return 0, err
1529 }
1530 i -= size
1531 i = encodeVarintGenerated(dAtA, i, uint64(size))
1532 }
1533 i--
1534 dAtA[i] = 0xa
1535 return len(dAtA) - i, nil
1536 }
1537
1538 func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
1539 size := m.Size()
1540 dAtA = make([]byte, size)
1541 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1542 if err != nil {
1543 return nil, err
1544 }
1545 return dAtA[:n], nil
1546 }
1547
1548 func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
1549 size := m.Size()
1550 return m.MarshalToSizedBuffer(dAtA[:size])
1551 }
1552
1553 func (m *ScaleSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1554 i := len(dAtA)
1555 _ = i
1556 var l int
1557 _ = l
1558 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1559 i--
1560 dAtA[i] = 0x8
1561 return len(dAtA) - i, nil
1562 }
1563
1564 func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
1565 size := m.Size()
1566 dAtA = make([]byte, size)
1567 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1568 if err != nil {
1569 return nil, err
1570 }
1571 return dAtA[:n], nil
1572 }
1573
1574 func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
1575 size := m.Size()
1576 return m.MarshalToSizedBuffer(dAtA[:size])
1577 }
1578
1579 func (m *ScaleStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1580 i := len(dAtA)
1581 _ = i
1582 var l int
1583 _ = l
1584 i -= len(m.TargetSelector)
1585 copy(dAtA[i:], m.TargetSelector)
1586 i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector)))
1587 i--
1588 dAtA[i] = 0x1a
1589 if len(m.Selector) > 0 {
1590 keysForSelector := make([]string, 0, len(m.Selector))
1591 for k := range m.Selector {
1592 keysForSelector = append(keysForSelector, string(k))
1593 }
1594 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
1595 for iNdEx := len(keysForSelector) - 1; iNdEx >= 0; iNdEx-- {
1596 v := m.Selector[string(keysForSelector[iNdEx])]
1597 baseI := i
1598 i -= len(v)
1599 copy(dAtA[i:], v)
1600 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1601 i--
1602 dAtA[i] = 0x12
1603 i -= len(keysForSelector[iNdEx])
1604 copy(dAtA[i:], keysForSelector[iNdEx])
1605 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSelector[iNdEx])))
1606 i--
1607 dAtA[i] = 0xa
1608 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
1609 i--
1610 dAtA[i] = 0x12
1611 }
1612 }
1613 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
1614 i--
1615 dAtA[i] = 0x8
1616 return len(dAtA) - i, nil
1617 }
1618
1619 func (m *StatefulSet) Marshal() (dAtA []byte, err error) {
1620 size := m.Size()
1621 dAtA = make([]byte, size)
1622 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1623 if err != nil {
1624 return nil, err
1625 }
1626 return dAtA[:n], nil
1627 }
1628
1629 func (m *StatefulSet) MarshalTo(dAtA []byte) (int, error) {
1630 size := m.Size()
1631 return m.MarshalToSizedBuffer(dAtA[:size])
1632 }
1633
1634 func (m *StatefulSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1635 i := len(dAtA)
1636 _ = i
1637 var l int
1638 _ = l
1639 {
1640 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1641 if err != nil {
1642 return 0, err
1643 }
1644 i -= size
1645 i = encodeVarintGenerated(dAtA, i, uint64(size))
1646 }
1647 i--
1648 dAtA[i] = 0x1a
1649 {
1650 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1651 if err != nil {
1652 return 0, err
1653 }
1654 i -= size
1655 i = encodeVarintGenerated(dAtA, i, uint64(size))
1656 }
1657 i--
1658 dAtA[i] = 0x12
1659 {
1660 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1661 if err != nil {
1662 return 0, err
1663 }
1664 i -= size
1665 i = encodeVarintGenerated(dAtA, i, uint64(size))
1666 }
1667 i--
1668 dAtA[i] = 0xa
1669 return len(dAtA) - i, nil
1670 }
1671
1672 func (m *StatefulSetCondition) Marshal() (dAtA []byte, err error) {
1673 size := m.Size()
1674 dAtA = make([]byte, size)
1675 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1676 if err != nil {
1677 return nil, err
1678 }
1679 return dAtA[:n], nil
1680 }
1681
1682 func (m *StatefulSetCondition) MarshalTo(dAtA []byte) (int, error) {
1683 size := m.Size()
1684 return m.MarshalToSizedBuffer(dAtA[:size])
1685 }
1686
1687 func (m *StatefulSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1688 i := len(dAtA)
1689 _ = i
1690 var l int
1691 _ = l
1692 i -= len(m.Message)
1693 copy(dAtA[i:], m.Message)
1694 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1695 i--
1696 dAtA[i] = 0x2a
1697 i -= len(m.Reason)
1698 copy(dAtA[i:], m.Reason)
1699 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1700 i--
1701 dAtA[i] = 0x22
1702 {
1703 size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
1704 if err != nil {
1705 return 0, err
1706 }
1707 i -= size
1708 i = encodeVarintGenerated(dAtA, i, uint64(size))
1709 }
1710 i--
1711 dAtA[i] = 0x1a
1712 i -= len(m.Status)
1713 copy(dAtA[i:], m.Status)
1714 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1715 i--
1716 dAtA[i] = 0x12
1717 i -= len(m.Type)
1718 copy(dAtA[i:], m.Type)
1719 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1720 i--
1721 dAtA[i] = 0xa
1722 return len(dAtA) - i, nil
1723 }
1724
1725 func (m *StatefulSetList) Marshal() (dAtA []byte, err error) {
1726 size := m.Size()
1727 dAtA = make([]byte, size)
1728 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1729 if err != nil {
1730 return nil, err
1731 }
1732 return dAtA[:n], nil
1733 }
1734
1735 func (m *StatefulSetList) MarshalTo(dAtA []byte) (int, error) {
1736 size := m.Size()
1737 return m.MarshalToSizedBuffer(dAtA[:size])
1738 }
1739
1740 func (m *StatefulSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1741 i := len(dAtA)
1742 _ = i
1743 var l int
1744 _ = l
1745 if len(m.Items) > 0 {
1746 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1747 {
1748 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1749 if err != nil {
1750 return 0, err
1751 }
1752 i -= size
1753 i = encodeVarintGenerated(dAtA, i, uint64(size))
1754 }
1755 i--
1756 dAtA[i] = 0x12
1757 }
1758 }
1759 {
1760 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1761 if err != nil {
1762 return 0, err
1763 }
1764 i -= size
1765 i = encodeVarintGenerated(dAtA, i, uint64(size))
1766 }
1767 i--
1768 dAtA[i] = 0xa
1769 return len(dAtA) - i, nil
1770 }
1771
1772 func (m *StatefulSetOrdinals) Marshal() (dAtA []byte, err error) {
1773 size := m.Size()
1774 dAtA = make([]byte, size)
1775 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1776 if err != nil {
1777 return nil, err
1778 }
1779 return dAtA[:n], nil
1780 }
1781
1782 func (m *StatefulSetOrdinals) MarshalTo(dAtA []byte) (int, error) {
1783 size := m.Size()
1784 return m.MarshalToSizedBuffer(dAtA[:size])
1785 }
1786
1787 func (m *StatefulSetOrdinals) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1788 i := len(dAtA)
1789 _ = i
1790 var l int
1791 _ = l
1792 i = encodeVarintGenerated(dAtA, i, uint64(m.Start))
1793 i--
1794 dAtA[i] = 0x8
1795 return len(dAtA) - i, nil
1796 }
1797
1798 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Marshal() (dAtA []byte, err error) {
1799 size := m.Size()
1800 dAtA = make([]byte, size)
1801 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1802 if err != nil {
1803 return nil, err
1804 }
1805 return dAtA[:n], nil
1806 }
1807
1808 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalTo(dAtA []byte) (int, error) {
1809 size := m.Size()
1810 return m.MarshalToSizedBuffer(dAtA[:size])
1811 }
1812
1813 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1814 i := len(dAtA)
1815 _ = i
1816 var l int
1817 _ = l
1818 i -= len(m.WhenScaled)
1819 copy(dAtA[i:], m.WhenScaled)
1820 i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenScaled)))
1821 i--
1822 dAtA[i] = 0x12
1823 i -= len(m.WhenDeleted)
1824 copy(dAtA[i:], m.WhenDeleted)
1825 i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenDeleted)))
1826 i--
1827 dAtA[i] = 0xa
1828 return len(dAtA) - i, nil
1829 }
1830
1831 func (m *StatefulSetSpec) 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 *StatefulSetSpec) MarshalTo(dAtA []byte) (int, error) {
1842 size := m.Size()
1843 return m.MarshalToSizedBuffer(dAtA[:size])
1844 }
1845
1846 func (m *StatefulSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1847 i := len(dAtA)
1848 _ = i
1849 var l int
1850 _ = l
1851 if m.Ordinals != nil {
1852 {
1853 size, err := m.Ordinals.MarshalToSizedBuffer(dAtA[:i])
1854 if err != nil {
1855 return 0, err
1856 }
1857 i -= size
1858 i = encodeVarintGenerated(dAtA, i, uint64(size))
1859 }
1860 i--
1861 dAtA[i] = 0x5a
1862 }
1863 if m.PersistentVolumeClaimRetentionPolicy != nil {
1864 {
1865 size, err := m.PersistentVolumeClaimRetentionPolicy.MarshalToSizedBuffer(dAtA[:i])
1866 if err != nil {
1867 return 0, err
1868 }
1869 i -= size
1870 i = encodeVarintGenerated(dAtA, i, uint64(size))
1871 }
1872 i--
1873 dAtA[i] = 0x52
1874 }
1875 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
1876 i--
1877 dAtA[i] = 0x48
1878 if m.RevisionHistoryLimit != nil {
1879 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
1880 i--
1881 dAtA[i] = 0x40
1882 }
1883 {
1884 size, err := m.UpdateStrategy.MarshalToSizedBuffer(dAtA[:i])
1885 if err != nil {
1886 return 0, err
1887 }
1888 i -= size
1889 i = encodeVarintGenerated(dAtA, i, uint64(size))
1890 }
1891 i--
1892 dAtA[i] = 0x3a
1893 i -= len(m.PodManagementPolicy)
1894 copy(dAtA[i:], m.PodManagementPolicy)
1895 i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodManagementPolicy)))
1896 i--
1897 dAtA[i] = 0x32
1898 i -= len(m.ServiceName)
1899 copy(dAtA[i:], m.ServiceName)
1900 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
1901 i--
1902 dAtA[i] = 0x2a
1903 if len(m.VolumeClaimTemplates) > 0 {
1904 for iNdEx := len(m.VolumeClaimTemplates) - 1; iNdEx >= 0; iNdEx-- {
1905 {
1906 size, err := m.VolumeClaimTemplates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1907 if err != nil {
1908 return 0, err
1909 }
1910 i -= size
1911 i = encodeVarintGenerated(dAtA, i, uint64(size))
1912 }
1913 i--
1914 dAtA[i] = 0x22
1915 }
1916 }
1917 {
1918 size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
1919 if err != nil {
1920 return 0, err
1921 }
1922 i -= size
1923 i = encodeVarintGenerated(dAtA, i, uint64(size))
1924 }
1925 i--
1926 dAtA[i] = 0x1a
1927 if m.Selector != nil {
1928 {
1929 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
1930 if err != nil {
1931 return 0, err
1932 }
1933 i -= size
1934 i = encodeVarintGenerated(dAtA, i, uint64(size))
1935 }
1936 i--
1937 dAtA[i] = 0x12
1938 }
1939 if m.Replicas != nil {
1940 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
1941 i--
1942 dAtA[i] = 0x8
1943 }
1944 return len(dAtA) - i, nil
1945 }
1946
1947 func (m *StatefulSetStatus) Marshal() (dAtA []byte, err error) {
1948 size := m.Size()
1949 dAtA = make([]byte, size)
1950 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1951 if err != nil {
1952 return nil, err
1953 }
1954 return dAtA[:n], nil
1955 }
1956
1957 func (m *StatefulSetStatus) MarshalTo(dAtA []byte) (int, error) {
1958 size := m.Size()
1959 return m.MarshalToSizedBuffer(dAtA[:size])
1960 }
1961
1962 func (m *StatefulSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1963 i := len(dAtA)
1964 _ = i
1965 var l int
1966 _ = l
1967 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
1968 i--
1969 dAtA[i] = 0x58
1970 if len(m.Conditions) > 0 {
1971 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
1972 {
1973 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1974 if err != nil {
1975 return 0, err
1976 }
1977 i -= size
1978 i = encodeVarintGenerated(dAtA, i, uint64(size))
1979 }
1980 i--
1981 dAtA[i] = 0x52
1982 }
1983 }
1984 if m.CollisionCount != nil {
1985 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
1986 i--
1987 dAtA[i] = 0x48
1988 }
1989 i -= len(m.UpdateRevision)
1990 copy(dAtA[i:], m.UpdateRevision)
1991 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UpdateRevision)))
1992 i--
1993 dAtA[i] = 0x3a
1994 i -= len(m.CurrentRevision)
1995 copy(dAtA[i:], m.CurrentRevision)
1996 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentRevision)))
1997 i--
1998 dAtA[i] = 0x32
1999 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
2000 i--
2001 dAtA[i] = 0x28
2002 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas))
2003 i--
2004 dAtA[i] = 0x20
2005 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
2006 i--
2007 dAtA[i] = 0x18
2008 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
2009 i--
2010 dAtA[i] = 0x10
2011 if m.ObservedGeneration != nil {
2012 i = encodeVarintGenerated(dAtA, i, uint64(*m.ObservedGeneration))
2013 i--
2014 dAtA[i] = 0x8
2015 }
2016 return len(dAtA) - i, nil
2017 }
2018
2019 func (m *StatefulSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
2020 size := m.Size()
2021 dAtA = make([]byte, size)
2022 n, err := m.MarshalToSizedBuffer(dAtA[:size])
2023 if err != nil {
2024 return nil, err
2025 }
2026 return dAtA[:n], nil
2027 }
2028
2029 func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
2030 size := m.Size()
2031 return m.MarshalToSizedBuffer(dAtA[:size])
2032 }
2033
2034 func (m *StatefulSetUpdateStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
2035 i := len(dAtA)
2036 _ = i
2037 var l int
2038 _ = l
2039 if m.RollingUpdate != nil {
2040 {
2041 size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
2042 if err != nil {
2043 return 0, err
2044 }
2045 i -= size
2046 i = encodeVarintGenerated(dAtA, i, uint64(size))
2047 }
2048 i--
2049 dAtA[i] = 0x12
2050 }
2051 i -= len(m.Type)
2052 copy(dAtA[i:], m.Type)
2053 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
2054 i--
2055 dAtA[i] = 0xa
2056 return len(dAtA) - i, nil
2057 }
2058
2059 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
2060 offset -= sovGenerated(v)
2061 base := offset
2062 for v >= 1<<7 {
2063 dAtA[offset] = uint8(v&0x7f | 0x80)
2064 v >>= 7
2065 offset++
2066 }
2067 dAtA[offset] = uint8(v)
2068 return base
2069 }
2070 func (m *ControllerRevision) Size() (n int) {
2071 if m == nil {
2072 return 0
2073 }
2074 var l int
2075 _ = l
2076 l = m.ObjectMeta.Size()
2077 n += 1 + l + sovGenerated(uint64(l))
2078 l = m.Data.Size()
2079 n += 1 + l + sovGenerated(uint64(l))
2080 n += 1 + sovGenerated(uint64(m.Revision))
2081 return n
2082 }
2083
2084 func (m *ControllerRevisionList) Size() (n int) {
2085 if m == nil {
2086 return 0
2087 }
2088 var l int
2089 _ = l
2090 l = m.ListMeta.Size()
2091 n += 1 + l + sovGenerated(uint64(l))
2092 if len(m.Items) > 0 {
2093 for _, e := range m.Items {
2094 l = e.Size()
2095 n += 1 + l + sovGenerated(uint64(l))
2096 }
2097 }
2098 return n
2099 }
2100
2101 func (m *Deployment) Size() (n int) {
2102 if m == nil {
2103 return 0
2104 }
2105 var l int
2106 _ = l
2107 l = m.ObjectMeta.Size()
2108 n += 1 + l + sovGenerated(uint64(l))
2109 l = m.Spec.Size()
2110 n += 1 + l + sovGenerated(uint64(l))
2111 l = m.Status.Size()
2112 n += 1 + l + sovGenerated(uint64(l))
2113 return n
2114 }
2115
2116 func (m *DeploymentCondition) Size() (n int) {
2117 if m == nil {
2118 return 0
2119 }
2120 var l int
2121 _ = l
2122 l = len(m.Type)
2123 n += 1 + l + sovGenerated(uint64(l))
2124 l = len(m.Status)
2125 n += 1 + l + sovGenerated(uint64(l))
2126 l = len(m.Reason)
2127 n += 1 + l + sovGenerated(uint64(l))
2128 l = len(m.Message)
2129 n += 1 + l + sovGenerated(uint64(l))
2130 l = m.LastUpdateTime.Size()
2131 n += 1 + l + sovGenerated(uint64(l))
2132 l = m.LastTransitionTime.Size()
2133 n += 1 + l + sovGenerated(uint64(l))
2134 return n
2135 }
2136
2137 func (m *DeploymentList) Size() (n int) {
2138 if m == nil {
2139 return 0
2140 }
2141 var l int
2142 _ = l
2143 l = m.ListMeta.Size()
2144 n += 1 + l + sovGenerated(uint64(l))
2145 if len(m.Items) > 0 {
2146 for _, e := range m.Items {
2147 l = e.Size()
2148 n += 1 + l + sovGenerated(uint64(l))
2149 }
2150 }
2151 return n
2152 }
2153
2154 func (m *DeploymentRollback) Size() (n int) {
2155 if m == nil {
2156 return 0
2157 }
2158 var l int
2159 _ = l
2160 l = len(m.Name)
2161 n += 1 + l + sovGenerated(uint64(l))
2162 if len(m.UpdatedAnnotations) > 0 {
2163 for k, v := range m.UpdatedAnnotations {
2164 _ = k
2165 _ = v
2166 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2167 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2168 }
2169 }
2170 l = m.RollbackTo.Size()
2171 n += 1 + l + sovGenerated(uint64(l))
2172 return n
2173 }
2174
2175 func (m *DeploymentSpec) Size() (n int) {
2176 if m == nil {
2177 return 0
2178 }
2179 var l int
2180 _ = l
2181 if m.Replicas != nil {
2182 n += 1 + sovGenerated(uint64(*m.Replicas))
2183 }
2184 if m.Selector != nil {
2185 l = m.Selector.Size()
2186 n += 1 + l + sovGenerated(uint64(l))
2187 }
2188 l = m.Template.Size()
2189 n += 1 + l + sovGenerated(uint64(l))
2190 l = m.Strategy.Size()
2191 n += 1 + l + sovGenerated(uint64(l))
2192 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2193 if m.RevisionHistoryLimit != nil {
2194 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2195 }
2196 n += 2
2197 if m.RollbackTo != nil {
2198 l = m.RollbackTo.Size()
2199 n += 1 + l + sovGenerated(uint64(l))
2200 }
2201 if m.ProgressDeadlineSeconds != nil {
2202 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
2203 }
2204 return n
2205 }
2206
2207 func (m *DeploymentStatus) Size() (n int) {
2208 if m == nil {
2209 return 0
2210 }
2211 var l int
2212 _ = l
2213 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
2214 n += 1 + sovGenerated(uint64(m.Replicas))
2215 n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
2216 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
2217 n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
2218 if len(m.Conditions) > 0 {
2219 for _, e := range m.Conditions {
2220 l = e.Size()
2221 n += 1 + l + sovGenerated(uint64(l))
2222 }
2223 }
2224 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
2225 if m.CollisionCount != nil {
2226 n += 1 + sovGenerated(uint64(*m.CollisionCount))
2227 }
2228 return n
2229 }
2230
2231 func (m *DeploymentStrategy) Size() (n int) {
2232 if m == nil {
2233 return 0
2234 }
2235 var l int
2236 _ = l
2237 l = len(m.Type)
2238 n += 1 + l + sovGenerated(uint64(l))
2239 if m.RollingUpdate != nil {
2240 l = m.RollingUpdate.Size()
2241 n += 1 + l + sovGenerated(uint64(l))
2242 }
2243 return n
2244 }
2245
2246 func (m *RollbackConfig) Size() (n int) {
2247 if m == nil {
2248 return 0
2249 }
2250 var l int
2251 _ = l
2252 n += 1 + sovGenerated(uint64(m.Revision))
2253 return n
2254 }
2255
2256 func (m *RollingUpdateDeployment) Size() (n int) {
2257 if m == nil {
2258 return 0
2259 }
2260 var l int
2261 _ = l
2262 if m.MaxUnavailable != nil {
2263 l = m.MaxUnavailable.Size()
2264 n += 1 + l + sovGenerated(uint64(l))
2265 }
2266 if m.MaxSurge != nil {
2267 l = m.MaxSurge.Size()
2268 n += 1 + l + sovGenerated(uint64(l))
2269 }
2270 return n
2271 }
2272
2273 func (m *RollingUpdateStatefulSetStrategy) Size() (n int) {
2274 if m == nil {
2275 return 0
2276 }
2277 var l int
2278 _ = l
2279 if m.Partition != nil {
2280 n += 1 + sovGenerated(uint64(*m.Partition))
2281 }
2282 if m.MaxUnavailable != nil {
2283 l = m.MaxUnavailable.Size()
2284 n += 1 + l + sovGenerated(uint64(l))
2285 }
2286 return n
2287 }
2288
2289 func (m *Scale) Size() (n int) {
2290 if m == nil {
2291 return 0
2292 }
2293 var l int
2294 _ = l
2295 l = m.ObjectMeta.Size()
2296 n += 1 + l + sovGenerated(uint64(l))
2297 l = m.Spec.Size()
2298 n += 1 + l + sovGenerated(uint64(l))
2299 l = m.Status.Size()
2300 n += 1 + l + sovGenerated(uint64(l))
2301 return n
2302 }
2303
2304 func (m *ScaleSpec) Size() (n int) {
2305 if m == nil {
2306 return 0
2307 }
2308 var l int
2309 _ = l
2310 n += 1 + sovGenerated(uint64(m.Replicas))
2311 return n
2312 }
2313
2314 func (m *ScaleStatus) Size() (n int) {
2315 if m == nil {
2316 return 0
2317 }
2318 var l int
2319 _ = l
2320 n += 1 + sovGenerated(uint64(m.Replicas))
2321 if len(m.Selector) > 0 {
2322 for k, v := range m.Selector {
2323 _ = k
2324 _ = v
2325 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2326 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2327 }
2328 }
2329 l = len(m.TargetSelector)
2330 n += 1 + l + sovGenerated(uint64(l))
2331 return n
2332 }
2333
2334 func (m *StatefulSet) Size() (n int) {
2335 if m == nil {
2336 return 0
2337 }
2338 var l int
2339 _ = l
2340 l = m.ObjectMeta.Size()
2341 n += 1 + l + sovGenerated(uint64(l))
2342 l = m.Spec.Size()
2343 n += 1 + l + sovGenerated(uint64(l))
2344 l = m.Status.Size()
2345 n += 1 + l + sovGenerated(uint64(l))
2346 return n
2347 }
2348
2349 func (m *StatefulSetCondition) Size() (n int) {
2350 if m == nil {
2351 return 0
2352 }
2353 var l int
2354 _ = l
2355 l = len(m.Type)
2356 n += 1 + l + sovGenerated(uint64(l))
2357 l = len(m.Status)
2358 n += 1 + l + sovGenerated(uint64(l))
2359 l = m.LastTransitionTime.Size()
2360 n += 1 + l + sovGenerated(uint64(l))
2361 l = len(m.Reason)
2362 n += 1 + l + sovGenerated(uint64(l))
2363 l = len(m.Message)
2364 n += 1 + l + sovGenerated(uint64(l))
2365 return n
2366 }
2367
2368 func (m *StatefulSetList) Size() (n int) {
2369 if m == nil {
2370 return 0
2371 }
2372 var l int
2373 _ = l
2374 l = m.ListMeta.Size()
2375 n += 1 + l + sovGenerated(uint64(l))
2376 if len(m.Items) > 0 {
2377 for _, e := range m.Items {
2378 l = e.Size()
2379 n += 1 + l + sovGenerated(uint64(l))
2380 }
2381 }
2382 return n
2383 }
2384
2385 func (m *StatefulSetOrdinals) Size() (n int) {
2386 if m == nil {
2387 return 0
2388 }
2389 var l int
2390 _ = l
2391 n += 1 + sovGenerated(uint64(m.Start))
2392 return n
2393 }
2394
2395 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Size() (n int) {
2396 if m == nil {
2397 return 0
2398 }
2399 var l int
2400 _ = l
2401 l = len(m.WhenDeleted)
2402 n += 1 + l + sovGenerated(uint64(l))
2403 l = len(m.WhenScaled)
2404 n += 1 + l + sovGenerated(uint64(l))
2405 return n
2406 }
2407
2408 func (m *StatefulSetSpec) Size() (n int) {
2409 if m == nil {
2410 return 0
2411 }
2412 var l int
2413 _ = l
2414 if m.Replicas != nil {
2415 n += 1 + sovGenerated(uint64(*m.Replicas))
2416 }
2417 if m.Selector != nil {
2418 l = m.Selector.Size()
2419 n += 1 + l + sovGenerated(uint64(l))
2420 }
2421 l = m.Template.Size()
2422 n += 1 + l + sovGenerated(uint64(l))
2423 if len(m.VolumeClaimTemplates) > 0 {
2424 for _, e := range m.VolumeClaimTemplates {
2425 l = e.Size()
2426 n += 1 + l + sovGenerated(uint64(l))
2427 }
2428 }
2429 l = len(m.ServiceName)
2430 n += 1 + l + sovGenerated(uint64(l))
2431 l = len(m.PodManagementPolicy)
2432 n += 1 + l + sovGenerated(uint64(l))
2433 l = m.UpdateStrategy.Size()
2434 n += 1 + l + sovGenerated(uint64(l))
2435 if m.RevisionHistoryLimit != nil {
2436 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
2437 }
2438 n += 1 + sovGenerated(uint64(m.MinReadySeconds))
2439 if m.PersistentVolumeClaimRetentionPolicy != nil {
2440 l = m.PersistentVolumeClaimRetentionPolicy.Size()
2441 n += 1 + l + sovGenerated(uint64(l))
2442 }
2443 if m.Ordinals != nil {
2444 l = m.Ordinals.Size()
2445 n += 1 + l + sovGenerated(uint64(l))
2446 }
2447 return n
2448 }
2449
2450 func (m *StatefulSetStatus) Size() (n int) {
2451 if m == nil {
2452 return 0
2453 }
2454 var l int
2455 _ = l
2456 if m.ObservedGeneration != nil {
2457 n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
2458 }
2459 n += 1 + sovGenerated(uint64(m.Replicas))
2460 n += 1 + sovGenerated(uint64(m.ReadyReplicas))
2461 n += 1 + sovGenerated(uint64(m.CurrentReplicas))
2462 n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
2463 l = len(m.CurrentRevision)
2464 n += 1 + l + sovGenerated(uint64(l))
2465 l = len(m.UpdateRevision)
2466 n += 1 + l + sovGenerated(uint64(l))
2467 if m.CollisionCount != nil {
2468 n += 1 + sovGenerated(uint64(*m.CollisionCount))
2469 }
2470 if len(m.Conditions) > 0 {
2471 for _, e := range m.Conditions {
2472 l = e.Size()
2473 n += 1 + l + sovGenerated(uint64(l))
2474 }
2475 }
2476 n += 1 + sovGenerated(uint64(m.AvailableReplicas))
2477 return n
2478 }
2479
2480 func (m *StatefulSetUpdateStrategy) Size() (n int) {
2481 if m == nil {
2482 return 0
2483 }
2484 var l int
2485 _ = l
2486 l = len(m.Type)
2487 n += 1 + l + sovGenerated(uint64(l))
2488 if m.RollingUpdate != nil {
2489 l = m.RollingUpdate.Size()
2490 n += 1 + l + sovGenerated(uint64(l))
2491 }
2492 return n
2493 }
2494
2495 func sovGenerated(x uint64) (n int) {
2496 return (math_bits.Len64(x|1) + 6) / 7
2497 }
2498 func sozGenerated(x uint64) (n int) {
2499 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2500 }
2501 func (this *ControllerRevision) String() string {
2502 if this == nil {
2503 return "nil"
2504 }
2505 s := strings.Join([]string{`&ControllerRevision{`,
2506 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2507 `Data:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Data), "RawExtension", "runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2508 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
2509 `}`,
2510 }, "")
2511 return s
2512 }
2513 func (this *ControllerRevisionList) String() string {
2514 if this == nil {
2515 return "nil"
2516 }
2517 repeatedStringForItems := "[]ControllerRevision{"
2518 for _, f := range this.Items {
2519 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ControllerRevision", "ControllerRevision", 1), `&`, ``, 1) + ","
2520 }
2521 repeatedStringForItems += "}"
2522 s := strings.Join([]string{`&ControllerRevisionList{`,
2523 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2524 `Items:` + repeatedStringForItems + `,`,
2525 `}`,
2526 }, "")
2527 return s
2528 }
2529 func (this *Deployment) String() string {
2530 if this == nil {
2531 return "nil"
2532 }
2533 s := strings.Join([]string{`&Deployment{`,
2534 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2535 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
2536 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
2537 `}`,
2538 }, "")
2539 return s
2540 }
2541 func (this *DeploymentCondition) String() string {
2542 if this == nil {
2543 return "nil"
2544 }
2545 s := strings.Join([]string{`&DeploymentCondition{`,
2546 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2547 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2548 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2549 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2550 `LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
2551 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
2552 `}`,
2553 }, "")
2554 return s
2555 }
2556 func (this *DeploymentList) String() string {
2557 if this == nil {
2558 return "nil"
2559 }
2560 repeatedStringForItems := "[]Deployment{"
2561 for _, f := range this.Items {
2562 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Deployment", "Deployment", 1), `&`, ``, 1) + ","
2563 }
2564 repeatedStringForItems += "}"
2565 s := strings.Join([]string{`&DeploymentList{`,
2566 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2567 `Items:` + repeatedStringForItems + `,`,
2568 `}`,
2569 }, "")
2570 return s
2571 }
2572 func (this *DeploymentRollback) String() string {
2573 if this == nil {
2574 return "nil"
2575 }
2576 keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations))
2577 for k := range this.UpdatedAnnotations {
2578 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k)
2579 }
2580 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
2581 mapStringForUpdatedAnnotations := "map[string]string{"
2582 for _, k := range keysForUpdatedAnnotations {
2583 mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k])
2584 }
2585 mapStringForUpdatedAnnotations += "}"
2586 s := strings.Join([]string{`&DeploymentRollback{`,
2587 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2588 `UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`,
2589 `RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`,
2590 `}`,
2591 }, "")
2592 return s
2593 }
2594 func (this *DeploymentSpec) String() string {
2595 if this == nil {
2596 return "nil"
2597 }
2598 s := strings.Join([]string{`&DeploymentSpec{`,
2599 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
2600 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
2601 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2602 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
2603 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
2604 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
2605 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
2606 `RollbackTo:` + strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1) + `,`,
2607 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
2608 `}`,
2609 }, "")
2610 return s
2611 }
2612 func (this *DeploymentStatus) String() string {
2613 if this == nil {
2614 return "nil"
2615 }
2616 repeatedStringForConditions := "[]DeploymentCondition{"
2617 for _, f := range this.Conditions {
2618 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + ","
2619 }
2620 repeatedStringForConditions += "}"
2621 s := strings.Join([]string{`&DeploymentStatus{`,
2622 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
2623 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2624 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
2625 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
2626 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
2627 `Conditions:` + repeatedStringForConditions + `,`,
2628 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
2629 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
2630 `}`,
2631 }, "")
2632 return s
2633 }
2634 func (this *DeploymentStrategy) String() string {
2635 if this == nil {
2636 return "nil"
2637 }
2638 s := strings.Join([]string{`&DeploymentStrategy{`,
2639 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2640 `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
2641 `}`,
2642 }, "")
2643 return s
2644 }
2645 func (this *RollbackConfig) String() string {
2646 if this == nil {
2647 return "nil"
2648 }
2649 s := strings.Join([]string{`&RollbackConfig{`,
2650 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
2651 `}`,
2652 }, "")
2653 return s
2654 }
2655 func (this *RollingUpdateDeployment) String() string {
2656 if this == nil {
2657 return "nil"
2658 }
2659 s := strings.Join([]string{`&RollingUpdateDeployment{`,
2660 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
2661 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
2662 `}`,
2663 }, "")
2664 return s
2665 }
2666 func (this *RollingUpdateStatefulSetStrategy) String() string {
2667 if this == nil {
2668 return "nil"
2669 }
2670 s := strings.Join([]string{`&RollingUpdateStatefulSetStrategy{`,
2671 `Partition:` + valueToStringGenerated(this.Partition) + `,`,
2672 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
2673 `}`,
2674 }, "")
2675 return s
2676 }
2677 func (this *Scale) String() string {
2678 if this == nil {
2679 return "nil"
2680 }
2681 s := strings.Join([]string{`&Scale{`,
2682 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2683 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
2684 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
2685 `}`,
2686 }, "")
2687 return s
2688 }
2689 func (this *ScaleSpec) String() string {
2690 if this == nil {
2691 return "nil"
2692 }
2693 s := strings.Join([]string{`&ScaleSpec{`,
2694 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2695 `}`,
2696 }, "")
2697 return s
2698 }
2699 func (this *ScaleStatus) String() string {
2700 if this == nil {
2701 return "nil"
2702 }
2703 keysForSelector := make([]string, 0, len(this.Selector))
2704 for k := range this.Selector {
2705 keysForSelector = append(keysForSelector, k)
2706 }
2707 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
2708 mapStringForSelector := "map[string]string{"
2709 for _, k := range keysForSelector {
2710 mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k])
2711 }
2712 mapStringForSelector += "}"
2713 s := strings.Join([]string{`&ScaleStatus{`,
2714 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2715 `Selector:` + mapStringForSelector + `,`,
2716 `TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`,
2717 `}`,
2718 }, "")
2719 return s
2720 }
2721 func (this *StatefulSet) String() string {
2722 if this == nil {
2723 return "nil"
2724 }
2725 s := strings.Join([]string{`&StatefulSet{`,
2726 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2727 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "StatefulSetSpec", "StatefulSetSpec", 1), `&`, ``, 1) + `,`,
2728 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "StatefulSetStatus", "StatefulSetStatus", 1), `&`, ``, 1) + `,`,
2729 `}`,
2730 }, "")
2731 return s
2732 }
2733 func (this *StatefulSetCondition) String() string {
2734 if this == nil {
2735 return "nil"
2736 }
2737 s := strings.Join([]string{`&StatefulSetCondition{`,
2738 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2739 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2740 `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
2741 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2742 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2743 `}`,
2744 }, "")
2745 return s
2746 }
2747 func (this *StatefulSetList) String() string {
2748 if this == nil {
2749 return "nil"
2750 }
2751 repeatedStringForItems := "[]StatefulSet{"
2752 for _, f := range this.Items {
2753 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "StatefulSet", "StatefulSet", 1), `&`, ``, 1) + ","
2754 }
2755 repeatedStringForItems += "}"
2756 s := strings.Join([]string{`&StatefulSetList{`,
2757 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2758 `Items:` + repeatedStringForItems + `,`,
2759 `}`,
2760 }, "")
2761 return s
2762 }
2763 func (this *StatefulSetOrdinals) String() string {
2764 if this == nil {
2765 return "nil"
2766 }
2767 s := strings.Join([]string{`&StatefulSetOrdinals{`,
2768 `Start:` + fmt.Sprintf("%v", this.Start) + `,`,
2769 `}`,
2770 }, "")
2771 return s
2772 }
2773 func (this *StatefulSetPersistentVolumeClaimRetentionPolicy) String() string {
2774 if this == nil {
2775 return "nil"
2776 }
2777 s := strings.Join([]string{`&StatefulSetPersistentVolumeClaimRetentionPolicy{`,
2778 `WhenDeleted:` + fmt.Sprintf("%v", this.WhenDeleted) + `,`,
2779 `WhenScaled:` + fmt.Sprintf("%v", this.WhenScaled) + `,`,
2780 `}`,
2781 }, "")
2782 return s
2783 }
2784 func (this *StatefulSetSpec) String() string {
2785 if this == nil {
2786 return "nil"
2787 }
2788 repeatedStringForVolumeClaimTemplates := "[]PersistentVolumeClaim{"
2789 for _, f := range this.VolumeClaimTemplates {
2790 repeatedStringForVolumeClaimTemplates += fmt.Sprintf("%v", f) + ","
2791 }
2792 repeatedStringForVolumeClaimTemplates += "}"
2793 s := strings.Join([]string{`&StatefulSetSpec{`,
2794 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
2795 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
2796 `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
2797 `VolumeClaimTemplates:` + repeatedStringForVolumeClaimTemplates + `,`,
2798 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
2799 `PodManagementPolicy:` + fmt.Sprintf("%v", this.PodManagementPolicy) + `,`,
2800 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
2801 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
2802 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
2803 `PersistentVolumeClaimRetentionPolicy:` + strings.Replace(this.PersistentVolumeClaimRetentionPolicy.String(), "StatefulSetPersistentVolumeClaimRetentionPolicy", "StatefulSetPersistentVolumeClaimRetentionPolicy", 1) + `,`,
2804 `Ordinals:` + strings.Replace(this.Ordinals.String(), "StatefulSetOrdinals", "StatefulSetOrdinals", 1) + `,`,
2805 `}`,
2806 }, "")
2807 return s
2808 }
2809 func (this *StatefulSetStatus) String() string {
2810 if this == nil {
2811 return "nil"
2812 }
2813 repeatedStringForConditions := "[]StatefulSetCondition{"
2814 for _, f := range this.Conditions {
2815 repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "StatefulSetCondition", "StatefulSetCondition", 1), `&`, ``, 1) + ","
2816 }
2817 repeatedStringForConditions += "}"
2818 s := strings.Join([]string{`&StatefulSetStatus{`,
2819 `ObservedGeneration:` + valueToStringGenerated(this.ObservedGeneration) + `,`,
2820 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
2821 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
2822 `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`,
2823 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
2824 `CurrentRevision:` + fmt.Sprintf("%v", this.CurrentRevision) + `,`,
2825 `UpdateRevision:` + fmt.Sprintf("%v", this.UpdateRevision) + `,`,
2826 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
2827 `Conditions:` + repeatedStringForConditions + `,`,
2828 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
2829 `}`,
2830 }, "")
2831 return s
2832 }
2833 func (this *StatefulSetUpdateStrategy) String() string {
2834 if this == nil {
2835 return "nil"
2836 }
2837 s := strings.Join([]string{`&StatefulSetUpdateStrategy{`,
2838 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2839 `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateStatefulSetStrategy", "RollingUpdateStatefulSetStrategy", 1) + `,`,
2840 `}`,
2841 }, "")
2842 return s
2843 }
2844 func valueToStringGenerated(v interface{}) string {
2845 rv := reflect.ValueOf(v)
2846 if rv.IsNil() {
2847 return "nil"
2848 }
2849 pv := reflect.Indirect(rv).Interface()
2850 return fmt.Sprintf("*%v", pv)
2851 }
2852 func (m *ControllerRevision) Unmarshal(dAtA []byte) error {
2853 l := len(dAtA)
2854 iNdEx := 0
2855 for iNdEx < l {
2856 preIndex := iNdEx
2857 var wire uint64
2858 for shift := uint(0); ; shift += 7 {
2859 if shift >= 64 {
2860 return ErrIntOverflowGenerated
2861 }
2862 if iNdEx >= l {
2863 return io.ErrUnexpectedEOF
2864 }
2865 b := dAtA[iNdEx]
2866 iNdEx++
2867 wire |= uint64(b&0x7F) << shift
2868 if b < 0x80 {
2869 break
2870 }
2871 }
2872 fieldNum := int32(wire >> 3)
2873 wireType := int(wire & 0x7)
2874 if wireType == 4 {
2875 return fmt.Errorf("proto: ControllerRevision: wiretype end group for non-group")
2876 }
2877 if fieldNum <= 0 {
2878 return fmt.Errorf("proto: ControllerRevision: illegal tag %d (wire type %d)", fieldNum, wire)
2879 }
2880 switch fieldNum {
2881 case 1:
2882 if wireType != 2 {
2883 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2884 }
2885 var msglen int
2886 for shift := uint(0); ; shift += 7 {
2887 if shift >= 64 {
2888 return ErrIntOverflowGenerated
2889 }
2890 if iNdEx >= l {
2891 return io.ErrUnexpectedEOF
2892 }
2893 b := dAtA[iNdEx]
2894 iNdEx++
2895 msglen |= int(b&0x7F) << shift
2896 if b < 0x80 {
2897 break
2898 }
2899 }
2900 if msglen < 0 {
2901 return ErrInvalidLengthGenerated
2902 }
2903 postIndex := iNdEx + msglen
2904 if postIndex < 0 {
2905 return ErrInvalidLengthGenerated
2906 }
2907 if postIndex > l {
2908 return io.ErrUnexpectedEOF
2909 }
2910 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2911 return err
2912 }
2913 iNdEx = postIndex
2914 case 2:
2915 if wireType != 2 {
2916 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
2917 }
2918 var msglen int
2919 for shift := uint(0); ; shift += 7 {
2920 if shift >= 64 {
2921 return ErrIntOverflowGenerated
2922 }
2923 if iNdEx >= l {
2924 return io.ErrUnexpectedEOF
2925 }
2926 b := dAtA[iNdEx]
2927 iNdEx++
2928 msglen |= int(b&0x7F) << shift
2929 if b < 0x80 {
2930 break
2931 }
2932 }
2933 if msglen < 0 {
2934 return ErrInvalidLengthGenerated
2935 }
2936 postIndex := iNdEx + msglen
2937 if postIndex < 0 {
2938 return ErrInvalidLengthGenerated
2939 }
2940 if postIndex > l {
2941 return io.ErrUnexpectedEOF
2942 }
2943 if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2944 return err
2945 }
2946 iNdEx = postIndex
2947 case 3:
2948 if wireType != 0 {
2949 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
2950 }
2951 m.Revision = 0
2952 for shift := uint(0); ; shift += 7 {
2953 if shift >= 64 {
2954 return ErrIntOverflowGenerated
2955 }
2956 if iNdEx >= l {
2957 return io.ErrUnexpectedEOF
2958 }
2959 b := dAtA[iNdEx]
2960 iNdEx++
2961 m.Revision |= int64(b&0x7F) << shift
2962 if b < 0x80 {
2963 break
2964 }
2965 }
2966 default:
2967 iNdEx = preIndex
2968 skippy, err := skipGenerated(dAtA[iNdEx:])
2969 if err != nil {
2970 return err
2971 }
2972 if (skippy < 0) || (iNdEx+skippy) < 0 {
2973 return ErrInvalidLengthGenerated
2974 }
2975 if (iNdEx + skippy) > l {
2976 return io.ErrUnexpectedEOF
2977 }
2978 iNdEx += skippy
2979 }
2980 }
2981
2982 if iNdEx > l {
2983 return io.ErrUnexpectedEOF
2984 }
2985 return nil
2986 }
2987 func (m *ControllerRevisionList) Unmarshal(dAtA []byte) error {
2988 l := len(dAtA)
2989 iNdEx := 0
2990 for iNdEx < l {
2991 preIndex := iNdEx
2992 var wire uint64
2993 for shift := uint(0); ; shift += 7 {
2994 if shift >= 64 {
2995 return ErrIntOverflowGenerated
2996 }
2997 if iNdEx >= l {
2998 return io.ErrUnexpectedEOF
2999 }
3000 b := dAtA[iNdEx]
3001 iNdEx++
3002 wire |= uint64(b&0x7F) << shift
3003 if b < 0x80 {
3004 break
3005 }
3006 }
3007 fieldNum := int32(wire >> 3)
3008 wireType := int(wire & 0x7)
3009 if wireType == 4 {
3010 return fmt.Errorf("proto: ControllerRevisionList: wiretype end group for non-group")
3011 }
3012 if fieldNum <= 0 {
3013 return fmt.Errorf("proto: ControllerRevisionList: illegal tag %d (wire type %d)", fieldNum, wire)
3014 }
3015 switch fieldNum {
3016 case 1:
3017 if wireType != 2 {
3018 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3019 }
3020 var msglen int
3021 for shift := uint(0); ; shift += 7 {
3022 if shift >= 64 {
3023 return ErrIntOverflowGenerated
3024 }
3025 if iNdEx >= l {
3026 return io.ErrUnexpectedEOF
3027 }
3028 b := dAtA[iNdEx]
3029 iNdEx++
3030 msglen |= int(b&0x7F) << shift
3031 if b < 0x80 {
3032 break
3033 }
3034 }
3035 if msglen < 0 {
3036 return ErrInvalidLengthGenerated
3037 }
3038 postIndex := iNdEx + msglen
3039 if postIndex < 0 {
3040 return ErrInvalidLengthGenerated
3041 }
3042 if postIndex > l {
3043 return io.ErrUnexpectedEOF
3044 }
3045 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3046 return err
3047 }
3048 iNdEx = postIndex
3049 case 2:
3050 if wireType != 2 {
3051 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3052 }
3053 var msglen int
3054 for shift := uint(0); ; shift += 7 {
3055 if shift >= 64 {
3056 return ErrIntOverflowGenerated
3057 }
3058 if iNdEx >= l {
3059 return io.ErrUnexpectedEOF
3060 }
3061 b := dAtA[iNdEx]
3062 iNdEx++
3063 msglen |= int(b&0x7F) << shift
3064 if b < 0x80 {
3065 break
3066 }
3067 }
3068 if msglen < 0 {
3069 return ErrInvalidLengthGenerated
3070 }
3071 postIndex := iNdEx + msglen
3072 if postIndex < 0 {
3073 return ErrInvalidLengthGenerated
3074 }
3075 if postIndex > l {
3076 return io.ErrUnexpectedEOF
3077 }
3078 m.Items = append(m.Items, ControllerRevision{})
3079 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3080 return err
3081 }
3082 iNdEx = postIndex
3083 default:
3084 iNdEx = preIndex
3085 skippy, err := skipGenerated(dAtA[iNdEx:])
3086 if err != nil {
3087 return err
3088 }
3089 if (skippy < 0) || (iNdEx+skippy) < 0 {
3090 return ErrInvalidLengthGenerated
3091 }
3092 if (iNdEx + skippy) > l {
3093 return io.ErrUnexpectedEOF
3094 }
3095 iNdEx += skippy
3096 }
3097 }
3098
3099 if iNdEx > l {
3100 return io.ErrUnexpectedEOF
3101 }
3102 return nil
3103 }
3104 func (m *Deployment) Unmarshal(dAtA []byte) error {
3105 l := len(dAtA)
3106 iNdEx := 0
3107 for iNdEx < l {
3108 preIndex := iNdEx
3109 var wire uint64
3110 for shift := uint(0); ; shift += 7 {
3111 if shift >= 64 {
3112 return ErrIntOverflowGenerated
3113 }
3114 if iNdEx >= l {
3115 return io.ErrUnexpectedEOF
3116 }
3117 b := dAtA[iNdEx]
3118 iNdEx++
3119 wire |= uint64(b&0x7F) << shift
3120 if b < 0x80 {
3121 break
3122 }
3123 }
3124 fieldNum := int32(wire >> 3)
3125 wireType := int(wire & 0x7)
3126 if wireType == 4 {
3127 return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
3128 }
3129 if fieldNum <= 0 {
3130 return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
3131 }
3132 switch fieldNum {
3133 case 1:
3134 if wireType != 2 {
3135 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3136 }
3137 var msglen int
3138 for shift := uint(0); ; shift += 7 {
3139 if shift >= 64 {
3140 return ErrIntOverflowGenerated
3141 }
3142 if iNdEx >= l {
3143 return io.ErrUnexpectedEOF
3144 }
3145 b := dAtA[iNdEx]
3146 iNdEx++
3147 msglen |= int(b&0x7F) << shift
3148 if b < 0x80 {
3149 break
3150 }
3151 }
3152 if msglen < 0 {
3153 return ErrInvalidLengthGenerated
3154 }
3155 postIndex := iNdEx + msglen
3156 if postIndex < 0 {
3157 return ErrInvalidLengthGenerated
3158 }
3159 if postIndex > l {
3160 return io.ErrUnexpectedEOF
3161 }
3162 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3163 return err
3164 }
3165 iNdEx = postIndex
3166 case 2:
3167 if wireType != 2 {
3168 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
3169 }
3170 var msglen int
3171 for shift := uint(0); ; shift += 7 {
3172 if shift >= 64 {
3173 return ErrIntOverflowGenerated
3174 }
3175 if iNdEx >= l {
3176 return io.ErrUnexpectedEOF
3177 }
3178 b := dAtA[iNdEx]
3179 iNdEx++
3180 msglen |= int(b&0x7F) << shift
3181 if b < 0x80 {
3182 break
3183 }
3184 }
3185 if msglen < 0 {
3186 return ErrInvalidLengthGenerated
3187 }
3188 postIndex := iNdEx + msglen
3189 if postIndex < 0 {
3190 return ErrInvalidLengthGenerated
3191 }
3192 if postIndex > l {
3193 return io.ErrUnexpectedEOF
3194 }
3195 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3196 return err
3197 }
3198 iNdEx = postIndex
3199 case 3:
3200 if wireType != 2 {
3201 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3202 }
3203 var msglen int
3204 for shift := uint(0); ; shift += 7 {
3205 if shift >= 64 {
3206 return ErrIntOverflowGenerated
3207 }
3208 if iNdEx >= l {
3209 return io.ErrUnexpectedEOF
3210 }
3211 b := dAtA[iNdEx]
3212 iNdEx++
3213 msglen |= int(b&0x7F) << shift
3214 if b < 0x80 {
3215 break
3216 }
3217 }
3218 if msglen < 0 {
3219 return ErrInvalidLengthGenerated
3220 }
3221 postIndex := iNdEx + msglen
3222 if postIndex < 0 {
3223 return ErrInvalidLengthGenerated
3224 }
3225 if postIndex > l {
3226 return io.ErrUnexpectedEOF
3227 }
3228 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3229 return err
3230 }
3231 iNdEx = postIndex
3232 default:
3233 iNdEx = preIndex
3234 skippy, err := skipGenerated(dAtA[iNdEx:])
3235 if err != nil {
3236 return err
3237 }
3238 if (skippy < 0) || (iNdEx+skippy) < 0 {
3239 return ErrInvalidLengthGenerated
3240 }
3241 if (iNdEx + skippy) > l {
3242 return io.ErrUnexpectedEOF
3243 }
3244 iNdEx += skippy
3245 }
3246 }
3247
3248 if iNdEx > l {
3249 return io.ErrUnexpectedEOF
3250 }
3251 return nil
3252 }
3253 func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
3254 l := len(dAtA)
3255 iNdEx := 0
3256 for iNdEx < l {
3257 preIndex := iNdEx
3258 var wire uint64
3259 for shift := uint(0); ; shift += 7 {
3260 if shift >= 64 {
3261 return ErrIntOverflowGenerated
3262 }
3263 if iNdEx >= l {
3264 return io.ErrUnexpectedEOF
3265 }
3266 b := dAtA[iNdEx]
3267 iNdEx++
3268 wire |= uint64(b&0x7F) << shift
3269 if b < 0x80 {
3270 break
3271 }
3272 }
3273 fieldNum := int32(wire >> 3)
3274 wireType := int(wire & 0x7)
3275 if wireType == 4 {
3276 return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
3277 }
3278 if fieldNum <= 0 {
3279 return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
3280 }
3281 switch fieldNum {
3282 case 1:
3283 if wireType != 2 {
3284 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3285 }
3286 var stringLen uint64
3287 for shift := uint(0); ; shift += 7 {
3288 if shift >= 64 {
3289 return ErrIntOverflowGenerated
3290 }
3291 if iNdEx >= l {
3292 return io.ErrUnexpectedEOF
3293 }
3294 b := dAtA[iNdEx]
3295 iNdEx++
3296 stringLen |= uint64(b&0x7F) << shift
3297 if b < 0x80 {
3298 break
3299 }
3300 }
3301 intStringLen := int(stringLen)
3302 if intStringLen < 0 {
3303 return ErrInvalidLengthGenerated
3304 }
3305 postIndex := iNdEx + intStringLen
3306 if postIndex < 0 {
3307 return ErrInvalidLengthGenerated
3308 }
3309 if postIndex > l {
3310 return io.ErrUnexpectedEOF
3311 }
3312 m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
3313 iNdEx = postIndex
3314 case 2:
3315 if wireType != 2 {
3316 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
3317 }
3318 var stringLen uint64
3319 for shift := uint(0); ; shift += 7 {
3320 if shift >= 64 {
3321 return ErrIntOverflowGenerated
3322 }
3323 if iNdEx >= l {
3324 return io.ErrUnexpectedEOF
3325 }
3326 b := dAtA[iNdEx]
3327 iNdEx++
3328 stringLen |= uint64(b&0x7F) << shift
3329 if b < 0x80 {
3330 break
3331 }
3332 }
3333 intStringLen := int(stringLen)
3334 if intStringLen < 0 {
3335 return ErrInvalidLengthGenerated
3336 }
3337 postIndex := iNdEx + intStringLen
3338 if postIndex < 0 {
3339 return ErrInvalidLengthGenerated
3340 }
3341 if postIndex > l {
3342 return io.ErrUnexpectedEOF
3343 }
3344 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
3345 iNdEx = postIndex
3346 case 4:
3347 if wireType != 2 {
3348 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
3349 }
3350 var stringLen uint64
3351 for shift := uint(0); ; shift += 7 {
3352 if shift >= 64 {
3353 return ErrIntOverflowGenerated
3354 }
3355 if iNdEx >= l {
3356 return io.ErrUnexpectedEOF
3357 }
3358 b := dAtA[iNdEx]
3359 iNdEx++
3360 stringLen |= uint64(b&0x7F) << shift
3361 if b < 0x80 {
3362 break
3363 }
3364 }
3365 intStringLen := int(stringLen)
3366 if intStringLen < 0 {
3367 return ErrInvalidLengthGenerated
3368 }
3369 postIndex := iNdEx + intStringLen
3370 if postIndex < 0 {
3371 return ErrInvalidLengthGenerated
3372 }
3373 if postIndex > l {
3374 return io.ErrUnexpectedEOF
3375 }
3376 m.Reason = string(dAtA[iNdEx:postIndex])
3377 iNdEx = postIndex
3378 case 5:
3379 if wireType != 2 {
3380 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
3381 }
3382 var stringLen uint64
3383 for shift := uint(0); ; shift += 7 {
3384 if shift >= 64 {
3385 return ErrIntOverflowGenerated
3386 }
3387 if iNdEx >= l {
3388 return io.ErrUnexpectedEOF
3389 }
3390 b := dAtA[iNdEx]
3391 iNdEx++
3392 stringLen |= uint64(b&0x7F) << shift
3393 if b < 0x80 {
3394 break
3395 }
3396 }
3397 intStringLen := int(stringLen)
3398 if intStringLen < 0 {
3399 return ErrInvalidLengthGenerated
3400 }
3401 postIndex := iNdEx + intStringLen
3402 if postIndex < 0 {
3403 return ErrInvalidLengthGenerated
3404 }
3405 if postIndex > l {
3406 return io.ErrUnexpectedEOF
3407 }
3408 m.Message = string(dAtA[iNdEx:postIndex])
3409 iNdEx = postIndex
3410 case 6:
3411 if wireType != 2 {
3412 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
3413 }
3414 var msglen int
3415 for shift := uint(0); ; shift += 7 {
3416 if shift >= 64 {
3417 return ErrIntOverflowGenerated
3418 }
3419 if iNdEx >= l {
3420 return io.ErrUnexpectedEOF
3421 }
3422 b := dAtA[iNdEx]
3423 iNdEx++
3424 msglen |= int(b&0x7F) << shift
3425 if b < 0x80 {
3426 break
3427 }
3428 }
3429 if msglen < 0 {
3430 return ErrInvalidLengthGenerated
3431 }
3432 postIndex := iNdEx + msglen
3433 if postIndex < 0 {
3434 return ErrInvalidLengthGenerated
3435 }
3436 if postIndex > l {
3437 return io.ErrUnexpectedEOF
3438 }
3439 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3440 return err
3441 }
3442 iNdEx = postIndex
3443 case 7:
3444 if wireType != 2 {
3445 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
3446 }
3447 var msglen int
3448 for shift := uint(0); ; shift += 7 {
3449 if shift >= 64 {
3450 return ErrIntOverflowGenerated
3451 }
3452 if iNdEx >= l {
3453 return io.ErrUnexpectedEOF
3454 }
3455 b := dAtA[iNdEx]
3456 iNdEx++
3457 msglen |= int(b&0x7F) << shift
3458 if b < 0x80 {
3459 break
3460 }
3461 }
3462 if msglen < 0 {
3463 return ErrInvalidLengthGenerated
3464 }
3465 postIndex := iNdEx + msglen
3466 if postIndex < 0 {
3467 return ErrInvalidLengthGenerated
3468 }
3469 if postIndex > l {
3470 return io.ErrUnexpectedEOF
3471 }
3472 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3473 return err
3474 }
3475 iNdEx = postIndex
3476 default:
3477 iNdEx = preIndex
3478 skippy, err := skipGenerated(dAtA[iNdEx:])
3479 if err != nil {
3480 return err
3481 }
3482 if (skippy < 0) || (iNdEx+skippy) < 0 {
3483 return ErrInvalidLengthGenerated
3484 }
3485 if (iNdEx + skippy) > l {
3486 return io.ErrUnexpectedEOF
3487 }
3488 iNdEx += skippy
3489 }
3490 }
3491
3492 if iNdEx > l {
3493 return io.ErrUnexpectedEOF
3494 }
3495 return nil
3496 }
3497 func (m *DeploymentList) Unmarshal(dAtA []byte) error {
3498 l := len(dAtA)
3499 iNdEx := 0
3500 for iNdEx < l {
3501 preIndex := iNdEx
3502 var wire uint64
3503 for shift := uint(0); ; shift += 7 {
3504 if shift >= 64 {
3505 return ErrIntOverflowGenerated
3506 }
3507 if iNdEx >= l {
3508 return io.ErrUnexpectedEOF
3509 }
3510 b := dAtA[iNdEx]
3511 iNdEx++
3512 wire |= uint64(b&0x7F) << shift
3513 if b < 0x80 {
3514 break
3515 }
3516 }
3517 fieldNum := int32(wire >> 3)
3518 wireType := int(wire & 0x7)
3519 if wireType == 4 {
3520 return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
3521 }
3522 if fieldNum <= 0 {
3523 return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
3524 }
3525 switch fieldNum {
3526 case 1:
3527 if wireType != 2 {
3528 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3529 }
3530 var msglen int
3531 for shift := uint(0); ; shift += 7 {
3532 if shift >= 64 {
3533 return ErrIntOverflowGenerated
3534 }
3535 if iNdEx >= l {
3536 return io.ErrUnexpectedEOF
3537 }
3538 b := dAtA[iNdEx]
3539 iNdEx++
3540 msglen |= int(b&0x7F) << shift
3541 if b < 0x80 {
3542 break
3543 }
3544 }
3545 if msglen < 0 {
3546 return ErrInvalidLengthGenerated
3547 }
3548 postIndex := iNdEx + msglen
3549 if postIndex < 0 {
3550 return ErrInvalidLengthGenerated
3551 }
3552 if postIndex > l {
3553 return io.ErrUnexpectedEOF
3554 }
3555 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3556 return err
3557 }
3558 iNdEx = postIndex
3559 case 2:
3560 if wireType != 2 {
3561 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3562 }
3563 var msglen int
3564 for shift := uint(0); ; shift += 7 {
3565 if shift >= 64 {
3566 return ErrIntOverflowGenerated
3567 }
3568 if iNdEx >= l {
3569 return io.ErrUnexpectedEOF
3570 }
3571 b := dAtA[iNdEx]
3572 iNdEx++
3573 msglen |= int(b&0x7F) << shift
3574 if b < 0x80 {
3575 break
3576 }
3577 }
3578 if msglen < 0 {
3579 return ErrInvalidLengthGenerated
3580 }
3581 postIndex := iNdEx + msglen
3582 if postIndex < 0 {
3583 return ErrInvalidLengthGenerated
3584 }
3585 if postIndex > l {
3586 return io.ErrUnexpectedEOF
3587 }
3588 m.Items = append(m.Items, Deployment{})
3589 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3590 return err
3591 }
3592 iNdEx = postIndex
3593 default:
3594 iNdEx = preIndex
3595 skippy, err := skipGenerated(dAtA[iNdEx:])
3596 if err != nil {
3597 return err
3598 }
3599 if (skippy < 0) || (iNdEx+skippy) < 0 {
3600 return ErrInvalidLengthGenerated
3601 }
3602 if (iNdEx + skippy) > l {
3603 return io.ErrUnexpectedEOF
3604 }
3605 iNdEx += skippy
3606 }
3607 }
3608
3609 if iNdEx > l {
3610 return io.ErrUnexpectedEOF
3611 }
3612 return nil
3613 }
3614 func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
3615 l := len(dAtA)
3616 iNdEx := 0
3617 for iNdEx < l {
3618 preIndex := iNdEx
3619 var wire uint64
3620 for shift := uint(0); ; shift += 7 {
3621 if shift >= 64 {
3622 return ErrIntOverflowGenerated
3623 }
3624 if iNdEx >= l {
3625 return io.ErrUnexpectedEOF
3626 }
3627 b := dAtA[iNdEx]
3628 iNdEx++
3629 wire |= uint64(b&0x7F) << shift
3630 if b < 0x80 {
3631 break
3632 }
3633 }
3634 fieldNum := int32(wire >> 3)
3635 wireType := int(wire & 0x7)
3636 if wireType == 4 {
3637 return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
3638 }
3639 if fieldNum <= 0 {
3640 return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
3641 }
3642 switch fieldNum {
3643 case 1:
3644 if wireType != 2 {
3645 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
3646 }
3647 var stringLen uint64
3648 for shift := uint(0); ; shift += 7 {
3649 if shift >= 64 {
3650 return ErrIntOverflowGenerated
3651 }
3652 if iNdEx >= l {
3653 return io.ErrUnexpectedEOF
3654 }
3655 b := dAtA[iNdEx]
3656 iNdEx++
3657 stringLen |= uint64(b&0x7F) << shift
3658 if b < 0x80 {
3659 break
3660 }
3661 }
3662 intStringLen := int(stringLen)
3663 if intStringLen < 0 {
3664 return ErrInvalidLengthGenerated
3665 }
3666 postIndex := iNdEx + intStringLen
3667 if postIndex < 0 {
3668 return ErrInvalidLengthGenerated
3669 }
3670 if postIndex > l {
3671 return io.ErrUnexpectedEOF
3672 }
3673 m.Name = string(dAtA[iNdEx:postIndex])
3674 iNdEx = postIndex
3675 case 2:
3676 if wireType != 2 {
3677 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
3678 }
3679 var msglen int
3680 for shift := uint(0); ; shift += 7 {
3681 if shift >= 64 {
3682 return ErrIntOverflowGenerated
3683 }
3684 if iNdEx >= l {
3685 return io.ErrUnexpectedEOF
3686 }
3687 b := dAtA[iNdEx]
3688 iNdEx++
3689 msglen |= int(b&0x7F) << shift
3690 if b < 0x80 {
3691 break
3692 }
3693 }
3694 if msglen < 0 {
3695 return ErrInvalidLengthGenerated
3696 }
3697 postIndex := iNdEx + msglen
3698 if postIndex < 0 {
3699 return ErrInvalidLengthGenerated
3700 }
3701 if postIndex > l {
3702 return io.ErrUnexpectedEOF
3703 }
3704 if m.UpdatedAnnotations == nil {
3705 m.UpdatedAnnotations = make(map[string]string)
3706 }
3707 var mapkey string
3708 var mapvalue string
3709 for iNdEx < postIndex {
3710 entryPreIndex := iNdEx
3711 var wire uint64
3712 for shift := uint(0); ; shift += 7 {
3713 if shift >= 64 {
3714 return ErrIntOverflowGenerated
3715 }
3716 if iNdEx >= l {
3717 return io.ErrUnexpectedEOF
3718 }
3719 b := dAtA[iNdEx]
3720 iNdEx++
3721 wire |= uint64(b&0x7F) << shift
3722 if b < 0x80 {
3723 break
3724 }
3725 }
3726 fieldNum := int32(wire >> 3)
3727 if fieldNum == 1 {
3728 var stringLenmapkey uint64
3729 for shift := uint(0); ; shift += 7 {
3730 if shift >= 64 {
3731 return ErrIntOverflowGenerated
3732 }
3733 if iNdEx >= l {
3734 return io.ErrUnexpectedEOF
3735 }
3736 b := dAtA[iNdEx]
3737 iNdEx++
3738 stringLenmapkey |= uint64(b&0x7F) << shift
3739 if b < 0x80 {
3740 break
3741 }
3742 }
3743 intStringLenmapkey := int(stringLenmapkey)
3744 if intStringLenmapkey < 0 {
3745 return ErrInvalidLengthGenerated
3746 }
3747 postStringIndexmapkey := iNdEx + intStringLenmapkey
3748 if postStringIndexmapkey < 0 {
3749 return ErrInvalidLengthGenerated
3750 }
3751 if postStringIndexmapkey > l {
3752 return io.ErrUnexpectedEOF
3753 }
3754 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
3755 iNdEx = postStringIndexmapkey
3756 } else if fieldNum == 2 {
3757 var stringLenmapvalue uint64
3758 for shift := uint(0); ; shift += 7 {
3759 if shift >= 64 {
3760 return ErrIntOverflowGenerated
3761 }
3762 if iNdEx >= l {
3763 return io.ErrUnexpectedEOF
3764 }
3765 b := dAtA[iNdEx]
3766 iNdEx++
3767 stringLenmapvalue |= uint64(b&0x7F) << shift
3768 if b < 0x80 {
3769 break
3770 }
3771 }
3772 intStringLenmapvalue := int(stringLenmapvalue)
3773 if intStringLenmapvalue < 0 {
3774 return ErrInvalidLengthGenerated
3775 }
3776 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
3777 if postStringIndexmapvalue < 0 {
3778 return ErrInvalidLengthGenerated
3779 }
3780 if postStringIndexmapvalue > l {
3781 return io.ErrUnexpectedEOF
3782 }
3783 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
3784 iNdEx = postStringIndexmapvalue
3785 } else {
3786 iNdEx = entryPreIndex
3787 skippy, err := skipGenerated(dAtA[iNdEx:])
3788 if err != nil {
3789 return err
3790 }
3791 if (skippy < 0) || (iNdEx+skippy) < 0 {
3792 return ErrInvalidLengthGenerated
3793 }
3794 if (iNdEx + skippy) > postIndex {
3795 return io.ErrUnexpectedEOF
3796 }
3797 iNdEx += skippy
3798 }
3799 }
3800 m.UpdatedAnnotations[mapkey] = mapvalue
3801 iNdEx = postIndex
3802 case 3:
3803 if wireType != 2 {
3804 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
3805 }
3806 var msglen int
3807 for shift := uint(0); ; shift += 7 {
3808 if shift >= 64 {
3809 return ErrIntOverflowGenerated
3810 }
3811 if iNdEx >= l {
3812 return io.ErrUnexpectedEOF
3813 }
3814 b := dAtA[iNdEx]
3815 iNdEx++
3816 msglen |= int(b&0x7F) << shift
3817 if b < 0x80 {
3818 break
3819 }
3820 }
3821 if msglen < 0 {
3822 return ErrInvalidLengthGenerated
3823 }
3824 postIndex := iNdEx + msglen
3825 if postIndex < 0 {
3826 return ErrInvalidLengthGenerated
3827 }
3828 if postIndex > l {
3829 return io.ErrUnexpectedEOF
3830 }
3831 if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3832 return err
3833 }
3834 iNdEx = postIndex
3835 default:
3836 iNdEx = preIndex
3837 skippy, err := skipGenerated(dAtA[iNdEx:])
3838 if err != nil {
3839 return err
3840 }
3841 if (skippy < 0) || (iNdEx+skippy) < 0 {
3842 return ErrInvalidLengthGenerated
3843 }
3844 if (iNdEx + skippy) > l {
3845 return io.ErrUnexpectedEOF
3846 }
3847 iNdEx += skippy
3848 }
3849 }
3850
3851 if iNdEx > l {
3852 return io.ErrUnexpectedEOF
3853 }
3854 return nil
3855 }
3856 func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
3857 l := len(dAtA)
3858 iNdEx := 0
3859 for iNdEx < l {
3860 preIndex := iNdEx
3861 var wire uint64
3862 for shift := uint(0); ; shift += 7 {
3863 if shift >= 64 {
3864 return ErrIntOverflowGenerated
3865 }
3866 if iNdEx >= l {
3867 return io.ErrUnexpectedEOF
3868 }
3869 b := dAtA[iNdEx]
3870 iNdEx++
3871 wire |= uint64(b&0x7F) << shift
3872 if b < 0x80 {
3873 break
3874 }
3875 }
3876 fieldNum := int32(wire >> 3)
3877 wireType := int(wire & 0x7)
3878 if wireType == 4 {
3879 return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
3880 }
3881 if fieldNum <= 0 {
3882 return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3883 }
3884 switch fieldNum {
3885 case 1:
3886 if wireType != 0 {
3887 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
3888 }
3889 var v int32
3890 for shift := uint(0); ; shift += 7 {
3891 if shift >= 64 {
3892 return ErrIntOverflowGenerated
3893 }
3894 if iNdEx >= l {
3895 return io.ErrUnexpectedEOF
3896 }
3897 b := dAtA[iNdEx]
3898 iNdEx++
3899 v |= int32(b&0x7F) << shift
3900 if b < 0x80 {
3901 break
3902 }
3903 }
3904 m.Replicas = &v
3905 case 2:
3906 if wireType != 2 {
3907 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
3908 }
3909 var msglen int
3910 for shift := uint(0); ; shift += 7 {
3911 if shift >= 64 {
3912 return ErrIntOverflowGenerated
3913 }
3914 if iNdEx >= l {
3915 return io.ErrUnexpectedEOF
3916 }
3917 b := dAtA[iNdEx]
3918 iNdEx++
3919 msglen |= int(b&0x7F) << shift
3920 if b < 0x80 {
3921 break
3922 }
3923 }
3924 if msglen < 0 {
3925 return ErrInvalidLengthGenerated
3926 }
3927 postIndex := iNdEx + msglen
3928 if postIndex < 0 {
3929 return ErrInvalidLengthGenerated
3930 }
3931 if postIndex > l {
3932 return io.ErrUnexpectedEOF
3933 }
3934 if m.Selector == nil {
3935 m.Selector = &v1.LabelSelector{}
3936 }
3937 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3938 return err
3939 }
3940 iNdEx = postIndex
3941 case 3:
3942 if wireType != 2 {
3943 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
3944 }
3945 var msglen int
3946 for shift := uint(0); ; shift += 7 {
3947 if shift >= 64 {
3948 return ErrIntOverflowGenerated
3949 }
3950 if iNdEx >= l {
3951 return io.ErrUnexpectedEOF
3952 }
3953 b := dAtA[iNdEx]
3954 iNdEx++
3955 msglen |= int(b&0x7F) << shift
3956 if b < 0x80 {
3957 break
3958 }
3959 }
3960 if msglen < 0 {
3961 return ErrInvalidLengthGenerated
3962 }
3963 postIndex := iNdEx + msglen
3964 if postIndex < 0 {
3965 return ErrInvalidLengthGenerated
3966 }
3967 if postIndex > l {
3968 return io.ErrUnexpectedEOF
3969 }
3970 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3971 return err
3972 }
3973 iNdEx = postIndex
3974 case 4:
3975 if wireType != 2 {
3976 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
3977 }
3978 var msglen int
3979 for shift := uint(0); ; shift += 7 {
3980 if shift >= 64 {
3981 return ErrIntOverflowGenerated
3982 }
3983 if iNdEx >= l {
3984 return io.ErrUnexpectedEOF
3985 }
3986 b := dAtA[iNdEx]
3987 iNdEx++
3988 msglen |= int(b&0x7F) << shift
3989 if b < 0x80 {
3990 break
3991 }
3992 }
3993 if msglen < 0 {
3994 return ErrInvalidLengthGenerated
3995 }
3996 postIndex := iNdEx + msglen
3997 if postIndex < 0 {
3998 return ErrInvalidLengthGenerated
3999 }
4000 if postIndex > l {
4001 return io.ErrUnexpectedEOF
4002 }
4003 if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4004 return err
4005 }
4006 iNdEx = postIndex
4007 case 5:
4008 if wireType != 0 {
4009 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
4010 }
4011 m.MinReadySeconds = 0
4012 for shift := uint(0); ; shift += 7 {
4013 if shift >= 64 {
4014 return ErrIntOverflowGenerated
4015 }
4016 if iNdEx >= l {
4017 return io.ErrUnexpectedEOF
4018 }
4019 b := dAtA[iNdEx]
4020 iNdEx++
4021 m.MinReadySeconds |= int32(b&0x7F) << shift
4022 if b < 0x80 {
4023 break
4024 }
4025 }
4026 case 6:
4027 if wireType != 0 {
4028 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
4029 }
4030 var v int32
4031 for shift := uint(0); ; shift += 7 {
4032 if shift >= 64 {
4033 return ErrIntOverflowGenerated
4034 }
4035 if iNdEx >= l {
4036 return io.ErrUnexpectedEOF
4037 }
4038 b := dAtA[iNdEx]
4039 iNdEx++
4040 v |= int32(b&0x7F) << shift
4041 if b < 0x80 {
4042 break
4043 }
4044 }
4045 m.RevisionHistoryLimit = &v
4046 case 7:
4047 if wireType != 0 {
4048 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
4049 }
4050 var v int
4051 for shift := uint(0); ; shift += 7 {
4052 if shift >= 64 {
4053 return ErrIntOverflowGenerated
4054 }
4055 if iNdEx >= l {
4056 return io.ErrUnexpectedEOF
4057 }
4058 b := dAtA[iNdEx]
4059 iNdEx++
4060 v |= int(b&0x7F) << shift
4061 if b < 0x80 {
4062 break
4063 }
4064 }
4065 m.Paused = bool(v != 0)
4066 case 8:
4067 if wireType != 2 {
4068 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
4069 }
4070 var msglen int
4071 for shift := uint(0); ; shift += 7 {
4072 if shift >= 64 {
4073 return ErrIntOverflowGenerated
4074 }
4075 if iNdEx >= l {
4076 return io.ErrUnexpectedEOF
4077 }
4078 b := dAtA[iNdEx]
4079 iNdEx++
4080 msglen |= int(b&0x7F) << shift
4081 if b < 0x80 {
4082 break
4083 }
4084 }
4085 if msglen < 0 {
4086 return ErrInvalidLengthGenerated
4087 }
4088 postIndex := iNdEx + msglen
4089 if postIndex < 0 {
4090 return ErrInvalidLengthGenerated
4091 }
4092 if postIndex > l {
4093 return io.ErrUnexpectedEOF
4094 }
4095 if m.RollbackTo == nil {
4096 m.RollbackTo = &RollbackConfig{}
4097 }
4098 if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4099 return err
4100 }
4101 iNdEx = postIndex
4102 case 9:
4103 if wireType != 0 {
4104 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
4105 }
4106 var v int32
4107 for shift := uint(0); ; shift += 7 {
4108 if shift >= 64 {
4109 return ErrIntOverflowGenerated
4110 }
4111 if iNdEx >= l {
4112 return io.ErrUnexpectedEOF
4113 }
4114 b := dAtA[iNdEx]
4115 iNdEx++
4116 v |= int32(b&0x7F) << shift
4117 if b < 0x80 {
4118 break
4119 }
4120 }
4121 m.ProgressDeadlineSeconds = &v
4122 default:
4123 iNdEx = preIndex
4124 skippy, err := skipGenerated(dAtA[iNdEx:])
4125 if err != nil {
4126 return err
4127 }
4128 if (skippy < 0) || (iNdEx+skippy) < 0 {
4129 return ErrInvalidLengthGenerated
4130 }
4131 if (iNdEx + skippy) > l {
4132 return io.ErrUnexpectedEOF
4133 }
4134 iNdEx += skippy
4135 }
4136 }
4137
4138 if iNdEx > l {
4139 return io.ErrUnexpectedEOF
4140 }
4141 return nil
4142 }
4143 func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
4144 l := len(dAtA)
4145 iNdEx := 0
4146 for iNdEx < l {
4147 preIndex := iNdEx
4148 var wire uint64
4149 for shift := uint(0); ; shift += 7 {
4150 if shift >= 64 {
4151 return ErrIntOverflowGenerated
4152 }
4153 if iNdEx >= l {
4154 return io.ErrUnexpectedEOF
4155 }
4156 b := dAtA[iNdEx]
4157 iNdEx++
4158 wire |= uint64(b&0x7F) << shift
4159 if b < 0x80 {
4160 break
4161 }
4162 }
4163 fieldNum := int32(wire >> 3)
4164 wireType := int(wire & 0x7)
4165 if wireType == 4 {
4166 return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
4167 }
4168 if fieldNum <= 0 {
4169 return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4170 }
4171 switch fieldNum {
4172 case 1:
4173 if wireType != 0 {
4174 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
4175 }
4176 m.ObservedGeneration = 0
4177 for shift := uint(0); ; shift += 7 {
4178 if shift >= 64 {
4179 return ErrIntOverflowGenerated
4180 }
4181 if iNdEx >= l {
4182 return io.ErrUnexpectedEOF
4183 }
4184 b := dAtA[iNdEx]
4185 iNdEx++
4186 m.ObservedGeneration |= int64(b&0x7F) << shift
4187 if b < 0x80 {
4188 break
4189 }
4190 }
4191 case 2:
4192 if wireType != 0 {
4193 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4194 }
4195 m.Replicas = 0
4196 for shift := uint(0); ; shift += 7 {
4197 if shift >= 64 {
4198 return ErrIntOverflowGenerated
4199 }
4200 if iNdEx >= l {
4201 return io.ErrUnexpectedEOF
4202 }
4203 b := dAtA[iNdEx]
4204 iNdEx++
4205 m.Replicas |= int32(b&0x7F) << shift
4206 if b < 0x80 {
4207 break
4208 }
4209 }
4210 case 3:
4211 if wireType != 0 {
4212 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
4213 }
4214 m.UpdatedReplicas = 0
4215 for shift := uint(0); ; shift += 7 {
4216 if shift >= 64 {
4217 return ErrIntOverflowGenerated
4218 }
4219 if iNdEx >= l {
4220 return io.ErrUnexpectedEOF
4221 }
4222 b := dAtA[iNdEx]
4223 iNdEx++
4224 m.UpdatedReplicas |= int32(b&0x7F) << shift
4225 if b < 0x80 {
4226 break
4227 }
4228 }
4229 case 4:
4230 if wireType != 0 {
4231 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
4232 }
4233 m.AvailableReplicas = 0
4234 for shift := uint(0); ; shift += 7 {
4235 if shift >= 64 {
4236 return ErrIntOverflowGenerated
4237 }
4238 if iNdEx >= l {
4239 return io.ErrUnexpectedEOF
4240 }
4241 b := dAtA[iNdEx]
4242 iNdEx++
4243 m.AvailableReplicas |= int32(b&0x7F) << shift
4244 if b < 0x80 {
4245 break
4246 }
4247 }
4248 case 5:
4249 if wireType != 0 {
4250 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
4251 }
4252 m.UnavailableReplicas = 0
4253 for shift := uint(0); ; shift += 7 {
4254 if shift >= 64 {
4255 return ErrIntOverflowGenerated
4256 }
4257 if iNdEx >= l {
4258 return io.ErrUnexpectedEOF
4259 }
4260 b := dAtA[iNdEx]
4261 iNdEx++
4262 m.UnavailableReplicas |= int32(b&0x7F) << shift
4263 if b < 0x80 {
4264 break
4265 }
4266 }
4267 case 6:
4268 if wireType != 2 {
4269 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
4270 }
4271 var msglen int
4272 for shift := uint(0); ; shift += 7 {
4273 if shift >= 64 {
4274 return ErrIntOverflowGenerated
4275 }
4276 if iNdEx >= l {
4277 return io.ErrUnexpectedEOF
4278 }
4279 b := dAtA[iNdEx]
4280 iNdEx++
4281 msglen |= int(b&0x7F) << shift
4282 if b < 0x80 {
4283 break
4284 }
4285 }
4286 if msglen < 0 {
4287 return ErrInvalidLengthGenerated
4288 }
4289 postIndex := iNdEx + msglen
4290 if postIndex < 0 {
4291 return ErrInvalidLengthGenerated
4292 }
4293 if postIndex > l {
4294 return io.ErrUnexpectedEOF
4295 }
4296 m.Conditions = append(m.Conditions, DeploymentCondition{})
4297 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4298 return err
4299 }
4300 iNdEx = postIndex
4301 case 7:
4302 if wireType != 0 {
4303 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
4304 }
4305 m.ReadyReplicas = 0
4306 for shift := uint(0); ; shift += 7 {
4307 if shift >= 64 {
4308 return ErrIntOverflowGenerated
4309 }
4310 if iNdEx >= l {
4311 return io.ErrUnexpectedEOF
4312 }
4313 b := dAtA[iNdEx]
4314 iNdEx++
4315 m.ReadyReplicas |= int32(b&0x7F) << shift
4316 if b < 0x80 {
4317 break
4318 }
4319 }
4320 case 8:
4321 if wireType != 0 {
4322 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
4323 }
4324 var v int32
4325 for shift := uint(0); ; shift += 7 {
4326 if shift >= 64 {
4327 return ErrIntOverflowGenerated
4328 }
4329 if iNdEx >= l {
4330 return io.ErrUnexpectedEOF
4331 }
4332 b := dAtA[iNdEx]
4333 iNdEx++
4334 v |= int32(b&0x7F) << shift
4335 if b < 0x80 {
4336 break
4337 }
4338 }
4339 m.CollisionCount = &v
4340 default:
4341 iNdEx = preIndex
4342 skippy, err := skipGenerated(dAtA[iNdEx:])
4343 if err != nil {
4344 return err
4345 }
4346 if (skippy < 0) || (iNdEx+skippy) < 0 {
4347 return ErrInvalidLengthGenerated
4348 }
4349 if (iNdEx + skippy) > l {
4350 return io.ErrUnexpectedEOF
4351 }
4352 iNdEx += skippy
4353 }
4354 }
4355
4356 if iNdEx > l {
4357 return io.ErrUnexpectedEOF
4358 }
4359 return nil
4360 }
4361 func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
4362 l := len(dAtA)
4363 iNdEx := 0
4364 for iNdEx < l {
4365 preIndex := iNdEx
4366 var wire uint64
4367 for shift := uint(0); ; shift += 7 {
4368 if shift >= 64 {
4369 return ErrIntOverflowGenerated
4370 }
4371 if iNdEx >= l {
4372 return io.ErrUnexpectedEOF
4373 }
4374 b := dAtA[iNdEx]
4375 iNdEx++
4376 wire |= uint64(b&0x7F) << shift
4377 if b < 0x80 {
4378 break
4379 }
4380 }
4381 fieldNum := int32(wire >> 3)
4382 wireType := int(wire & 0x7)
4383 if wireType == 4 {
4384 return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
4385 }
4386 if fieldNum <= 0 {
4387 return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
4388 }
4389 switch fieldNum {
4390 case 1:
4391 if wireType != 2 {
4392 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
4393 }
4394 var stringLen uint64
4395 for shift := uint(0); ; shift += 7 {
4396 if shift >= 64 {
4397 return ErrIntOverflowGenerated
4398 }
4399 if iNdEx >= l {
4400 return io.ErrUnexpectedEOF
4401 }
4402 b := dAtA[iNdEx]
4403 iNdEx++
4404 stringLen |= uint64(b&0x7F) << shift
4405 if b < 0x80 {
4406 break
4407 }
4408 }
4409 intStringLen := int(stringLen)
4410 if intStringLen < 0 {
4411 return ErrInvalidLengthGenerated
4412 }
4413 postIndex := iNdEx + intStringLen
4414 if postIndex < 0 {
4415 return ErrInvalidLengthGenerated
4416 }
4417 if postIndex > l {
4418 return io.ErrUnexpectedEOF
4419 }
4420 m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
4421 iNdEx = postIndex
4422 case 2:
4423 if wireType != 2 {
4424 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
4425 }
4426 var msglen int
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 msglen |= int(b&0x7F) << shift
4437 if b < 0x80 {
4438 break
4439 }
4440 }
4441 if msglen < 0 {
4442 return ErrInvalidLengthGenerated
4443 }
4444 postIndex := iNdEx + msglen
4445 if postIndex < 0 {
4446 return ErrInvalidLengthGenerated
4447 }
4448 if postIndex > l {
4449 return io.ErrUnexpectedEOF
4450 }
4451 if m.RollingUpdate == nil {
4452 m.RollingUpdate = &RollingUpdateDeployment{}
4453 }
4454 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4455 return err
4456 }
4457 iNdEx = postIndex
4458 default:
4459 iNdEx = preIndex
4460 skippy, err := skipGenerated(dAtA[iNdEx:])
4461 if err != nil {
4462 return err
4463 }
4464 if (skippy < 0) || (iNdEx+skippy) < 0 {
4465 return ErrInvalidLengthGenerated
4466 }
4467 if (iNdEx + skippy) > l {
4468 return io.ErrUnexpectedEOF
4469 }
4470 iNdEx += skippy
4471 }
4472 }
4473
4474 if iNdEx > l {
4475 return io.ErrUnexpectedEOF
4476 }
4477 return nil
4478 }
4479 func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
4480 l := len(dAtA)
4481 iNdEx := 0
4482 for iNdEx < l {
4483 preIndex := iNdEx
4484 var wire uint64
4485 for shift := uint(0); ; shift += 7 {
4486 if shift >= 64 {
4487 return ErrIntOverflowGenerated
4488 }
4489 if iNdEx >= l {
4490 return io.ErrUnexpectedEOF
4491 }
4492 b := dAtA[iNdEx]
4493 iNdEx++
4494 wire |= uint64(b&0x7F) << shift
4495 if b < 0x80 {
4496 break
4497 }
4498 }
4499 fieldNum := int32(wire >> 3)
4500 wireType := int(wire & 0x7)
4501 if wireType == 4 {
4502 return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
4503 }
4504 if fieldNum <= 0 {
4505 return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
4506 }
4507 switch fieldNum {
4508 case 1:
4509 if wireType != 0 {
4510 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
4511 }
4512 m.Revision = 0
4513 for shift := uint(0); ; shift += 7 {
4514 if shift >= 64 {
4515 return ErrIntOverflowGenerated
4516 }
4517 if iNdEx >= l {
4518 return io.ErrUnexpectedEOF
4519 }
4520 b := dAtA[iNdEx]
4521 iNdEx++
4522 m.Revision |= int64(b&0x7F) << shift
4523 if b < 0x80 {
4524 break
4525 }
4526 }
4527 default:
4528 iNdEx = preIndex
4529 skippy, err := skipGenerated(dAtA[iNdEx:])
4530 if err != nil {
4531 return err
4532 }
4533 if (skippy < 0) || (iNdEx+skippy) < 0 {
4534 return ErrInvalidLengthGenerated
4535 }
4536 if (iNdEx + skippy) > l {
4537 return io.ErrUnexpectedEOF
4538 }
4539 iNdEx += skippy
4540 }
4541 }
4542
4543 if iNdEx > l {
4544 return io.ErrUnexpectedEOF
4545 }
4546 return nil
4547 }
4548 func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
4549 l := len(dAtA)
4550 iNdEx := 0
4551 for iNdEx < l {
4552 preIndex := iNdEx
4553 var wire uint64
4554 for shift := uint(0); ; shift += 7 {
4555 if shift >= 64 {
4556 return ErrIntOverflowGenerated
4557 }
4558 if iNdEx >= l {
4559 return io.ErrUnexpectedEOF
4560 }
4561 b := dAtA[iNdEx]
4562 iNdEx++
4563 wire |= uint64(b&0x7F) << shift
4564 if b < 0x80 {
4565 break
4566 }
4567 }
4568 fieldNum := int32(wire >> 3)
4569 wireType := int(wire & 0x7)
4570 if wireType == 4 {
4571 return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
4572 }
4573 if fieldNum <= 0 {
4574 return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
4575 }
4576 switch fieldNum {
4577 case 1:
4578 if wireType != 2 {
4579 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
4580 }
4581 var msglen int
4582 for shift := uint(0); ; shift += 7 {
4583 if shift >= 64 {
4584 return ErrIntOverflowGenerated
4585 }
4586 if iNdEx >= l {
4587 return io.ErrUnexpectedEOF
4588 }
4589 b := dAtA[iNdEx]
4590 iNdEx++
4591 msglen |= int(b&0x7F) << shift
4592 if b < 0x80 {
4593 break
4594 }
4595 }
4596 if msglen < 0 {
4597 return ErrInvalidLengthGenerated
4598 }
4599 postIndex := iNdEx + msglen
4600 if postIndex < 0 {
4601 return ErrInvalidLengthGenerated
4602 }
4603 if postIndex > l {
4604 return io.ErrUnexpectedEOF
4605 }
4606 if m.MaxUnavailable == nil {
4607 m.MaxUnavailable = &intstr.IntOrString{}
4608 }
4609 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4610 return err
4611 }
4612 iNdEx = postIndex
4613 case 2:
4614 if wireType != 2 {
4615 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
4616 }
4617 var msglen int
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 msglen |= int(b&0x7F) << shift
4628 if b < 0x80 {
4629 break
4630 }
4631 }
4632 if msglen < 0 {
4633 return ErrInvalidLengthGenerated
4634 }
4635 postIndex := iNdEx + msglen
4636 if postIndex < 0 {
4637 return ErrInvalidLengthGenerated
4638 }
4639 if postIndex > l {
4640 return io.ErrUnexpectedEOF
4641 }
4642 if m.MaxSurge == nil {
4643 m.MaxSurge = &intstr.IntOrString{}
4644 }
4645 if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4646 return err
4647 }
4648 iNdEx = postIndex
4649 default:
4650 iNdEx = preIndex
4651 skippy, err := skipGenerated(dAtA[iNdEx:])
4652 if err != nil {
4653 return err
4654 }
4655 if (skippy < 0) || (iNdEx+skippy) < 0 {
4656 return ErrInvalidLengthGenerated
4657 }
4658 if (iNdEx + skippy) > l {
4659 return io.ErrUnexpectedEOF
4660 }
4661 iNdEx += skippy
4662 }
4663 }
4664
4665 if iNdEx > l {
4666 return io.ErrUnexpectedEOF
4667 }
4668 return nil
4669 }
4670 func (m *RollingUpdateStatefulSetStrategy) Unmarshal(dAtA []byte) error {
4671 l := len(dAtA)
4672 iNdEx := 0
4673 for iNdEx < l {
4674 preIndex := iNdEx
4675 var wire uint64
4676 for shift := uint(0); ; shift += 7 {
4677 if shift >= 64 {
4678 return ErrIntOverflowGenerated
4679 }
4680 if iNdEx >= l {
4681 return io.ErrUnexpectedEOF
4682 }
4683 b := dAtA[iNdEx]
4684 iNdEx++
4685 wire |= uint64(b&0x7F) << shift
4686 if b < 0x80 {
4687 break
4688 }
4689 }
4690 fieldNum := int32(wire >> 3)
4691 wireType := int(wire & 0x7)
4692 if wireType == 4 {
4693 return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: wiretype end group for non-group")
4694 }
4695 if fieldNum <= 0 {
4696 return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
4697 }
4698 switch fieldNum {
4699 case 1:
4700 if wireType != 0 {
4701 return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
4702 }
4703 var v int32
4704 for shift := uint(0); ; shift += 7 {
4705 if shift >= 64 {
4706 return ErrIntOverflowGenerated
4707 }
4708 if iNdEx >= l {
4709 return io.ErrUnexpectedEOF
4710 }
4711 b := dAtA[iNdEx]
4712 iNdEx++
4713 v |= int32(b&0x7F) << shift
4714 if b < 0x80 {
4715 break
4716 }
4717 }
4718 m.Partition = &v
4719 case 2:
4720 if wireType != 2 {
4721 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
4722 }
4723 var msglen int
4724 for shift := uint(0); ; shift += 7 {
4725 if shift >= 64 {
4726 return ErrIntOverflowGenerated
4727 }
4728 if iNdEx >= l {
4729 return io.ErrUnexpectedEOF
4730 }
4731 b := dAtA[iNdEx]
4732 iNdEx++
4733 msglen |= int(b&0x7F) << shift
4734 if b < 0x80 {
4735 break
4736 }
4737 }
4738 if msglen < 0 {
4739 return ErrInvalidLengthGenerated
4740 }
4741 postIndex := iNdEx + msglen
4742 if postIndex < 0 {
4743 return ErrInvalidLengthGenerated
4744 }
4745 if postIndex > l {
4746 return io.ErrUnexpectedEOF
4747 }
4748 if m.MaxUnavailable == nil {
4749 m.MaxUnavailable = &intstr.IntOrString{}
4750 }
4751 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4752 return err
4753 }
4754 iNdEx = postIndex
4755 default:
4756 iNdEx = preIndex
4757 skippy, err := skipGenerated(dAtA[iNdEx:])
4758 if err != nil {
4759 return err
4760 }
4761 if (skippy < 0) || (iNdEx+skippy) < 0 {
4762 return ErrInvalidLengthGenerated
4763 }
4764 if (iNdEx + skippy) > l {
4765 return io.ErrUnexpectedEOF
4766 }
4767 iNdEx += skippy
4768 }
4769 }
4770
4771 if iNdEx > l {
4772 return io.ErrUnexpectedEOF
4773 }
4774 return nil
4775 }
4776 func (m *Scale) Unmarshal(dAtA []byte) error {
4777 l := len(dAtA)
4778 iNdEx := 0
4779 for iNdEx < l {
4780 preIndex := iNdEx
4781 var wire uint64
4782 for shift := uint(0); ; shift += 7 {
4783 if shift >= 64 {
4784 return ErrIntOverflowGenerated
4785 }
4786 if iNdEx >= l {
4787 return io.ErrUnexpectedEOF
4788 }
4789 b := dAtA[iNdEx]
4790 iNdEx++
4791 wire |= uint64(b&0x7F) << shift
4792 if b < 0x80 {
4793 break
4794 }
4795 }
4796 fieldNum := int32(wire >> 3)
4797 wireType := int(wire & 0x7)
4798 if wireType == 4 {
4799 return fmt.Errorf("proto: Scale: wiretype end group for non-group")
4800 }
4801 if fieldNum <= 0 {
4802 return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
4803 }
4804 switch fieldNum {
4805 case 1:
4806 if wireType != 2 {
4807 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4808 }
4809 var msglen int
4810 for shift := uint(0); ; shift += 7 {
4811 if shift >= 64 {
4812 return ErrIntOverflowGenerated
4813 }
4814 if iNdEx >= l {
4815 return io.ErrUnexpectedEOF
4816 }
4817 b := dAtA[iNdEx]
4818 iNdEx++
4819 msglen |= int(b&0x7F) << shift
4820 if b < 0x80 {
4821 break
4822 }
4823 }
4824 if msglen < 0 {
4825 return ErrInvalidLengthGenerated
4826 }
4827 postIndex := iNdEx + msglen
4828 if postIndex < 0 {
4829 return ErrInvalidLengthGenerated
4830 }
4831 if postIndex > l {
4832 return io.ErrUnexpectedEOF
4833 }
4834 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4835 return err
4836 }
4837 iNdEx = postIndex
4838 case 2:
4839 if wireType != 2 {
4840 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4841 }
4842 var msglen int
4843 for shift := uint(0); ; shift += 7 {
4844 if shift >= 64 {
4845 return ErrIntOverflowGenerated
4846 }
4847 if iNdEx >= l {
4848 return io.ErrUnexpectedEOF
4849 }
4850 b := dAtA[iNdEx]
4851 iNdEx++
4852 msglen |= int(b&0x7F) << shift
4853 if b < 0x80 {
4854 break
4855 }
4856 }
4857 if msglen < 0 {
4858 return ErrInvalidLengthGenerated
4859 }
4860 postIndex := iNdEx + msglen
4861 if postIndex < 0 {
4862 return ErrInvalidLengthGenerated
4863 }
4864 if postIndex > l {
4865 return io.ErrUnexpectedEOF
4866 }
4867 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4868 return err
4869 }
4870 iNdEx = postIndex
4871 case 3:
4872 if wireType != 2 {
4873 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4874 }
4875 var msglen int
4876 for shift := uint(0); ; shift += 7 {
4877 if shift >= 64 {
4878 return ErrIntOverflowGenerated
4879 }
4880 if iNdEx >= l {
4881 return io.ErrUnexpectedEOF
4882 }
4883 b := dAtA[iNdEx]
4884 iNdEx++
4885 msglen |= int(b&0x7F) << shift
4886 if b < 0x80 {
4887 break
4888 }
4889 }
4890 if msglen < 0 {
4891 return ErrInvalidLengthGenerated
4892 }
4893 postIndex := iNdEx + msglen
4894 if postIndex < 0 {
4895 return ErrInvalidLengthGenerated
4896 }
4897 if postIndex > l {
4898 return io.ErrUnexpectedEOF
4899 }
4900 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4901 return err
4902 }
4903 iNdEx = postIndex
4904 default:
4905 iNdEx = preIndex
4906 skippy, err := skipGenerated(dAtA[iNdEx:])
4907 if err != nil {
4908 return err
4909 }
4910 if (skippy < 0) || (iNdEx+skippy) < 0 {
4911 return ErrInvalidLengthGenerated
4912 }
4913 if (iNdEx + skippy) > l {
4914 return io.ErrUnexpectedEOF
4915 }
4916 iNdEx += skippy
4917 }
4918 }
4919
4920 if iNdEx > l {
4921 return io.ErrUnexpectedEOF
4922 }
4923 return nil
4924 }
4925 func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
4926 l := len(dAtA)
4927 iNdEx := 0
4928 for iNdEx < l {
4929 preIndex := iNdEx
4930 var wire uint64
4931 for shift := uint(0); ; shift += 7 {
4932 if shift >= 64 {
4933 return ErrIntOverflowGenerated
4934 }
4935 if iNdEx >= l {
4936 return io.ErrUnexpectedEOF
4937 }
4938 b := dAtA[iNdEx]
4939 iNdEx++
4940 wire |= uint64(b&0x7F) << shift
4941 if b < 0x80 {
4942 break
4943 }
4944 }
4945 fieldNum := int32(wire >> 3)
4946 wireType := int(wire & 0x7)
4947 if wireType == 4 {
4948 return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
4949 }
4950 if fieldNum <= 0 {
4951 return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4952 }
4953 switch fieldNum {
4954 case 1:
4955 if wireType != 0 {
4956 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4957 }
4958 m.Replicas = 0
4959 for shift := uint(0); ; shift += 7 {
4960 if shift >= 64 {
4961 return ErrIntOverflowGenerated
4962 }
4963 if iNdEx >= l {
4964 return io.ErrUnexpectedEOF
4965 }
4966 b := dAtA[iNdEx]
4967 iNdEx++
4968 m.Replicas |= int32(b&0x7F) << shift
4969 if b < 0x80 {
4970 break
4971 }
4972 }
4973 default:
4974 iNdEx = preIndex
4975 skippy, err := skipGenerated(dAtA[iNdEx:])
4976 if err != nil {
4977 return err
4978 }
4979 if (skippy < 0) || (iNdEx+skippy) < 0 {
4980 return ErrInvalidLengthGenerated
4981 }
4982 if (iNdEx + skippy) > l {
4983 return io.ErrUnexpectedEOF
4984 }
4985 iNdEx += skippy
4986 }
4987 }
4988
4989 if iNdEx > l {
4990 return io.ErrUnexpectedEOF
4991 }
4992 return nil
4993 }
4994 func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
4995 l := len(dAtA)
4996 iNdEx := 0
4997 for iNdEx < l {
4998 preIndex := iNdEx
4999 var wire uint64
5000 for shift := uint(0); ; shift += 7 {
5001 if shift >= 64 {
5002 return ErrIntOverflowGenerated
5003 }
5004 if iNdEx >= l {
5005 return io.ErrUnexpectedEOF
5006 }
5007 b := dAtA[iNdEx]
5008 iNdEx++
5009 wire |= uint64(b&0x7F) << shift
5010 if b < 0x80 {
5011 break
5012 }
5013 }
5014 fieldNum := int32(wire >> 3)
5015 wireType := int(wire & 0x7)
5016 if wireType == 4 {
5017 return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
5018 }
5019 if fieldNum <= 0 {
5020 return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
5021 }
5022 switch fieldNum {
5023 case 1:
5024 if wireType != 0 {
5025 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
5026 }
5027 m.Replicas = 0
5028 for shift := uint(0); ; shift += 7 {
5029 if shift >= 64 {
5030 return ErrIntOverflowGenerated
5031 }
5032 if iNdEx >= l {
5033 return io.ErrUnexpectedEOF
5034 }
5035 b := dAtA[iNdEx]
5036 iNdEx++
5037 m.Replicas |= int32(b&0x7F) << shift
5038 if b < 0x80 {
5039 break
5040 }
5041 }
5042 case 2:
5043 if wireType != 2 {
5044 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
5045 }
5046 var msglen int
5047 for shift := uint(0); ; shift += 7 {
5048 if shift >= 64 {
5049 return ErrIntOverflowGenerated
5050 }
5051 if iNdEx >= l {
5052 return io.ErrUnexpectedEOF
5053 }
5054 b := dAtA[iNdEx]
5055 iNdEx++
5056 msglen |= int(b&0x7F) << shift
5057 if b < 0x80 {
5058 break
5059 }
5060 }
5061 if msglen < 0 {
5062 return ErrInvalidLengthGenerated
5063 }
5064 postIndex := iNdEx + msglen
5065 if postIndex < 0 {
5066 return ErrInvalidLengthGenerated
5067 }
5068 if postIndex > l {
5069 return io.ErrUnexpectedEOF
5070 }
5071 if m.Selector == nil {
5072 m.Selector = make(map[string]string)
5073 }
5074 var mapkey string
5075 var mapvalue string
5076 for iNdEx < postIndex {
5077 entryPreIndex := iNdEx
5078 var wire uint64
5079 for shift := uint(0); ; shift += 7 {
5080 if shift >= 64 {
5081 return ErrIntOverflowGenerated
5082 }
5083 if iNdEx >= l {
5084 return io.ErrUnexpectedEOF
5085 }
5086 b := dAtA[iNdEx]
5087 iNdEx++
5088 wire |= uint64(b&0x7F) << shift
5089 if b < 0x80 {
5090 break
5091 }
5092 }
5093 fieldNum := int32(wire >> 3)
5094 if fieldNum == 1 {
5095 var stringLenmapkey uint64
5096 for shift := uint(0); ; shift += 7 {
5097 if shift >= 64 {
5098 return ErrIntOverflowGenerated
5099 }
5100 if iNdEx >= l {
5101 return io.ErrUnexpectedEOF
5102 }
5103 b := dAtA[iNdEx]
5104 iNdEx++
5105 stringLenmapkey |= uint64(b&0x7F) << shift
5106 if b < 0x80 {
5107 break
5108 }
5109 }
5110 intStringLenmapkey := int(stringLenmapkey)
5111 if intStringLenmapkey < 0 {
5112 return ErrInvalidLengthGenerated
5113 }
5114 postStringIndexmapkey := iNdEx + intStringLenmapkey
5115 if postStringIndexmapkey < 0 {
5116 return ErrInvalidLengthGenerated
5117 }
5118 if postStringIndexmapkey > l {
5119 return io.ErrUnexpectedEOF
5120 }
5121 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5122 iNdEx = postStringIndexmapkey
5123 } else if fieldNum == 2 {
5124 var stringLenmapvalue uint64
5125 for shift := uint(0); ; shift += 7 {
5126 if shift >= 64 {
5127 return ErrIntOverflowGenerated
5128 }
5129 if iNdEx >= l {
5130 return io.ErrUnexpectedEOF
5131 }
5132 b := dAtA[iNdEx]
5133 iNdEx++
5134 stringLenmapvalue |= uint64(b&0x7F) << shift
5135 if b < 0x80 {
5136 break
5137 }
5138 }
5139 intStringLenmapvalue := int(stringLenmapvalue)
5140 if intStringLenmapvalue < 0 {
5141 return ErrInvalidLengthGenerated
5142 }
5143 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
5144 if postStringIndexmapvalue < 0 {
5145 return ErrInvalidLengthGenerated
5146 }
5147 if postStringIndexmapvalue > l {
5148 return io.ErrUnexpectedEOF
5149 }
5150 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
5151 iNdEx = postStringIndexmapvalue
5152 } else {
5153 iNdEx = entryPreIndex
5154 skippy, err := skipGenerated(dAtA[iNdEx:])
5155 if err != nil {
5156 return err
5157 }
5158 if (skippy < 0) || (iNdEx+skippy) < 0 {
5159 return ErrInvalidLengthGenerated
5160 }
5161 if (iNdEx + skippy) > postIndex {
5162 return io.ErrUnexpectedEOF
5163 }
5164 iNdEx += skippy
5165 }
5166 }
5167 m.Selector[mapkey] = mapvalue
5168 iNdEx = postIndex
5169 case 3:
5170 if wireType != 2 {
5171 return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
5172 }
5173 var stringLen uint64
5174 for shift := uint(0); ; shift += 7 {
5175 if shift >= 64 {
5176 return ErrIntOverflowGenerated
5177 }
5178 if iNdEx >= l {
5179 return io.ErrUnexpectedEOF
5180 }
5181 b := dAtA[iNdEx]
5182 iNdEx++
5183 stringLen |= uint64(b&0x7F) << shift
5184 if b < 0x80 {
5185 break
5186 }
5187 }
5188 intStringLen := int(stringLen)
5189 if intStringLen < 0 {
5190 return ErrInvalidLengthGenerated
5191 }
5192 postIndex := iNdEx + intStringLen
5193 if postIndex < 0 {
5194 return ErrInvalidLengthGenerated
5195 }
5196 if postIndex > l {
5197 return io.ErrUnexpectedEOF
5198 }
5199 m.TargetSelector = string(dAtA[iNdEx:postIndex])
5200 iNdEx = postIndex
5201 default:
5202 iNdEx = preIndex
5203 skippy, err := skipGenerated(dAtA[iNdEx:])
5204 if err != nil {
5205 return err
5206 }
5207 if (skippy < 0) || (iNdEx+skippy) < 0 {
5208 return ErrInvalidLengthGenerated
5209 }
5210 if (iNdEx + skippy) > l {
5211 return io.ErrUnexpectedEOF
5212 }
5213 iNdEx += skippy
5214 }
5215 }
5216
5217 if iNdEx > l {
5218 return io.ErrUnexpectedEOF
5219 }
5220 return nil
5221 }
5222 func (m *StatefulSet) Unmarshal(dAtA []byte) error {
5223 l := len(dAtA)
5224 iNdEx := 0
5225 for iNdEx < l {
5226 preIndex := iNdEx
5227 var wire uint64
5228 for shift := uint(0); ; shift += 7 {
5229 if shift >= 64 {
5230 return ErrIntOverflowGenerated
5231 }
5232 if iNdEx >= l {
5233 return io.ErrUnexpectedEOF
5234 }
5235 b := dAtA[iNdEx]
5236 iNdEx++
5237 wire |= uint64(b&0x7F) << shift
5238 if b < 0x80 {
5239 break
5240 }
5241 }
5242 fieldNum := int32(wire >> 3)
5243 wireType := int(wire & 0x7)
5244 if wireType == 4 {
5245 return fmt.Errorf("proto: StatefulSet: wiretype end group for non-group")
5246 }
5247 if fieldNum <= 0 {
5248 return fmt.Errorf("proto: StatefulSet: illegal tag %d (wire type %d)", fieldNum, wire)
5249 }
5250 switch fieldNum {
5251 case 1:
5252 if wireType != 2 {
5253 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
5254 }
5255 var msglen int
5256 for shift := uint(0); ; shift += 7 {
5257 if shift >= 64 {
5258 return ErrIntOverflowGenerated
5259 }
5260 if iNdEx >= l {
5261 return io.ErrUnexpectedEOF
5262 }
5263 b := dAtA[iNdEx]
5264 iNdEx++
5265 msglen |= int(b&0x7F) << shift
5266 if b < 0x80 {
5267 break
5268 }
5269 }
5270 if msglen < 0 {
5271 return ErrInvalidLengthGenerated
5272 }
5273 postIndex := iNdEx + msglen
5274 if postIndex < 0 {
5275 return ErrInvalidLengthGenerated
5276 }
5277 if postIndex > l {
5278 return io.ErrUnexpectedEOF
5279 }
5280 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5281 return err
5282 }
5283 iNdEx = postIndex
5284 case 2:
5285 if wireType != 2 {
5286 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
5287 }
5288 var msglen int
5289 for shift := uint(0); ; shift += 7 {
5290 if shift >= 64 {
5291 return ErrIntOverflowGenerated
5292 }
5293 if iNdEx >= l {
5294 return io.ErrUnexpectedEOF
5295 }
5296 b := dAtA[iNdEx]
5297 iNdEx++
5298 msglen |= int(b&0x7F) << shift
5299 if b < 0x80 {
5300 break
5301 }
5302 }
5303 if msglen < 0 {
5304 return ErrInvalidLengthGenerated
5305 }
5306 postIndex := iNdEx + msglen
5307 if postIndex < 0 {
5308 return ErrInvalidLengthGenerated
5309 }
5310 if postIndex > l {
5311 return io.ErrUnexpectedEOF
5312 }
5313 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5314 return err
5315 }
5316 iNdEx = postIndex
5317 case 3:
5318 if wireType != 2 {
5319 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5320 }
5321 var msglen int
5322 for shift := uint(0); ; shift += 7 {
5323 if shift >= 64 {
5324 return ErrIntOverflowGenerated
5325 }
5326 if iNdEx >= l {
5327 return io.ErrUnexpectedEOF
5328 }
5329 b := dAtA[iNdEx]
5330 iNdEx++
5331 msglen |= int(b&0x7F) << shift
5332 if b < 0x80 {
5333 break
5334 }
5335 }
5336 if msglen < 0 {
5337 return ErrInvalidLengthGenerated
5338 }
5339 postIndex := iNdEx + msglen
5340 if postIndex < 0 {
5341 return ErrInvalidLengthGenerated
5342 }
5343 if postIndex > l {
5344 return io.ErrUnexpectedEOF
5345 }
5346 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5347 return err
5348 }
5349 iNdEx = postIndex
5350 default:
5351 iNdEx = preIndex
5352 skippy, err := skipGenerated(dAtA[iNdEx:])
5353 if err != nil {
5354 return err
5355 }
5356 if (skippy < 0) || (iNdEx+skippy) < 0 {
5357 return ErrInvalidLengthGenerated
5358 }
5359 if (iNdEx + skippy) > l {
5360 return io.ErrUnexpectedEOF
5361 }
5362 iNdEx += skippy
5363 }
5364 }
5365
5366 if iNdEx > l {
5367 return io.ErrUnexpectedEOF
5368 }
5369 return nil
5370 }
5371 func (m *StatefulSetCondition) Unmarshal(dAtA []byte) error {
5372 l := len(dAtA)
5373 iNdEx := 0
5374 for iNdEx < l {
5375 preIndex := iNdEx
5376 var wire uint64
5377 for shift := uint(0); ; shift += 7 {
5378 if shift >= 64 {
5379 return ErrIntOverflowGenerated
5380 }
5381 if iNdEx >= l {
5382 return io.ErrUnexpectedEOF
5383 }
5384 b := dAtA[iNdEx]
5385 iNdEx++
5386 wire |= uint64(b&0x7F) << shift
5387 if b < 0x80 {
5388 break
5389 }
5390 }
5391 fieldNum := int32(wire >> 3)
5392 wireType := int(wire & 0x7)
5393 if wireType == 4 {
5394 return fmt.Errorf("proto: StatefulSetCondition: wiretype end group for non-group")
5395 }
5396 if fieldNum <= 0 {
5397 return fmt.Errorf("proto: StatefulSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
5398 }
5399 switch fieldNum {
5400 case 1:
5401 if wireType != 2 {
5402 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
5403 }
5404 var stringLen uint64
5405 for shift := uint(0); ; shift += 7 {
5406 if shift >= 64 {
5407 return ErrIntOverflowGenerated
5408 }
5409 if iNdEx >= l {
5410 return io.ErrUnexpectedEOF
5411 }
5412 b := dAtA[iNdEx]
5413 iNdEx++
5414 stringLen |= uint64(b&0x7F) << shift
5415 if b < 0x80 {
5416 break
5417 }
5418 }
5419 intStringLen := int(stringLen)
5420 if intStringLen < 0 {
5421 return ErrInvalidLengthGenerated
5422 }
5423 postIndex := iNdEx + intStringLen
5424 if postIndex < 0 {
5425 return ErrInvalidLengthGenerated
5426 }
5427 if postIndex > l {
5428 return io.ErrUnexpectedEOF
5429 }
5430 m.Type = StatefulSetConditionType(dAtA[iNdEx:postIndex])
5431 iNdEx = postIndex
5432 case 2:
5433 if wireType != 2 {
5434 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
5435 }
5436 var stringLen uint64
5437 for shift := uint(0); ; shift += 7 {
5438 if shift >= 64 {
5439 return ErrIntOverflowGenerated
5440 }
5441 if iNdEx >= l {
5442 return io.ErrUnexpectedEOF
5443 }
5444 b := dAtA[iNdEx]
5445 iNdEx++
5446 stringLen |= uint64(b&0x7F) << shift
5447 if b < 0x80 {
5448 break
5449 }
5450 }
5451 intStringLen := int(stringLen)
5452 if intStringLen < 0 {
5453 return ErrInvalidLengthGenerated
5454 }
5455 postIndex := iNdEx + intStringLen
5456 if postIndex < 0 {
5457 return ErrInvalidLengthGenerated
5458 }
5459 if postIndex > l {
5460 return io.ErrUnexpectedEOF
5461 }
5462 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
5463 iNdEx = postIndex
5464 case 3:
5465 if wireType != 2 {
5466 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
5467 }
5468 var msglen int
5469 for shift := uint(0); ; shift += 7 {
5470 if shift >= 64 {
5471 return ErrIntOverflowGenerated
5472 }
5473 if iNdEx >= l {
5474 return io.ErrUnexpectedEOF
5475 }
5476 b := dAtA[iNdEx]
5477 iNdEx++
5478 msglen |= int(b&0x7F) << shift
5479 if b < 0x80 {
5480 break
5481 }
5482 }
5483 if msglen < 0 {
5484 return ErrInvalidLengthGenerated
5485 }
5486 postIndex := iNdEx + msglen
5487 if postIndex < 0 {
5488 return ErrInvalidLengthGenerated
5489 }
5490 if postIndex > l {
5491 return io.ErrUnexpectedEOF
5492 }
5493 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5494 return err
5495 }
5496 iNdEx = postIndex
5497 case 4:
5498 if wireType != 2 {
5499 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
5500 }
5501 var stringLen 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 stringLen |= uint64(b&0x7F) << shift
5512 if b < 0x80 {
5513 break
5514 }
5515 }
5516 intStringLen := int(stringLen)
5517 if intStringLen < 0 {
5518 return ErrInvalidLengthGenerated
5519 }
5520 postIndex := iNdEx + intStringLen
5521 if postIndex < 0 {
5522 return ErrInvalidLengthGenerated
5523 }
5524 if postIndex > l {
5525 return io.ErrUnexpectedEOF
5526 }
5527 m.Reason = string(dAtA[iNdEx:postIndex])
5528 iNdEx = postIndex
5529 case 5:
5530 if wireType != 2 {
5531 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5532 }
5533 var stringLen uint64
5534 for shift := uint(0); ; shift += 7 {
5535 if shift >= 64 {
5536 return ErrIntOverflowGenerated
5537 }
5538 if iNdEx >= l {
5539 return io.ErrUnexpectedEOF
5540 }
5541 b := dAtA[iNdEx]
5542 iNdEx++
5543 stringLen |= uint64(b&0x7F) << shift
5544 if b < 0x80 {
5545 break
5546 }
5547 }
5548 intStringLen := int(stringLen)
5549 if intStringLen < 0 {
5550 return ErrInvalidLengthGenerated
5551 }
5552 postIndex := iNdEx + intStringLen
5553 if postIndex < 0 {
5554 return ErrInvalidLengthGenerated
5555 }
5556 if postIndex > l {
5557 return io.ErrUnexpectedEOF
5558 }
5559 m.Message = string(dAtA[iNdEx:postIndex])
5560 iNdEx = postIndex
5561 default:
5562 iNdEx = preIndex
5563 skippy, err := skipGenerated(dAtA[iNdEx:])
5564 if err != nil {
5565 return err
5566 }
5567 if (skippy < 0) || (iNdEx+skippy) < 0 {
5568 return ErrInvalidLengthGenerated
5569 }
5570 if (iNdEx + skippy) > l {
5571 return io.ErrUnexpectedEOF
5572 }
5573 iNdEx += skippy
5574 }
5575 }
5576
5577 if iNdEx > l {
5578 return io.ErrUnexpectedEOF
5579 }
5580 return nil
5581 }
5582 func (m *StatefulSetList) Unmarshal(dAtA []byte) error {
5583 l := len(dAtA)
5584 iNdEx := 0
5585 for iNdEx < l {
5586 preIndex := iNdEx
5587 var wire uint64
5588 for shift := uint(0); ; shift += 7 {
5589 if shift >= 64 {
5590 return ErrIntOverflowGenerated
5591 }
5592 if iNdEx >= l {
5593 return io.ErrUnexpectedEOF
5594 }
5595 b := dAtA[iNdEx]
5596 iNdEx++
5597 wire |= uint64(b&0x7F) << shift
5598 if b < 0x80 {
5599 break
5600 }
5601 }
5602 fieldNum := int32(wire >> 3)
5603 wireType := int(wire & 0x7)
5604 if wireType == 4 {
5605 return fmt.Errorf("proto: StatefulSetList: wiretype end group for non-group")
5606 }
5607 if fieldNum <= 0 {
5608 return fmt.Errorf("proto: StatefulSetList: illegal tag %d (wire type %d)", fieldNum, wire)
5609 }
5610 switch fieldNum {
5611 case 1:
5612 if wireType != 2 {
5613 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5614 }
5615 var msglen int
5616 for shift := uint(0); ; shift += 7 {
5617 if shift >= 64 {
5618 return ErrIntOverflowGenerated
5619 }
5620 if iNdEx >= l {
5621 return io.ErrUnexpectedEOF
5622 }
5623 b := dAtA[iNdEx]
5624 iNdEx++
5625 msglen |= int(b&0x7F) << shift
5626 if b < 0x80 {
5627 break
5628 }
5629 }
5630 if msglen < 0 {
5631 return ErrInvalidLengthGenerated
5632 }
5633 postIndex := iNdEx + msglen
5634 if postIndex < 0 {
5635 return ErrInvalidLengthGenerated
5636 }
5637 if postIndex > l {
5638 return io.ErrUnexpectedEOF
5639 }
5640 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5641 return err
5642 }
5643 iNdEx = postIndex
5644 case 2:
5645 if wireType != 2 {
5646 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5647 }
5648 var msglen int
5649 for shift := uint(0); ; shift += 7 {
5650 if shift >= 64 {
5651 return ErrIntOverflowGenerated
5652 }
5653 if iNdEx >= l {
5654 return io.ErrUnexpectedEOF
5655 }
5656 b := dAtA[iNdEx]
5657 iNdEx++
5658 msglen |= int(b&0x7F) << shift
5659 if b < 0x80 {
5660 break
5661 }
5662 }
5663 if msglen < 0 {
5664 return ErrInvalidLengthGenerated
5665 }
5666 postIndex := iNdEx + msglen
5667 if postIndex < 0 {
5668 return ErrInvalidLengthGenerated
5669 }
5670 if postIndex > l {
5671 return io.ErrUnexpectedEOF
5672 }
5673 m.Items = append(m.Items, StatefulSet{})
5674 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5675 return err
5676 }
5677 iNdEx = postIndex
5678 default:
5679 iNdEx = preIndex
5680 skippy, err := skipGenerated(dAtA[iNdEx:])
5681 if err != nil {
5682 return err
5683 }
5684 if (skippy < 0) || (iNdEx+skippy) < 0 {
5685 return ErrInvalidLengthGenerated
5686 }
5687 if (iNdEx + skippy) > l {
5688 return io.ErrUnexpectedEOF
5689 }
5690 iNdEx += skippy
5691 }
5692 }
5693
5694 if iNdEx > l {
5695 return io.ErrUnexpectedEOF
5696 }
5697 return nil
5698 }
5699 func (m *StatefulSetOrdinals) Unmarshal(dAtA []byte) error {
5700 l := len(dAtA)
5701 iNdEx := 0
5702 for iNdEx < l {
5703 preIndex := iNdEx
5704 var wire uint64
5705 for shift := uint(0); ; shift += 7 {
5706 if shift >= 64 {
5707 return ErrIntOverflowGenerated
5708 }
5709 if iNdEx >= l {
5710 return io.ErrUnexpectedEOF
5711 }
5712 b := dAtA[iNdEx]
5713 iNdEx++
5714 wire |= uint64(b&0x7F) << shift
5715 if b < 0x80 {
5716 break
5717 }
5718 }
5719 fieldNum := int32(wire >> 3)
5720 wireType := int(wire & 0x7)
5721 if wireType == 4 {
5722 return fmt.Errorf("proto: StatefulSetOrdinals: wiretype end group for non-group")
5723 }
5724 if fieldNum <= 0 {
5725 return fmt.Errorf("proto: StatefulSetOrdinals: illegal tag %d (wire type %d)", fieldNum, wire)
5726 }
5727 switch fieldNum {
5728 case 1:
5729 if wireType != 0 {
5730 return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
5731 }
5732 m.Start = 0
5733 for shift := uint(0); ; shift += 7 {
5734 if shift >= 64 {
5735 return ErrIntOverflowGenerated
5736 }
5737 if iNdEx >= l {
5738 return io.ErrUnexpectedEOF
5739 }
5740 b := dAtA[iNdEx]
5741 iNdEx++
5742 m.Start |= int32(b&0x7F) << shift
5743 if b < 0x80 {
5744 break
5745 }
5746 }
5747 default:
5748 iNdEx = preIndex
5749 skippy, err := skipGenerated(dAtA[iNdEx:])
5750 if err != nil {
5751 return err
5752 }
5753 if (skippy < 0) || (iNdEx+skippy) < 0 {
5754 return ErrInvalidLengthGenerated
5755 }
5756 if (iNdEx + skippy) > l {
5757 return io.ErrUnexpectedEOF
5758 }
5759 iNdEx += skippy
5760 }
5761 }
5762
5763 if iNdEx > l {
5764 return io.ErrUnexpectedEOF
5765 }
5766 return nil
5767 }
5768 func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Unmarshal(dAtA []byte) error {
5769 l := len(dAtA)
5770 iNdEx := 0
5771 for iNdEx < l {
5772 preIndex := iNdEx
5773 var wire uint64
5774 for shift := uint(0); ; shift += 7 {
5775 if shift >= 64 {
5776 return ErrIntOverflowGenerated
5777 }
5778 if iNdEx >= l {
5779 return io.ErrUnexpectedEOF
5780 }
5781 b := dAtA[iNdEx]
5782 iNdEx++
5783 wire |= uint64(b&0x7F) << shift
5784 if b < 0x80 {
5785 break
5786 }
5787 }
5788 fieldNum := int32(wire >> 3)
5789 wireType := int(wire & 0x7)
5790 if wireType == 4 {
5791 return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: wiretype end group for non-group")
5792 }
5793 if fieldNum <= 0 {
5794 return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
5795 }
5796 switch fieldNum {
5797 case 1:
5798 if wireType != 2 {
5799 return fmt.Errorf("proto: wrong wireType = %d for field WhenDeleted", wireType)
5800 }
5801 var stringLen uint64
5802 for shift := uint(0); ; shift += 7 {
5803 if shift >= 64 {
5804 return ErrIntOverflowGenerated
5805 }
5806 if iNdEx >= l {
5807 return io.ErrUnexpectedEOF
5808 }
5809 b := dAtA[iNdEx]
5810 iNdEx++
5811 stringLen |= uint64(b&0x7F) << shift
5812 if b < 0x80 {
5813 break
5814 }
5815 }
5816 intStringLen := int(stringLen)
5817 if intStringLen < 0 {
5818 return ErrInvalidLengthGenerated
5819 }
5820 postIndex := iNdEx + intStringLen
5821 if postIndex < 0 {
5822 return ErrInvalidLengthGenerated
5823 }
5824 if postIndex > l {
5825 return io.ErrUnexpectedEOF
5826 }
5827 m.WhenDeleted = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex])
5828 iNdEx = postIndex
5829 case 2:
5830 if wireType != 2 {
5831 return fmt.Errorf("proto: wrong wireType = %d for field WhenScaled", wireType)
5832 }
5833 var stringLen uint64
5834 for shift := uint(0); ; shift += 7 {
5835 if shift >= 64 {
5836 return ErrIntOverflowGenerated
5837 }
5838 if iNdEx >= l {
5839 return io.ErrUnexpectedEOF
5840 }
5841 b := dAtA[iNdEx]
5842 iNdEx++
5843 stringLen |= uint64(b&0x7F) << shift
5844 if b < 0x80 {
5845 break
5846 }
5847 }
5848 intStringLen := int(stringLen)
5849 if intStringLen < 0 {
5850 return ErrInvalidLengthGenerated
5851 }
5852 postIndex := iNdEx + intStringLen
5853 if postIndex < 0 {
5854 return ErrInvalidLengthGenerated
5855 }
5856 if postIndex > l {
5857 return io.ErrUnexpectedEOF
5858 }
5859 m.WhenScaled = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex])
5860 iNdEx = postIndex
5861 default:
5862 iNdEx = preIndex
5863 skippy, err := skipGenerated(dAtA[iNdEx:])
5864 if err != nil {
5865 return err
5866 }
5867 if (skippy < 0) || (iNdEx+skippy) < 0 {
5868 return ErrInvalidLengthGenerated
5869 }
5870 if (iNdEx + skippy) > l {
5871 return io.ErrUnexpectedEOF
5872 }
5873 iNdEx += skippy
5874 }
5875 }
5876
5877 if iNdEx > l {
5878 return io.ErrUnexpectedEOF
5879 }
5880 return nil
5881 }
5882 func (m *StatefulSetSpec) Unmarshal(dAtA []byte) error {
5883 l := len(dAtA)
5884 iNdEx := 0
5885 for iNdEx < l {
5886 preIndex := iNdEx
5887 var wire uint64
5888 for shift := uint(0); ; shift += 7 {
5889 if shift >= 64 {
5890 return ErrIntOverflowGenerated
5891 }
5892 if iNdEx >= l {
5893 return io.ErrUnexpectedEOF
5894 }
5895 b := dAtA[iNdEx]
5896 iNdEx++
5897 wire |= uint64(b&0x7F) << shift
5898 if b < 0x80 {
5899 break
5900 }
5901 }
5902 fieldNum := int32(wire >> 3)
5903 wireType := int(wire & 0x7)
5904 if wireType == 4 {
5905 return fmt.Errorf("proto: StatefulSetSpec: wiretype end group for non-group")
5906 }
5907 if fieldNum <= 0 {
5908 return fmt.Errorf("proto: StatefulSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
5909 }
5910 switch fieldNum {
5911 case 1:
5912 if wireType != 0 {
5913 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
5914 }
5915 var v int32
5916 for shift := uint(0); ; shift += 7 {
5917 if shift >= 64 {
5918 return ErrIntOverflowGenerated
5919 }
5920 if iNdEx >= l {
5921 return io.ErrUnexpectedEOF
5922 }
5923 b := dAtA[iNdEx]
5924 iNdEx++
5925 v |= int32(b&0x7F) << shift
5926 if b < 0x80 {
5927 break
5928 }
5929 }
5930 m.Replicas = &v
5931 case 2:
5932 if wireType != 2 {
5933 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
5934 }
5935 var msglen int
5936 for shift := uint(0); ; shift += 7 {
5937 if shift >= 64 {
5938 return ErrIntOverflowGenerated
5939 }
5940 if iNdEx >= l {
5941 return io.ErrUnexpectedEOF
5942 }
5943 b := dAtA[iNdEx]
5944 iNdEx++
5945 msglen |= int(b&0x7F) << shift
5946 if b < 0x80 {
5947 break
5948 }
5949 }
5950 if msglen < 0 {
5951 return ErrInvalidLengthGenerated
5952 }
5953 postIndex := iNdEx + msglen
5954 if postIndex < 0 {
5955 return ErrInvalidLengthGenerated
5956 }
5957 if postIndex > l {
5958 return io.ErrUnexpectedEOF
5959 }
5960 if m.Selector == nil {
5961 m.Selector = &v1.LabelSelector{}
5962 }
5963 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5964 return err
5965 }
5966 iNdEx = postIndex
5967 case 3:
5968 if wireType != 2 {
5969 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
5970 }
5971 var msglen int
5972 for shift := uint(0); ; shift += 7 {
5973 if shift >= 64 {
5974 return ErrIntOverflowGenerated
5975 }
5976 if iNdEx >= l {
5977 return io.ErrUnexpectedEOF
5978 }
5979 b := dAtA[iNdEx]
5980 iNdEx++
5981 msglen |= int(b&0x7F) << shift
5982 if b < 0x80 {
5983 break
5984 }
5985 }
5986 if msglen < 0 {
5987 return ErrInvalidLengthGenerated
5988 }
5989 postIndex := iNdEx + msglen
5990 if postIndex < 0 {
5991 return ErrInvalidLengthGenerated
5992 }
5993 if postIndex > l {
5994 return io.ErrUnexpectedEOF
5995 }
5996 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5997 return err
5998 }
5999 iNdEx = postIndex
6000 case 4:
6001 if wireType != 2 {
6002 return fmt.Errorf("proto: wrong wireType = %d for field VolumeClaimTemplates", wireType)
6003 }
6004 var msglen int
6005 for shift := uint(0); ; shift += 7 {
6006 if shift >= 64 {
6007 return ErrIntOverflowGenerated
6008 }
6009 if iNdEx >= l {
6010 return io.ErrUnexpectedEOF
6011 }
6012 b := dAtA[iNdEx]
6013 iNdEx++
6014 msglen |= int(b&0x7F) << shift
6015 if b < 0x80 {
6016 break
6017 }
6018 }
6019 if msglen < 0 {
6020 return ErrInvalidLengthGenerated
6021 }
6022 postIndex := iNdEx + msglen
6023 if postIndex < 0 {
6024 return ErrInvalidLengthGenerated
6025 }
6026 if postIndex > l {
6027 return io.ErrUnexpectedEOF
6028 }
6029 m.VolumeClaimTemplates = append(m.VolumeClaimTemplates, v11.PersistentVolumeClaim{})
6030 if err := m.VolumeClaimTemplates[len(m.VolumeClaimTemplates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6031 return err
6032 }
6033 iNdEx = postIndex
6034 case 5:
6035 if wireType != 2 {
6036 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
6037 }
6038 var stringLen uint64
6039 for shift := uint(0); ; shift += 7 {
6040 if shift >= 64 {
6041 return ErrIntOverflowGenerated
6042 }
6043 if iNdEx >= l {
6044 return io.ErrUnexpectedEOF
6045 }
6046 b := dAtA[iNdEx]
6047 iNdEx++
6048 stringLen |= uint64(b&0x7F) << shift
6049 if b < 0x80 {
6050 break
6051 }
6052 }
6053 intStringLen := int(stringLen)
6054 if intStringLen < 0 {
6055 return ErrInvalidLengthGenerated
6056 }
6057 postIndex := iNdEx + intStringLen
6058 if postIndex < 0 {
6059 return ErrInvalidLengthGenerated
6060 }
6061 if postIndex > l {
6062 return io.ErrUnexpectedEOF
6063 }
6064 m.ServiceName = string(dAtA[iNdEx:postIndex])
6065 iNdEx = postIndex
6066 case 6:
6067 if wireType != 2 {
6068 return fmt.Errorf("proto: wrong wireType = %d for field PodManagementPolicy", wireType)
6069 }
6070 var stringLen uint64
6071 for shift := uint(0); ; shift += 7 {
6072 if shift >= 64 {
6073 return ErrIntOverflowGenerated
6074 }
6075 if iNdEx >= l {
6076 return io.ErrUnexpectedEOF
6077 }
6078 b := dAtA[iNdEx]
6079 iNdEx++
6080 stringLen |= uint64(b&0x7F) << shift
6081 if b < 0x80 {
6082 break
6083 }
6084 }
6085 intStringLen := int(stringLen)
6086 if intStringLen < 0 {
6087 return ErrInvalidLengthGenerated
6088 }
6089 postIndex := iNdEx + intStringLen
6090 if postIndex < 0 {
6091 return ErrInvalidLengthGenerated
6092 }
6093 if postIndex > l {
6094 return io.ErrUnexpectedEOF
6095 }
6096 m.PodManagementPolicy = PodManagementPolicyType(dAtA[iNdEx:postIndex])
6097 iNdEx = postIndex
6098 case 7:
6099 if wireType != 2 {
6100 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
6101 }
6102 var msglen int
6103 for shift := uint(0); ; shift += 7 {
6104 if shift >= 64 {
6105 return ErrIntOverflowGenerated
6106 }
6107 if iNdEx >= l {
6108 return io.ErrUnexpectedEOF
6109 }
6110 b := dAtA[iNdEx]
6111 iNdEx++
6112 msglen |= int(b&0x7F) << shift
6113 if b < 0x80 {
6114 break
6115 }
6116 }
6117 if msglen < 0 {
6118 return ErrInvalidLengthGenerated
6119 }
6120 postIndex := iNdEx + msglen
6121 if postIndex < 0 {
6122 return ErrInvalidLengthGenerated
6123 }
6124 if postIndex > l {
6125 return io.ErrUnexpectedEOF
6126 }
6127 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6128 return err
6129 }
6130 iNdEx = postIndex
6131 case 8:
6132 if wireType != 0 {
6133 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
6134 }
6135 var v int32
6136 for shift := uint(0); ; shift += 7 {
6137 if shift >= 64 {
6138 return ErrIntOverflowGenerated
6139 }
6140 if iNdEx >= l {
6141 return io.ErrUnexpectedEOF
6142 }
6143 b := dAtA[iNdEx]
6144 iNdEx++
6145 v |= int32(b&0x7F) << shift
6146 if b < 0x80 {
6147 break
6148 }
6149 }
6150 m.RevisionHistoryLimit = &v
6151 case 9:
6152 if wireType != 0 {
6153 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
6154 }
6155 m.MinReadySeconds = 0
6156 for shift := uint(0); ; shift += 7 {
6157 if shift >= 64 {
6158 return ErrIntOverflowGenerated
6159 }
6160 if iNdEx >= l {
6161 return io.ErrUnexpectedEOF
6162 }
6163 b := dAtA[iNdEx]
6164 iNdEx++
6165 m.MinReadySeconds |= int32(b&0x7F) << shift
6166 if b < 0x80 {
6167 break
6168 }
6169 }
6170 case 10:
6171 if wireType != 2 {
6172 return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaimRetentionPolicy", wireType)
6173 }
6174 var msglen int
6175 for shift := uint(0); ; shift += 7 {
6176 if shift >= 64 {
6177 return ErrIntOverflowGenerated
6178 }
6179 if iNdEx >= l {
6180 return io.ErrUnexpectedEOF
6181 }
6182 b := dAtA[iNdEx]
6183 iNdEx++
6184 msglen |= int(b&0x7F) << shift
6185 if b < 0x80 {
6186 break
6187 }
6188 }
6189 if msglen < 0 {
6190 return ErrInvalidLengthGenerated
6191 }
6192 postIndex := iNdEx + msglen
6193 if postIndex < 0 {
6194 return ErrInvalidLengthGenerated
6195 }
6196 if postIndex > l {
6197 return io.ErrUnexpectedEOF
6198 }
6199 if m.PersistentVolumeClaimRetentionPolicy == nil {
6200 m.PersistentVolumeClaimRetentionPolicy = &StatefulSetPersistentVolumeClaimRetentionPolicy{}
6201 }
6202 if err := m.PersistentVolumeClaimRetentionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6203 return err
6204 }
6205 iNdEx = postIndex
6206 case 11:
6207 if wireType != 2 {
6208 return fmt.Errorf("proto: wrong wireType = %d for field Ordinals", wireType)
6209 }
6210 var msglen int
6211 for shift := uint(0); ; shift += 7 {
6212 if shift >= 64 {
6213 return ErrIntOverflowGenerated
6214 }
6215 if iNdEx >= l {
6216 return io.ErrUnexpectedEOF
6217 }
6218 b := dAtA[iNdEx]
6219 iNdEx++
6220 msglen |= int(b&0x7F) << shift
6221 if b < 0x80 {
6222 break
6223 }
6224 }
6225 if msglen < 0 {
6226 return ErrInvalidLengthGenerated
6227 }
6228 postIndex := iNdEx + msglen
6229 if postIndex < 0 {
6230 return ErrInvalidLengthGenerated
6231 }
6232 if postIndex > l {
6233 return io.ErrUnexpectedEOF
6234 }
6235 if m.Ordinals == nil {
6236 m.Ordinals = &StatefulSetOrdinals{}
6237 }
6238 if err := m.Ordinals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6239 return err
6240 }
6241 iNdEx = postIndex
6242 default:
6243 iNdEx = preIndex
6244 skippy, err := skipGenerated(dAtA[iNdEx:])
6245 if err != nil {
6246 return err
6247 }
6248 if (skippy < 0) || (iNdEx+skippy) < 0 {
6249 return ErrInvalidLengthGenerated
6250 }
6251 if (iNdEx + skippy) > l {
6252 return io.ErrUnexpectedEOF
6253 }
6254 iNdEx += skippy
6255 }
6256 }
6257
6258 if iNdEx > l {
6259 return io.ErrUnexpectedEOF
6260 }
6261 return nil
6262 }
6263 func (m *StatefulSetStatus) Unmarshal(dAtA []byte) error {
6264 l := len(dAtA)
6265 iNdEx := 0
6266 for iNdEx < l {
6267 preIndex := iNdEx
6268 var wire uint64
6269 for shift := uint(0); ; shift += 7 {
6270 if shift >= 64 {
6271 return ErrIntOverflowGenerated
6272 }
6273 if iNdEx >= l {
6274 return io.ErrUnexpectedEOF
6275 }
6276 b := dAtA[iNdEx]
6277 iNdEx++
6278 wire |= uint64(b&0x7F) << shift
6279 if b < 0x80 {
6280 break
6281 }
6282 }
6283 fieldNum := int32(wire >> 3)
6284 wireType := int(wire & 0x7)
6285 if wireType == 4 {
6286 return fmt.Errorf("proto: StatefulSetStatus: wiretype end group for non-group")
6287 }
6288 if fieldNum <= 0 {
6289 return fmt.Errorf("proto: StatefulSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
6290 }
6291 switch fieldNum {
6292 case 1:
6293 if wireType != 0 {
6294 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
6295 }
6296 var v int64
6297 for shift := uint(0); ; shift += 7 {
6298 if shift >= 64 {
6299 return ErrIntOverflowGenerated
6300 }
6301 if iNdEx >= l {
6302 return io.ErrUnexpectedEOF
6303 }
6304 b := dAtA[iNdEx]
6305 iNdEx++
6306 v |= int64(b&0x7F) << shift
6307 if b < 0x80 {
6308 break
6309 }
6310 }
6311 m.ObservedGeneration = &v
6312 case 2:
6313 if wireType != 0 {
6314 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
6315 }
6316 m.Replicas = 0
6317 for shift := uint(0); ; shift += 7 {
6318 if shift >= 64 {
6319 return ErrIntOverflowGenerated
6320 }
6321 if iNdEx >= l {
6322 return io.ErrUnexpectedEOF
6323 }
6324 b := dAtA[iNdEx]
6325 iNdEx++
6326 m.Replicas |= int32(b&0x7F) << shift
6327 if b < 0x80 {
6328 break
6329 }
6330 }
6331 case 3:
6332 if wireType != 0 {
6333 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
6334 }
6335 m.ReadyReplicas = 0
6336 for shift := uint(0); ; shift += 7 {
6337 if shift >= 64 {
6338 return ErrIntOverflowGenerated
6339 }
6340 if iNdEx >= l {
6341 return io.ErrUnexpectedEOF
6342 }
6343 b := dAtA[iNdEx]
6344 iNdEx++
6345 m.ReadyReplicas |= int32(b&0x7F) << shift
6346 if b < 0x80 {
6347 break
6348 }
6349 }
6350 case 4:
6351 if wireType != 0 {
6352 return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
6353 }
6354 m.CurrentReplicas = 0
6355 for shift := uint(0); ; shift += 7 {
6356 if shift >= 64 {
6357 return ErrIntOverflowGenerated
6358 }
6359 if iNdEx >= l {
6360 return io.ErrUnexpectedEOF
6361 }
6362 b := dAtA[iNdEx]
6363 iNdEx++
6364 m.CurrentReplicas |= int32(b&0x7F) << shift
6365 if b < 0x80 {
6366 break
6367 }
6368 }
6369 case 5:
6370 if wireType != 0 {
6371 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
6372 }
6373 m.UpdatedReplicas = 0
6374 for shift := uint(0); ; shift += 7 {
6375 if shift >= 64 {
6376 return ErrIntOverflowGenerated
6377 }
6378 if iNdEx >= l {
6379 return io.ErrUnexpectedEOF
6380 }
6381 b := dAtA[iNdEx]
6382 iNdEx++
6383 m.UpdatedReplicas |= int32(b&0x7F) << shift
6384 if b < 0x80 {
6385 break
6386 }
6387 }
6388 case 6:
6389 if wireType != 2 {
6390 return fmt.Errorf("proto: wrong wireType = %d for field CurrentRevision", wireType)
6391 }
6392 var stringLen uint64
6393 for shift := uint(0); ; shift += 7 {
6394 if shift >= 64 {
6395 return ErrIntOverflowGenerated
6396 }
6397 if iNdEx >= l {
6398 return io.ErrUnexpectedEOF
6399 }
6400 b := dAtA[iNdEx]
6401 iNdEx++
6402 stringLen |= uint64(b&0x7F) << shift
6403 if b < 0x80 {
6404 break
6405 }
6406 }
6407 intStringLen := int(stringLen)
6408 if intStringLen < 0 {
6409 return ErrInvalidLengthGenerated
6410 }
6411 postIndex := iNdEx + intStringLen
6412 if postIndex < 0 {
6413 return ErrInvalidLengthGenerated
6414 }
6415 if postIndex > l {
6416 return io.ErrUnexpectedEOF
6417 }
6418 m.CurrentRevision = string(dAtA[iNdEx:postIndex])
6419 iNdEx = postIndex
6420 case 7:
6421 if wireType != 2 {
6422 return fmt.Errorf("proto: wrong wireType = %d for field UpdateRevision", wireType)
6423 }
6424 var stringLen uint64
6425 for shift := uint(0); ; shift += 7 {
6426 if shift >= 64 {
6427 return ErrIntOverflowGenerated
6428 }
6429 if iNdEx >= l {
6430 return io.ErrUnexpectedEOF
6431 }
6432 b := dAtA[iNdEx]
6433 iNdEx++
6434 stringLen |= uint64(b&0x7F) << shift
6435 if b < 0x80 {
6436 break
6437 }
6438 }
6439 intStringLen := int(stringLen)
6440 if intStringLen < 0 {
6441 return ErrInvalidLengthGenerated
6442 }
6443 postIndex := iNdEx + intStringLen
6444 if postIndex < 0 {
6445 return ErrInvalidLengthGenerated
6446 }
6447 if postIndex > l {
6448 return io.ErrUnexpectedEOF
6449 }
6450 m.UpdateRevision = string(dAtA[iNdEx:postIndex])
6451 iNdEx = postIndex
6452 case 9:
6453 if wireType != 0 {
6454 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
6455 }
6456 var v int32
6457 for shift := uint(0); ; shift += 7 {
6458 if shift >= 64 {
6459 return ErrIntOverflowGenerated
6460 }
6461 if iNdEx >= l {
6462 return io.ErrUnexpectedEOF
6463 }
6464 b := dAtA[iNdEx]
6465 iNdEx++
6466 v |= int32(b&0x7F) << shift
6467 if b < 0x80 {
6468 break
6469 }
6470 }
6471 m.CollisionCount = &v
6472 case 10:
6473 if wireType != 2 {
6474 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", 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 m.Conditions = append(m.Conditions, StatefulSetCondition{})
6502 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6503 return err
6504 }
6505 iNdEx = postIndex
6506 case 11:
6507 if wireType != 0 {
6508 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
6509 }
6510 m.AvailableReplicas = 0
6511 for shift := uint(0); ; shift += 7 {
6512 if shift >= 64 {
6513 return ErrIntOverflowGenerated
6514 }
6515 if iNdEx >= l {
6516 return io.ErrUnexpectedEOF
6517 }
6518 b := dAtA[iNdEx]
6519 iNdEx++
6520 m.AvailableReplicas |= int32(b&0x7F) << shift
6521 if b < 0x80 {
6522 break
6523 }
6524 }
6525 default:
6526 iNdEx = preIndex
6527 skippy, err := skipGenerated(dAtA[iNdEx:])
6528 if err != nil {
6529 return err
6530 }
6531 if (skippy < 0) || (iNdEx+skippy) < 0 {
6532 return ErrInvalidLengthGenerated
6533 }
6534 if (iNdEx + skippy) > l {
6535 return io.ErrUnexpectedEOF
6536 }
6537 iNdEx += skippy
6538 }
6539 }
6540
6541 if iNdEx > l {
6542 return io.ErrUnexpectedEOF
6543 }
6544 return nil
6545 }
6546 func (m *StatefulSetUpdateStrategy) Unmarshal(dAtA []byte) error {
6547 l := len(dAtA)
6548 iNdEx := 0
6549 for iNdEx < l {
6550 preIndex := iNdEx
6551 var wire uint64
6552 for shift := uint(0); ; shift += 7 {
6553 if shift >= 64 {
6554 return ErrIntOverflowGenerated
6555 }
6556 if iNdEx >= l {
6557 return io.ErrUnexpectedEOF
6558 }
6559 b := dAtA[iNdEx]
6560 iNdEx++
6561 wire |= uint64(b&0x7F) << shift
6562 if b < 0x80 {
6563 break
6564 }
6565 }
6566 fieldNum := int32(wire >> 3)
6567 wireType := int(wire & 0x7)
6568 if wireType == 4 {
6569 return fmt.Errorf("proto: StatefulSetUpdateStrategy: wiretype end group for non-group")
6570 }
6571 if fieldNum <= 0 {
6572 return fmt.Errorf("proto: StatefulSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
6573 }
6574 switch fieldNum {
6575 case 1:
6576 if wireType != 2 {
6577 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
6578 }
6579 var stringLen uint64
6580 for shift := uint(0); ; shift += 7 {
6581 if shift >= 64 {
6582 return ErrIntOverflowGenerated
6583 }
6584 if iNdEx >= l {
6585 return io.ErrUnexpectedEOF
6586 }
6587 b := dAtA[iNdEx]
6588 iNdEx++
6589 stringLen |= uint64(b&0x7F) << shift
6590 if b < 0x80 {
6591 break
6592 }
6593 }
6594 intStringLen := int(stringLen)
6595 if intStringLen < 0 {
6596 return ErrInvalidLengthGenerated
6597 }
6598 postIndex := iNdEx + intStringLen
6599 if postIndex < 0 {
6600 return ErrInvalidLengthGenerated
6601 }
6602 if postIndex > l {
6603 return io.ErrUnexpectedEOF
6604 }
6605 m.Type = StatefulSetUpdateStrategyType(dAtA[iNdEx:postIndex])
6606 iNdEx = postIndex
6607 case 2:
6608 if wireType != 2 {
6609 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
6610 }
6611 var msglen int
6612 for shift := uint(0); ; shift += 7 {
6613 if shift >= 64 {
6614 return ErrIntOverflowGenerated
6615 }
6616 if iNdEx >= l {
6617 return io.ErrUnexpectedEOF
6618 }
6619 b := dAtA[iNdEx]
6620 iNdEx++
6621 msglen |= int(b&0x7F) << shift
6622 if b < 0x80 {
6623 break
6624 }
6625 }
6626 if msglen < 0 {
6627 return ErrInvalidLengthGenerated
6628 }
6629 postIndex := iNdEx + msglen
6630 if postIndex < 0 {
6631 return ErrInvalidLengthGenerated
6632 }
6633 if postIndex > l {
6634 return io.ErrUnexpectedEOF
6635 }
6636 if m.RollingUpdate == nil {
6637 m.RollingUpdate = &RollingUpdateStatefulSetStrategy{}
6638 }
6639 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6640 return err
6641 }
6642 iNdEx = postIndex
6643 default:
6644 iNdEx = preIndex
6645 skippy, err := skipGenerated(dAtA[iNdEx:])
6646 if err != nil {
6647 return err
6648 }
6649 if (skippy < 0) || (iNdEx+skippy) < 0 {
6650 return ErrInvalidLengthGenerated
6651 }
6652 if (iNdEx + skippy) > l {
6653 return io.ErrUnexpectedEOF
6654 }
6655 iNdEx += skippy
6656 }
6657 }
6658
6659 if iNdEx > l {
6660 return io.ErrUnexpectedEOF
6661 }
6662 return nil
6663 }
6664 func skipGenerated(dAtA []byte) (n int, err error) {
6665 l := len(dAtA)
6666 iNdEx := 0
6667 depth := 0
6668 for iNdEx < l {
6669 var wire uint64
6670 for shift := uint(0); ; shift += 7 {
6671 if shift >= 64 {
6672 return 0, ErrIntOverflowGenerated
6673 }
6674 if iNdEx >= l {
6675 return 0, io.ErrUnexpectedEOF
6676 }
6677 b := dAtA[iNdEx]
6678 iNdEx++
6679 wire |= (uint64(b) & 0x7F) << shift
6680 if b < 0x80 {
6681 break
6682 }
6683 }
6684 wireType := int(wire & 0x7)
6685 switch wireType {
6686 case 0:
6687 for shift := uint(0); ; shift += 7 {
6688 if shift >= 64 {
6689 return 0, ErrIntOverflowGenerated
6690 }
6691 if iNdEx >= l {
6692 return 0, io.ErrUnexpectedEOF
6693 }
6694 iNdEx++
6695 if dAtA[iNdEx-1] < 0x80 {
6696 break
6697 }
6698 }
6699 case 1:
6700 iNdEx += 8
6701 case 2:
6702 var length int
6703 for shift := uint(0); ; shift += 7 {
6704 if shift >= 64 {
6705 return 0, ErrIntOverflowGenerated
6706 }
6707 if iNdEx >= l {
6708 return 0, io.ErrUnexpectedEOF
6709 }
6710 b := dAtA[iNdEx]
6711 iNdEx++
6712 length |= (int(b) & 0x7F) << shift
6713 if b < 0x80 {
6714 break
6715 }
6716 }
6717 if length < 0 {
6718 return 0, ErrInvalidLengthGenerated
6719 }
6720 iNdEx += length
6721 case 3:
6722 depth++
6723 case 4:
6724 if depth == 0 {
6725 return 0, ErrUnexpectedEndOfGroupGenerated
6726 }
6727 depth--
6728 case 5:
6729 iNdEx += 4
6730 default:
6731 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
6732 }
6733 if iNdEx < 0 {
6734 return 0, ErrInvalidLengthGenerated
6735 }
6736 if depth == 0 {
6737 return iNdEx, nil
6738 }
6739 }
6740 return 0, io.ErrUnexpectedEOF
6741 }
6742
6743 var (
6744 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
6745 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
6746 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
6747 )
6748
View as plain text