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