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