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