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