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