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