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