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