Gitiles
Code Review Sign In
gerrit.opencord.org / voltha-go / d6e07e75efb1d9d65436ebb6ebbb80a1845208d3 / . / vendor / k8s.io / apimachinery / pkg / apis / meta / v1 / generated.pb.go
blob: 81320c9c882727ac859d00ad162bbc7a60b92052 [file] [log] [blame]
sslobodr60a6d0f2019-01-18 14:51:05 -0500[diff] [blame]1/*
2Copyright The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17// Code generated by protoc-gen-gogo. DO NOT EDIT.
18// source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto
19
20/*
21 Package v1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto
25
26 It has these top-level messages:
27 APIGroup
28 APIGroupList
29 APIResource
30 APIResourceList
31 APIVersions
32 CreateOptions
33 DeleteOptions
34 Duration
35 ExportOptions
36 GetOptions
37 GroupKind
38 GroupResource
39 GroupVersion
40 GroupVersionForDiscovery
41 GroupVersionKind
42 GroupVersionResource
43 Initializer
44 Initializers
45 LabelSelector
46 LabelSelectorRequirement
47 List
48 ListMeta
49 ListOptions
50 MicroTime
51 ObjectMeta
52 OwnerReference
53 Patch
54 Preconditions
55 RootPaths
56 ServerAddressByClientCIDR
57 Status
58 StatusCause
59 StatusDetails
60 Time
61 Timestamp
62 TypeMeta
63 UpdateOptions
64 Verbs
65 WatchEvent
66*/
67package v1
68
69import proto "github.com/gogo/protobuf/proto"
70import fmt "fmt"
71import math "math"
72
73import k8s_io_apimachinery_pkg_runtime "k8s.io/apimachinery/pkg/runtime"
74
75import time "time"
76import k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
77
78import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
79
80import strings "strings"
81import reflect "reflect"
82
83import io "io"
84
85// Reference imports to suppress errors if they are not otherwise used.
86var _ = proto.Marshal
87var _ = fmt.Errorf
88var _ = math.Inf
89var _ = time.Kitchen
90
91// This is a compile-time assertion to ensure that this generated file
92// is compatible with the proto package it is being compiled against.
93// A compilation error at this line likely means your copy of the
94// proto package needs to be updated.
95const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
96
97func (m *APIGroup) Reset() { *m = APIGroup{} }
98func (*APIGroup) ProtoMessage() {}
99func (*APIGroup) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
100
101func (m *APIGroupList) Reset() { *m = APIGroupList{} }
102func (*APIGroupList) ProtoMessage() {}
103func (*APIGroupList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
104
105func (m *APIResource) Reset() { *m = APIResource{} }
106func (*APIResource) ProtoMessage() {}
107func (*APIResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
108
109func (m *APIResourceList) Reset() { *m = APIResourceList{} }
110func (*APIResourceList) ProtoMessage() {}
111func (*APIResourceList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
112
113func (m *APIVersions) Reset() { *m = APIVersions{} }
114func (*APIVersions) ProtoMessage() {}
115func (*APIVersions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
116
117func (m *CreateOptions) Reset() { *m = CreateOptions{} }
118func (*CreateOptions) ProtoMessage() {}
119func (*CreateOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
120
121func (m *DeleteOptions) Reset() { *m = DeleteOptions{} }
122func (*DeleteOptions) ProtoMessage() {}
123func (*DeleteOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
124
125func (m *Duration) Reset() { *m = Duration{} }
126func (*Duration) ProtoMessage() {}
127func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
128
129func (m *ExportOptions) Reset() { *m = ExportOptions{} }
130func (*ExportOptions) ProtoMessage() {}
131func (*ExportOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
132
133func (m *GetOptions) Reset() { *m = GetOptions{} }
134func (*GetOptions) ProtoMessage() {}
135func (*GetOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
136
137func (m *GroupKind) Reset() { *m = GroupKind{} }
138func (*GroupKind) ProtoMessage() {}
139func (*GroupKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
140
141func (m *GroupResource) Reset() { *m = GroupResource{} }
142func (*GroupResource) ProtoMessage() {}
143func (*GroupResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
144
145func (m *GroupVersion) Reset() { *m = GroupVersion{} }
146func (*GroupVersion) ProtoMessage() {}
147func (*GroupVersion) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
148
149func (m *GroupVersionForDiscovery) Reset() { *m = GroupVersionForDiscovery{} }
150func (*GroupVersionForDiscovery) ProtoMessage() {}
151func (*GroupVersionForDiscovery) Descriptor() ([]byte, []int) {
152 return fileDescriptorGenerated, []int{13}
153}
154
155func (m *GroupVersionKind) Reset() { *m = GroupVersionKind{} }
156func (*GroupVersionKind) ProtoMessage() {}
157func (*GroupVersionKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
158
159func (m *GroupVersionResource) Reset() { *m = GroupVersionResource{} }
160func (*GroupVersionResource) ProtoMessage() {}
161func (*GroupVersionResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
162
163func (m *Initializer) Reset() { *m = Initializer{} }
164func (*Initializer) ProtoMessage() {}
165func (*Initializer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
166
167func (m *Initializers) Reset() { *m = Initializers{} }
168func (*Initializers) ProtoMessage() {}
169func (*Initializers) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
170
171func (m *LabelSelector) Reset() { *m = LabelSelector{} }
172func (*LabelSelector) ProtoMessage() {}
173func (*LabelSelector) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
174
175func (m *LabelSelectorRequirement) Reset() { *m = LabelSelectorRequirement{} }
176func (*LabelSelectorRequirement) ProtoMessage() {}
177func (*LabelSelectorRequirement) Descriptor() ([]byte, []int) {
178 return fileDescriptorGenerated, []int{19}
179}
180
181func (m *List) Reset() { *m = List{} }
182func (*List) ProtoMessage() {}
183func (*List) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
184
185func (m *ListMeta) Reset() { *m = ListMeta{} }
186func (*ListMeta) ProtoMessage() {}
187func (*ListMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
188
189func (m *ListOptions) Reset() { *m = ListOptions{} }
190func (*ListOptions) ProtoMessage() {}
191func (*ListOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
192
193func (m *MicroTime) Reset() { *m = MicroTime{} }
194func (*MicroTime) ProtoMessage() {}
195func (*MicroTime) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
196
197func (m *ObjectMeta) Reset() { *m = ObjectMeta{} }
198func (*ObjectMeta) ProtoMessage() {}
199func (*ObjectMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
200
201func (m *OwnerReference) Reset() { *m = OwnerReference{} }
202func (*OwnerReference) ProtoMessage() {}
203func (*OwnerReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
204
205func (m *Patch) Reset() { *m = Patch{} }
206func (*Patch) ProtoMessage() {}
207func (*Patch) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
208
209func (m *Preconditions) Reset() { *m = Preconditions{} }
210func (*Preconditions) ProtoMessage() {}
211func (*Preconditions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
212
213func (m *RootPaths) Reset() { *m = RootPaths{} }
214func (*RootPaths) ProtoMessage() {}
215func (*RootPaths) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
216
217func (m *ServerAddressByClientCIDR) Reset() { *m = ServerAddressByClientCIDR{} }
218func (*ServerAddressByClientCIDR) ProtoMessage() {}
219func (*ServerAddressByClientCIDR) Descriptor() ([]byte, []int) {
220 return fileDescriptorGenerated, []int{29}
221}
222
223func (m *Status) Reset() { *m = Status{} }
224func (*Status) ProtoMessage() {}
225func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
226
227func (m *StatusCause) Reset() { *m = StatusCause{} }
228func (*StatusCause) ProtoMessage() {}
229func (*StatusCause) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} }
230
231func (m *StatusDetails) Reset() { *m = StatusDetails{} }
232func (*StatusDetails) ProtoMessage() {}
233func (*StatusDetails) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} }
234
235func (m *Time) Reset() { *m = Time{} }
236func (*Time) ProtoMessage() {}
237func (*Time) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
238
239func (m *Timestamp) Reset() { *m = Timestamp{} }
240func (*Timestamp) ProtoMessage() {}
241func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
242
243func (m *TypeMeta) Reset() { *m = TypeMeta{} }
244func (*TypeMeta) ProtoMessage() {}
245func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
246
247func (m *UpdateOptions) Reset() { *m = UpdateOptions{} }
248func (*UpdateOptions) ProtoMessage() {}
249func (*UpdateOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
250
251func (m *Verbs) Reset() { *m = Verbs{} }
252func (*Verbs) ProtoMessage() {}
253func (*Verbs) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
254
255func (m *WatchEvent) Reset() { *m = WatchEvent{} }
256func (*WatchEvent) ProtoMessage() {}
257func (*WatchEvent) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
258
259func init() {
260 proto.RegisterType((*APIGroup)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroup")
261 proto.RegisterType((*APIGroupList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroupList")
262 proto.RegisterType((*APIResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResource")
263 proto.RegisterType((*APIResourceList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResourceList")
264 proto.RegisterType((*APIVersions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIVersions")
265 proto.RegisterType((*CreateOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.CreateOptions")
266 proto.RegisterType((*DeleteOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.DeleteOptions")
267 proto.RegisterType((*Duration)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Duration")
268 proto.RegisterType((*ExportOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ExportOptions")
269 proto.RegisterType((*GetOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GetOptions")
270 proto.RegisterType((*GroupKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupKind")
271 proto.RegisterType((*GroupResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupResource")
272 proto.RegisterType((*GroupVersion)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersion")
273 proto.RegisterType((*GroupVersionForDiscovery)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery")
274 proto.RegisterType((*GroupVersionKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionKind")
275 proto.RegisterType((*GroupVersionResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionResource")
276 proto.RegisterType((*Initializer)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializer")
277 proto.RegisterType((*Initializers)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializers")
278 proto.RegisterType((*LabelSelector)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector")
279 proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement")
280 proto.RegisterType((*List)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.List")
281 proto.RegisterType((*ListMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta")
282 proto.RegisterType((*ListOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListOptions")
283 proto.RegisterType((*MicroTime)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.MicroTime")
284 proto.RegisterType((*ObjectMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta")
285 proto.RegisterType((*OwnerReference)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.OwnerReference")
286 proto.RegisterType((*Patch)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Patch")
287 proto.RegisterType((*Preconditions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Preconditions")
288 proto.RegisterType((*RootPaths)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.RootPaths")
289 proto.RegisterType((*ServerAddressByClientCIDR)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR")
290 proto.RegisterType((*Status)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Status")
291 proto.RegisterType((*StatusCause)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusCause")
292 proto.RegisterType((*StatusDetails)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusDetails")
293 proto.RegisterType((*Time)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Time")
294 proto.RegisterType((*Timestamp)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Timestamp")
295 proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.TypeMeta")
296 proto.RegisterType((*UpdateOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.UpdateOptions")
297 proto.RegisterType((*Verbs)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Verbs")
298 proto.RegisterType((*WatchEvent)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.WatchEvent")
299}
300func (m *APIGroup) Marshal() (dAtA []byte, err error) {
301 size := m.Size()
302 dAtA = make([]byte, size)
303 n, err := m.MarshalTo(dAtA)
304 if err != nil {
305 return nil, err
306 }
307 return dAtA[:n], nil
308}
309
310func (m *APIGroup) MarshalTo(dAtA []byte) (int, error) {
311 var i int
312 _ = i
313 var l int
314 _ = l
315 dAtA[i] = 0xa
316 i++
317 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
318 i += copy(dAtA[i:], m.Name)
319 if len(m.Versions) > 0 {
320 for _, msg := range m.Versions {
321 dAtA[i] = 0x12
322 i++
323 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
324 n, err := msg.MarshalTo(dAtA[i:])
325 if err != nil {
326 return 0, err
327 }
328 i += n
329 }
330 }
331 dAtA[i] = 0x1a
332 i++
333 i = encodeVarintGenerated(dAtA, i, uint64(m.PreferredVersion.Size()))
334 n1, err := m.PreferredVersion.MarshalTo(dAtA[i:])
335 if err != nil {
336 return 0, err
337 }
338 i += n1
339 if len(m.ServerAddressByClientCIDRs) > 0 {
340 for _, msg := range m.ServerAddressByClientCIDRs {
341 dAtA[i] = 0x22
342 i++
343 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
344 n, err := msg.MarshalTo(dAtA[i:])
345 if err != nil {
346 return 0, err
347 }
348 i += n
349 }
350 }
351 return i, nil
352}
353
354func (m *APIGroupList) Marshal() (dAtA []byte, err error) {
355 size := m.Size()
356 dAtA = make([]byte, size)
357 n, err := m.MarshalTo(dAtA)
358 if err != nil {
359 return nil, err
360 }
361 return dAtA[:n], nil
362}
363
364func (m *APIGroupList) MarshalTo(dAtA []byte) (int, error) {
365 var i int
366 _ = i
367 var l int
368 _ = l
369 if len(m.Groups) > 0 {
370 for _, msg := range m.Groups {
371 dAtA[i] = 0xa
372 i++
373 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
374 n, err := msg.MarshalTo(dAtA[i:])
375 if err != nil {
376 return 0, err
377 }
378 i += n
379 }
380 }
381 return i, nil
382}
383
384func (m *APIResource) Marshal() (dAtA []byte, err error) {
385 size := m.Size()
386 dAtA = make([]byte, size)
387 n, err := m.MarshalTo(dAtA)
388 if err != nil {
389 return nil, err
390 }
391 return dAtA[:n], nil
392}
393
394func (m *APIResource) MarshalTo(dAtA []byte) (int, error) {
395 var i int
396 _ = i
397 var l int
398 _ = l
399 dAtA[i] = 0xa
400 i++
401 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
402 i += copy(dAtA[i:], m.Name)
403 dAtA[i] = 0x10
404 i++
405 if m.Namespaced {
406 dAtA[i] = 1
407 } else {
408 dAtA[i] = 0
409 }
410 i++
411 dAtA[i] = 0x1a
412 i++
413 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
414 i += copy(dAtA[i:], m.Kind)
415 if m.Verbs != nil {
416 dAtA[i] = 0x22
417 i++
418 i = encodeVarintGenerated(dAtA, i, uint64(m.Verbs.Size()))
419 n2, err := m.Verbs.MarshalTo(dAtA[i:])
420 if err != nil {
421 return 0, err
422 }
423 i += n2
424 }
425 if len(m.ShortNames) > 0 {
426 for _, s := range m.ShortNames {
427 dAtA[i] = 0x2a
428 i++
429 l = len(s)
430 for l >= 1<<7 {
431 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
432 l >>= 7
433 i++
434 }
435 dAtA[i] = uint8(l)
436 i++
437 i += copy(dAtA[i:], s)
438 }
439 }
440 dAtA[i] = 0x32
441 i++
442 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SingularName)))
443 i += copy(dAtA[i:], m.SingularName)
444 if len(m.Categories) > 0 {
445 for _, s := range m.Categories {
446 dAtA[i] = 0x3a
447 i++
448 l = len(s)
449 for l >= 1<<7 {
450 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
451 l >>= 7
452 i++
453 }
454 dAtA[i] = uint8(l)
455 i++
456 i += copy(dAtA[i:], s)
457 }
458 }
459 dAtA[i] = 0x42
460 i++
461 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
462 i += copy(dAtA[i:], m.Group)
463 dAtA[i] = 0x4a
464 i++
465 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
466 i += copy(dAtA[i:], m.Version)
467 return i, nil
468}
469
470func (m *APIResourceList) Marshal() (dAtA []byte, err error) {
471 size := m.Size()
472 dAtA = make([]byte, size)
473 n, err := m.MarshalTo(dAtA)
474 if err != nil {
475 return nil, err
476 }
477 return dAtA[:n], nil
478}
479
480func (m *APIResourceList) MarshalTo(dAtA []byte) (int, error) {
481 var i int
482 _ = i
483 var l int
484 _ = l
485 dAtA[i] = 0xa
486 i++
487 i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion)))
488 i += copy(dAtA[i:], m.GroupVersion)
489 if len(m.APIResources) > 0 {
490 for _, msg := range m.APIResources {
491 dAtA[i] = 0x12
492 i++
493 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
494 n, err := msg.MarshalTo(dAtA[i:])
495 if err != nil {
496 return 0, err
497 }
498 i += n
499 }
500 }
501 return i, nil
502}
503
504func (m *APIVersions) Marshal() (dAtA []byte, err error) {
505 size := m.Size()
506 dAtA = make([]byte, size)
507 n, err := m.MarshalTo(dAtA)
508 if err != nil {
509 return nil, err
510 }
511 return dAtA[:n], nil
512}
513
514func (m *APIVersions) MarshalTo(dAtA []byte) (int, error) {
515 var i int
516 _ = i
517 var l int
518 _ = l
519 if len(m.Versions) > 0 {
520 for _, s := range m.Versions {
521 dAtA[i] = 0xa
522 i++
523 l = len(s)
524 for l >= 1<<7 {
525 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
526 l >>= 7
527 i++
528 }
529 dAtA[i] = uint8(l)
530 i++
531 i += copy(dAtA[i:], s)
532 }
533 }
534 if len(m.ServerAddressByClientCIDRs) > 0 {
535 for _, msg := range m.ServerAddressByClientCIDRs {
536 dAtA[i] = 0x12
537 i++
538 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
539 n, err := msg.MarshalTo(dAtA[i:])
540 if err != nil {
541 return 0, err
542 }
543 i += n
544 }
545 }
546 return i, nil
547}
548
549func (m *CreateOptions) Marshal() (dAtA []byte, err error) {
550 size := m.Size()
551 dAtA = make([]byte, size)
552 n, err := m.MarshalTo(dAtA)
553 if err != nil {
554 return nil, err
555 }
556 return dAtA[:n], nil
557}
558
559func (m *CreateOptions) MarshalTo(dAtA []byte) (int, error) {
560 var i int
561 _ = i
562 var l int
563 _ = l
564 if len(m.DryRun) > 0 {
565 for _, s := range m.DryRun {
566 dAtA[i] = 0xa
567 i++
568 l = len(s)
569 for l >= 1<<7 {
570 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
571 l >>= 7
572 i++
573 }
574 dAtA[i] = uint8(l)
575 i++
576 i += copy(dAtA[i:], s)
577 }
578 }
579 dAtA[i] = 0x10
580 i++
581 if m.IncludeUninitialized {
582 dAtA[i] = 1
583 } else {
584 dAtA[i] = 0
585 }
586 i++
587 return i, nil
588}
589
590func (m *DeleteOptions) Marshal() (dAtA []byte, err error) {
591 size := m.Size()
592 dAtA = make([]byte, size)
593 n, err := m.MarshalTo(dAtA)
594 if err != nil {
595 return nil, err
596 }
597 return dAtA[:n], nil
598}
599
600func (m *DeleteOptions) MarshalTo(dAtA []byte) (int, error) {
601 var i int
602 _ = i
603 var l int
604 _ = l
605 if m.GracePeriodSeconds != nil {
606 dAtA[i] = 0x8
607 i++
608 i = encodeVarintGenerated(dAtA, i, uint64(*m.GracePeriodSeconds))
609 }
610 if m.Preconditions != nil {
611 dAtA[i] = 0x12
612 i++
613 i = encodeVarintGenerated(dAtA, i, uint64(m.Preconditions.Size()))
614 n3, err := m.Preconditions.MarshalTo(dAtA[i:])
615 if err != nil {
616 return 0, err
617 }
618 i += n3
619 }
620 if m.OrphanDependents != nil {
621 dAtA[i] = 0x18
622 i++
623 if *m.OrphanDependents {
624 dAtA[i] = 1
625 } else {
626 dAtA[i] = 0
627 }
628 i++
629 }
630 if m.PropagationPolicy != nil {
631 dAtA[i] = 0x22
632 i++
633 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PropagationPolicy)))
634 i += copy(dAtA[i:], *m.PropagationPolicy)
635 }
636 if len(m.DryRun) > 0 {
637 for _, s := range m.DryRun {
638 dAtA[i] = 0x2a
639 i++
640 l = len(s)
641 for l >= 1<<7 {
642 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
643 l >>= 7
644 i++
645 }
646 dAtA[i] = uint8(l)
647 i++
648 i += copy(dAtA[i:], s)
649 }
650 }
651 return i, nil
652}
653
654func (m *Duration) Marshal() (dAtA []byte, err error) {
655 size := m.Size()
656 dAtA = make([]byte, size)
657 n, err := m.MarshalTo(dAtA)
658 if err != nil {
659 return nil, err
660 }
661 return dAtA[:n], nil
662}
663
664func (m *Duration) MarshalTo(dAtA []byte) (int, error) {
665 var i int
666 _ = i
667 var l int
668 _ = l
669 dAtA[i] = 0x8
670 i++
671 i = encodeVarintGenerated(dAtA, i, uint64(m.Duration))
672 return i, nil
673}
674
675func (m *ExportOptions) Marshal() (dAtA []byte, err error) {
676 size := m.Size()
677 dAtA = make([]byte, size)
678 n, err := m.MarshalTo(dAtA)
679 if err != nil {
680 return nil, err
681 }
682 return dAtA[:n], nil
683}
684
685func (m *ExportOptions) MarshalTo(dAtA []byte) (int, error) {
686 var i int
687 _ = i
688 var l int
689 _ = l
690 dAtA[i] = 0x8
691 i++
692 if m.Export {
693 dAtA[i] = 1
694 } else {
695 dAtA[i] = 0
696 }
697 i++
698 dAtA[i] = 0x10
699 i++
700 if m.Exact {
701 dAtA[i] = 1
702 } else {
703 dAtA[i] = 0
704 }
705 i++
706 return i, nil
707}
708
709func (m *GetOptions) Marshal() (dAtA []byte, err error) {
710 size := m.Size()
711 dAtA = make([]byte, size)
712 n, err := m.MarshalTo(dAtA)
713 if err != nil {
714 return nil, err
715 }
716 return dAtA[:n], nil
717}
718
719func (m *GetOptions) MarshalTo(dAtA []byte) (int, error) {
720 var i int
721 _ = i
722 var l int
723 _ = l
724 dAtA[i] = 0xa
725 i++
726 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
727 i += copy(dAtA[i:], m.ResourceVersion)
728 dAtA[i] = 0x10
729 i++
730 if m.IncludeUninitialized {
731 dAtA[i] = 1
732 } else {
733 dAtA[i] = 0
734 }
735 i++
736 return i, nil
737}
738
739func (m *GroupKind) Marshal() (dAtA []byte, err error) {
740 size := m.Size()
741 dAtA = make([]byte, size)
742 n, err := m.MarshalTo(dAtA)
743 if err != nil {
744 return nil, err
745 }
746 return dAtA[:n], nil
747}
748
749func (m *GroupKind) MarshalTo(dAtA []byte) (int, error) {
750 var i int
751 _ = i
752 var l int
753 _ = l
754 dAtA[i] = 0xa
755 i++
756 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
757 i += copy(dAtA[i:], m.Group)
758 dAtA[i] = 0x12
759 i++
760 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
761 i += copy(dAtA[i:], m.Kind)
762 return i, nil
763}
764
765func (m *GroupResource) Marshal() (dAtA []byte, err error) {
766 size := m.Size()
767 dAtA = make([]byte, size)
768 n, err := m.MarshalTo(dAtA)
769 if err != nil {
770 return nil, err
771 }
772 return dAtA[:n], nil
773}
774
775func (m *GroupResource) MarshalTo(dAtA []byte) (int, error) {
776 var i int
777 _ = i
778 var l int
779 _ = l
780 dAtA[i] = 0xa
781 i++
782 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
783 i += copy(dAtA[i:], m.Group)
784 dAtA[i] = 0x12
785 i++
786 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
787 i += copy(dAtA[i:], m.Resource)
788 return i, nil
789}
790
791func (m *GroupVersion) Marshal() (dAtA []byte, err error) {
792 size := m.Size()
793 dAtA = make([]byte, size)
794 n, err := m.MarshalTo(dAtA)
795 if err != nil {
796 return nil, err
797 }
798 return dAtA[:n], nil
799}
800
801func (m *GroupVersion) MarshalTo(dAtA []byte) (int, error) {
802 var i int
803 _ = i
804 var l int
805 _ = l
806 dAtA[i] = 0xa
807 i++
808 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
809 i += copy(dAtA[i:], m.Group)
810 dAtA[i] = 0x12
811 i++
812 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
813 i += copy(dAtA[i:], m.Version)
814 return i, nil
815}
816
817func (m *GroupVersionForDiscovery) Marshal() (dAtA []byte, err error) {
818 size := m.Size()
819 dAtA = make([]byte, size)
820 n, err := m.MarshalTo(dAtA)
821 if err != nil {
822 return nil, err
823 }
824 return dAtA[:n], nil
825}
826
827func (m *GroupVersionForDiscovery) MarshalTo(dAtA []byte) (int, error) {
828 var i int
829 _ = i
830 var l int
831 _ = l
832 dAtA[i] = 0xa
833 i++
834 i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion)))
835 i += copy(dAtA[i:], m.GroupVersion)
836 dAtA[i] = 0x12
837 i++
838 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
839 i += copy(dAtA[i:], m.Version)
840 return i, nil
841}
842
843func (m *GroupVersionKind) Marshal() (dAtA []byte, err error) {
844 size := m.Size()
845 dAtA = make([]byte, size)
846 n, err := m.MarshalTo(dAtA)
847 if err != nil {
848 return nil, err
849 }
850 return dAtA[:n], nil
851}
852
853func (m *GroupVersionKind) MarshalTo(dAtA []byte) (int, error) {
854 var i int
855 _ = i
856 var l int
857 _ = l
858 dAtA[i] = 0xa
859 i++
860 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
861 i += copy(dAtA[i:], m.Group)
862 dAtA[i] = 0x12
863 i++
864 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
865 i += copy(dAtA[i:], m.Version)
866 dAtA[i] = 0x1a
867 i++
868 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
869 i += copy(dAtA[i:], m.Kind)
870 return i, nil
871}
872
873func (m *GroupVersionResource) Marshal() (dAtA []byte, err error) {
874 size := m.Size()
875 dAtA = make([]byte, size)
876 n, err := m.MarshalTo(dAtA)
877 if err != nil {
878 return nil, err
879 }
880 return dAtA[:n], nil
881}
882
883func (m *GroupVersionResource) MarshalTo(dAtA []byte) (int, error) {
884 var i int
885 _ = i
886 var l int
887 _ = l
888 dAtA[i] = 0xa
889 i++
890 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
891 i += copy(dAtA[i:], m.Group)
892 dAtA[i] = 0x12
893 i++
894 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version)))
895 i += copy(dAtA[i:], m.Version)
896 dAtA[i] = 0x1a
897 i++
898 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource)))
899 i += copy(dAtA[i:], m.Resource)
900 return i, nil
901}
902
903func (m *Initializer) Marshal() (dAtA []byte, err error) {
904 size := m.Size()
905 dAtA = make([]byte, size)
906 n, err := m.MarshalTo(dAtA)
907 if err != nil {
908 return nil, err
909 }
910 return dAtA[:n], nil
911}
912
913func (m *Initializer) MarshalTo(dAtA []byte) (int, error) {
914 var i int
915 _ = i
916 var l int
917 _ = l
918 dAtA[i] = 0xa
919 i++
920 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
921 i += copy(dAtA[i:], m.Name)
922 return i, nil
923}
924
925func (m *Initializers) Marshal() (dAtA []byte, err error) {
926 size := m.Size()
927 dAtA = make([]byte, size)
928 n, err := m.MarshalTo(dAtA)
929 if err != nil {
930 return nil, err
931 }
932 return dAtA[:n], nil
933}
934
935func (m *Initializers) MarshalTo(dAtA []byte) (int, error) {
936 var i int
937 _ = i
938 var l int
939 _ = l
940 if len(m.Pending) > 0 {
941 for _, msg := range m.Pending {
942 dAtA[i] = 0xa
943 i++
944 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
945 n, err := msg.MarshalTo(dAtA[i:])
946 if err != nil {
947 return 0, err
948 }
949 i += n
950 }
951 }
952 if m.Result != nil {
953 dAtA[i] = 0x12
954 i++
955 i = encodeVarintGenerated(dAtA, i, uint64(m.Result.Size()))
956 n4, err := m.Result.MarshalTo(dAtA[i:])
957 if err != nil {
958 return 0, err
959 }
960 i += n4
961 }
962 return i, nil
963}
964
965func (m *LabelSelector) Marshal() (dAtA []byte, err error) {
966 size := m.Size()
967 dAtA = make([]byte, size)
968 n, err := m.MarshalTo(dAtA)
969 if err != nil {
970 return nil, err
971 }
972 return dAtA[:n], nil
973}
974
975func (m *LabelSelector) MarshalTo(dAtA []byte) (int, error) {
976 var i int
977 _ = i
978 var l int
979 _ = l
980 if len(m.MatchLabels) > 0 {
981 keysForMatchLabels := make([]string, 0, len(m.MatchLabels))
982 for k := range m.MatchLabels {
983 keysForMatchLabels = append(keysForMatchLabels, string(k))
984 }
985 github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
986 for _, k := range keysForMatchLabels {
987 dAtA[i] = 0xa
988 i++
989 v := m.MatchLabels[string(k)]
990 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
991 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
992 dAtA[i] = 0xa
993 i++
994 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
995 i += copy(dAtA[i:], k)
996 dAtA[i] = 0x12
997 i++
998 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
999 i += copy(dAtA[i:], v)
1000 }
1001 }
1002 if len(m.MatchExpressions) > 0 {
1003 for _, msg := range m.MatchExpressions {
1004 dAtA[i] = 0x12
1005 i++
1006 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1007 n, err := msg.MarshalTo(dAtA[i:])
1008 if err != nil {
1009 return 0, err
1010 }
1011 i += n
1012 }
1013 }
1014 return i, nil
1015}
1016
1017func (m *LabelSelectorRequirement) Marshal() (dAtA []byte, err error) {
1018 size := m.Size()
1019 dAtA = make([]byte, size)
1020 n, err := m.MarshalTo(dAtA)
1021 if err != nil {
1022 return nil, err
1023 }
1024 return dAtA[:n], nil
1025}
1026
1027func (m *LabelSelectorRequirement) MarshalTo(dAtA []byte) (int, error) {
1028 var i int
1029 _ = i
1030 var l int
1031 _ = l
1032 dAtA[i] = 0xa
1033 i++
1034 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key)))
1035 i += copy(dAtA[i:], m.Key)
1036 dAtA[i] = 0x12
1037 i++
1038 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator)))
1039 i += copy(dAtA[i:], m.Operator)
1040 if len(m.Values) > 0 {
1041 for _, s := range m.Values {
1042 dAtA[i] = 0x1a
1043 i++
1044 l = len(s)
1045 for l >= 1<<7 {
1046 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1047 l >>= 7
1048 i++
1049 }
1050 dAtA[i] = uint8(l)
1051 i++
1052 i += copy(dAtA[i:], s)
1053 }
1054 }
1055 return i, nil
1056}
1057
1058func (m *List) Marshal() (dAtA []byte, err error) {
1059 size := m.Size()
1060 dAtA = make([]byte, size)
1061 n, err := m.MarshalTo(dAtA)
1062 if err != nil {
1063 return nil, err
1064 }
1065 return dAtA[:n], nil
1066}
1067
1068func (m *List) MarshalTo(dAtA []byte) (int, error) {
1069 var i int
1070 _ = i
1071 var l int
1072 _ = l
1073 dAtA[i] = 0xa
1074 i++
1075 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1076 n5, err := m.ListMeta.MarshalTo(dAtA[i:])
1077 if err != nil {
1078 return 0, err
1079 }
1080 i += n5
1081 if len(m.Items) > 0 {
1082 for _, msg := range m.Items {
1083 dAtA[i] = 0x12
1084 i++
1085 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1086 n, err := msg.MarshalTo(dAtA[i:])
1087 if err != nil {
1088 return 0, err
1089 }
1090 i += n
1091 }
1092 }
1093 return i, nil
1094}
1095
1096func (m *ListMeta) Marshal() (dAtA []byte, err error) {
1097 size := m.Size()
1098 dAtA = make([]byte, size)
1099 n, err := m.MarshalTo(dAtA)
1100 if err != nil {
1101 return nil, err
1102 }
1103 return dAtA[:n], nil
1104}
1105
1106func (m *ListMeta) MarshalTo(dAtA []byte) (int, error) {
1107 var i int
1108 _ = i
1109 var l int
1110 _ = l
1111 dAtA[i] = 0xa
1112 i++
1113 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink)))
1114 i += copy(dAtA[i:], m.SelfLink)
1115 dAtA[i] = 0x12
1116 i++
1117 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
1118 i += copy(dAtA[i:], m.ResourceVersion)
1119 dAtA[i] = 0x1a
1120 i++
1121 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue)))
1122 i += copy(dAtA[i:], m.Continue)
1123 return i, nil
1124}
1125
1126func (m *ListOptions) Marshal() (dAtA []byte, err error) {
1127 size := m.Size()
1128 dAtA = make([]byte, size)
1129 n, err := m.MarshalTo(dAtA)
1130 if err != nil {
1131 return nil, err
1132 }
1133 return dAtA[:n], nil
1134}
1135
1136func (m *ListOptions) MarshalTo(dAtA []byte) (int, error) {
1137 var i int
1138 _ = i
1139 var l int
1140 _ = l
1141 dAtA[i] = 0xa
1142 i++
1143 i = encodeVarintGenerated(dAtA, i, uint64(len(m.LabelSelector)))
1144 i += copy(dAtA[i:], m.LabelSelector)
1145 dAtA[i] = 0x12
1146 i++
1147 i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldSelector)))
1148 i += copy(dAtA[i:], m.FieldSelector)
1149 dAtA[i] = 0x18
1150 i++
1151 if m.Watch {
1152 dAtA[i] = 1
1153 } else {
1154 dAtA[i] = 0
1155 }
1156 i++
1157 dAtA[i] = 0x22
1158 i++
1159 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
1160 i += copy(dAtA[i:], m.ResourceVersion)
1161 if m.TimeoutSeconds != nil {
1162 dAtA[i] = 0x28
1163 i++
1164 i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds))
1165 }
1166 dAtA[i] = 0x30
1167 i++
1168 if m.IncludeUninitialized {
1169 dAtA[i] = 1
1170 } else {
1171 dAtA[i] = 0
1172 }
1173 i++
1174 dAtA[i] = 0x38
1175 i++
1176 i = encodeVarintGenerated(dAtA, i, uint64(m.Limit))
1177 dAtA[i] = 0x42
1178 i++
1179 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue)))
1180 i += copy(dAtA[i:], m.Continue)
1181 return i, nil
1182}
1183
1184func (m *ObjectMeta) Marshal() (dAtA []byte, err error) {
1185 size := m.Size()
1186 dAtA = make([]byte, size)
1187 n, err := m.MarshalTo(dAtA)
1188 if err != nil {
1189 return nil, err
1190 }
1191 return dAtA[:n], nil
1192}
1193
1194func (m *ObjectMeta) MarshalTo(dAtA []byte) (int, error) {
1195 var i int
1196 _ = i
1197 var l int
1198 _ = l
1199 dAtA[i] = 0xa
1200 i++
1201 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1202 i += copy(dAtA[i:], m.Name)
1203 dAtA[i] = 0x12
1204 i++
1205 i = encodeVarintGenerated(dAtA, i, uint64(len(m.GenerateName)))
1206 i += copy(dAtA[i:], m.GenerateName)
1207 dAtA[i] = 0x1a
1208 i++
1209 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
1210 i += copy(dAtA[i:], m.Namespace)
1211 dAtA[i] = 0x22
1212 i++
1213 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink)))
1214 i += copy(dAtA[i:], m.SelfLink)
1215 dAtA[i] = 0x2a
1216 i++
1217 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1218 i += copy(dAtA[i:], m.UID)
1219 dAtA[i] = 0x32
1220 i++
1221 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion)))
1222 i += copy(dAtA[i:], m.ResourceVersion)
1223 dAtA[i] = 0x38
1224 i++
1225 i = encodeVarintGenerated(dAtA, i, uint64(m.Generation))
1226 dAtA[i] = 0x42
1227 i++
1228 i = encodeVarintGenerated(dAtA, i, uint64(m.CreationTimestamp.Size()))
1229 n6, err := m.CreationTimestamp.MarshalTo(dAtA[i:])
1230 if err != nil {
1231 return 0, err
1232 }
1233 i += n6
1234 if m.DeletionTimestamp != nil {
1235 dAtA[i] = 0x4a
1236 i++
1237 i = encodeVarintGenerated(dAtA, i, uint64(m.DeletionTimestamp.Size()))
1238 n7, err := m.DeletionTimestamp.MarshalTo(dAtA[i:])
1239 if err != nil {
1240 return 0, err
1241 }
1242 i += n7
1243 }
1244 if m.DeletionGracePeriodSeconds != nil {
1245 dAtA[i] = 0x50
1246 i++
1247 i = encodeVarintGenerated(dAtA, i, uint64(*m.DeletionGracePeriodSeconds))
1248 }
1249 if len(m.Labels) > 0 {
1250 keysForLabels := make([]string, 0, len(m.Labels))
1251 for k := range m.Labels {
1252 keysForLabels = append(keysForLabels, string(k))
1253 }
1254 github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
1255 for _, k := range keysForLabels {
1256 dAtA[i] = 0x5a
1257 i++
1258 v := m.Labels[string(k)]
1259 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1260 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1261 dAtA[i] = 0xa
1262 i++
1263 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1264 i += copy(dAtA[i:], k)
1265 dAtA[i] = 0x12
1266 i++
1267 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1268 i += copy(dAtA[i:], v)
1269 }
1270 }
1271 if len(m.Annotations) > 0 {
1272 keysForAnnotations := make([]string, 0, len(m.Annotations))
1273 for k := range m.Annotations {
1274 keysForAnnotations = append(keysForAnnotations, string(k))
1275 }
1276 github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
1277 for _, k := range keysForAnnotations {
1278 dAtA[i] = 0x62
1279 i++
1280 v := m.Annotations[string(k)]
1281 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1282 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
1283 dAtA[i] = 0xa
1284 i++
1285 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
1286 i += copy(dAtA[i:], k)
1287 dAtA[i] = 0x12
1288 i++
1289 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1290 i += copy(dAtA[i:], v)
1291 }
1292 }
1293 if len(m.OwnerReferences) > 0 {
1294 for _, msg := range m.OwnerReferences {
1295 dAtA[i] = 0x6a
1296 i++
1297 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1298 n, err := msg.MarshalTo(dAtA[i:])
1299 if err != nil {
1300 return 0, err
1301 }
1302 i += n
1303 }
1304 }
1305 if len(m.Finalizers) > 0 {
1306 for _, s := range m.Finalizers {
1307 dAtA[i] = 0x72
1308 i++
1309 l = len(s)
1310 for l >= 1<<7 {
1311 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1312 l >>= 7
1313 i++
1314 }
1315 dAtA[i] = uint8(l)
1316 i++
1317 i += copy(dAtA[i:], s)
1318 }
1319 }
1320 dAtA[i] = 0x7a
1321 i++
1322 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClusterName)))
1323 i += copy(dAtA[i:], m.ClusterName)
1324 if m.Initializers != nil {
1325 dAtA[i] = 0x82
1326 i++
1327 dAtA[i] = 0x1
1328 i++
1329 i = encodeVarintGenerated(dAtA, i, uint64(m.Initializers.Size()))
1330 n8, err := m.Initializers.MarshalTo(dAtA[i:])
1331 if err != nil {
1332 return 0, err
1333 }
1334 i += n8
1335 }
1336 return i, nil
1337}
1338
1339func (m *OwnerReference) Marshal() (dAtA []byte, err error) {
1340 size := m.Size()
1341 dAtA = make([]byte, size)
1342 n, err := m.MarshalTo(dAtA)
1343 if err != nil {
1344 return nil, err
1345 }
1346 return dAtA[:n], nil
1347}
1348
1349func (m *OwnerReference) MarshalTo(dAtA []byte) (int, error) {
1350 var i int
1351 _ = i
1352 var l int
1353 _ = l
1354 dAtA[i] = 0xa
1355 i++
1356 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1357 i += copy(dAtA[i:], m.Kind)
1358 dAtA[i] = 0x1a
1359 i++
1360 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1361 i += copy(dAtA[i:], m.Name)
1362 dAtA[i] = 0x22
1363 i++
1364 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1365 i += copy(dAtA[i:], m.UID)
1366 dAtA[i] = 0x2a
1367 i++
1368 i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
1369 i += copy(dAtA[i:], m.APIVersion)
1370 if m.Controller != nil {
1371 dAtA[i] = 0x30
1372 i++
1373 if *m.Controller {
1374 dAtA[i] = 1
1375 } else {
1376 dAtA[i] = 0
1377 }
1378 i++
1379 }
1380 if m.BlockOwnerDeletion != nil {
1381 dAtA[i] = 0x38
1382 i++
1383 if *m.BlockOwnerDeletion {
1384 dAtA[i] = 1
1385 } else {
1386 dAtA[i] = 0
1387 }
1388 i++
1389 }
1390 return i, nil
1391}
1392
1393func (m *Patch) Marshal() (dAtA []byte, err error) {
1394 size := m.Size()
1395 dAtA = make([]byte, size)
1396 n, err := m.MarshalTo(dAtA)
1397 if err != nil {
1398 return nil, err
1399 }
1400 return dAtA[:n], nil
1401}
1402
1403func (m *Patch) MarshalTo(dAtA []byte) (int, error) {
1404 var i int
1405 _ = i
1406 var l int
1407 _ = l
1408 return i, nil
1409}
1410
1411func (m *Preconditions) Marshal() (dAtA []byte, err error) {
1412 size := m.Size()
1413 dAtA = make([]byte, size)
1414 n, err := m.MarshalTo(dAtA)
1415 if err != nil {
1416 return nil, err
1417 }
1418 return dAtA[:n], nil
1419}
1420
1421func (m *Preconditions) MarshalTo(dAtA []byte) (int, error) {
1422 var i int
1423 _ = i
1424 var l int
1425 _ = l
1426 if m.UID != nil {
1427 dAtA[i] = 0xa
1428 i++
1429 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UID)))
1430 i += copy(dAtA[i:], *m.UID)
1431 }
1432 return i, nil
1433}
1434
1435func (m *RootPaths) Marshal() (dAtA []byte, err error) {
1436 size := m.Size()
1437 dAtA = make([]byte, size)
1438 n, err := m.MarshalTo(dAtA)
1439 if err != nil {
1440 return nil, err
1441 }
1442 return dAtA[:n], nil
1443}
1444
1445func (m *RootPaths) MarshalTo(dAtA []byte) (int, error) {
1446 var i int
1447 _ = i
1448 var l int
1449 _ = l
1450 if len(m.Paths) > 0 {
1451 for _, s := range m.Paths {
1452 dAtA[i] = 0xa
1453 i++
1454 l = len(s)
1455 for l >= 1<<7 {
1456 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1457 l >>= 7
1458 i++
1459 }
1460 dAtA[i] = uint8(l)
1461 i++
1462 i += copy(dAtA[i:], s)
1463 }
1464 }
1465 return i, nil
1466}
1467
1468func (m *ServerAddressByClientCIDR) Marshal() (dAtA []byte, err error) {
1469 size := m.Size()
1470 dAtA = make([]byte, size)
1471 n, err := m.MarshalTo(dAtA)
1472 if err != nil {
1473 return nil, err
1474 }
1475 return dAtA[:n], nil
1476}
1477
1478func (m *ServerAddressByClientCIDR) MarshalTo(dAtA []byte) (int, error) {
1479 var i int
1480 _ = i
1481 var l int
1482 _ = l
1483 dAtA[i] = 0xa
1484 i++
1485 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientCIDR)))
1486 i += copy(dAtA[i:], m.ClientCIDR)
1487 dAtA[i] = 0x12
1488 i++
1489 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServerAddress)))
1490 i += copy(dAtA[i:], m.ServerAddress)
1491 return i, nil
1492}
1493
1494func (m *Status) Marshal() (dAtA []byte, err error) {
1495 size := m.Size()
1496 dAtA = make([]byte, size)
1497 n, err := m.MarshalTo(dAtA)
1498 if err != nil {
1499 return nil, err
1500 }
1501 return dAtA[:n], nil
1502}
1503
1504func (m *Status) MarshalTo(dAtA []byte) (int, error) {
1505 var i int
1506 _ = i
1507 var l int
1508 _ = l
1509 dAtA[i] = 0xa
1510 i++
1511 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
1512 n9, err := m.ListMeta.MarshalTo(dAtA[i:])
1513 if err != nil {
1514 return 0, err
1515 }
1516 i += n9
1517 dAtA[i] = 0x12
1518 i++
1519 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
1520 i += copy(dAtA[i:], m.Status)
1521 dAtA[i] = 0x1a
1522 i++
1523 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1524 i += copy(dAtA[i:], m.Message)
1525 dAtA[i] = 0x22
1526 i++
1527 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
1528 i += copy(dAtA[i:], m.Reason)
1529 if m.Details != nil {
1530 dAtA[i] = 0x2a
1531 i++
1532 i = encodeVarintGenerated(dAtA, i, uint64(m.Details.Size()))
1533 n10, err := m.Details.MarshalTo(dAtA[i:])
1534 if err != nil {
1535 return 0, err
1536 }
1537 i += n10
1538 }
1539 dAtA[i] = 0x30
1540 i++
1541 i = encodeVarintGenerated(dAtA, i, uint64(m.Code))
1542 return i, nil
1543}
1544
1545func (m *StatusCause) Marshal() (dAtA []byte, err error) {
1546 size := m.Size()
1547 dAtA = make([]byte, size)
1548 n, err := m.MarshalTo(dAtA)
1549 if err != nil {
1550 return nil, err
1551 }
1552 return dAtA[:n], nil
1553}
1554
1555func (m *StatusCause) MarshalTo(dAtA []byte) (int, error) {
1556 var i int
1557 _ = i
1558 var l int
1559 _ = l
1560 dAtA[i] = 0xa
1561 i++
1562 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1563 i += copy(dAtA[i:], m.Type)
1564 dAtA[i] = 0x12
1565 i++
1566 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1567 i += copy(dAtA[i:], m.Message)
1568 dAtA[i] = 0x1a
1569 i++
1570 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Field)))
1571 i += copy(dAtA[i:], m.Field)
1572 return i, nil
1573}
1574
1575func (m *StatusDetails) Marshal() (dAtA []byte, err error) {
1576 size := m.Size()
1577 dAtA = make([]byte, size)
1578 n, err := m.MarshalTo(dAtA)
1579 if err != nil {
1580 return nil, err
1581 }
1582 return dAtA[:n], nil
1583}
1584
1585func (m *StatusDetails) MarshalTo(dAtA []byte) (int, error) {
1586 var i int
1587 _ = i
1588 var l int
1589 _ = l
1590 dAtA[i] = 0xa
1591 i++
1592 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1593 i += copy(dAtA[i:], m.Name)
1594 dAtA[i] = 0x12
1595 i++
1596 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group)))
1597 i += copy(dAtA[i:], m.Group)
1598 dAtA[i] = 0x1a
1599 i++
1600 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1601 i += copy(dAtA[i:], m.Kind)
1602 if len(m.Causes) > 0 {
1603 for _, msg := range m.Causes {
1604 dAtA[i] = 0x22
1605 i++
1606 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
1607 n, err := msg.MarshalTo(dAtA[i:])
1608 if err != nil {
1609 return 0, err
1610 }
1611 i += n
1612 }
1613 }
1614 dAtA[i] = 0x28
1615 i++
1616 i = encodeVarintGenerated(dAtA, i, uint64(m.RetryAfterSeconds))
1617 dAtA[i] = 0x32
1618 i++
1619 i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
1620 i += copy(dAtA[i:], m.UID)
1621 return i, nil
1622}
1623
1624func (m *Timestamp) Marshal() (dAtA []byte, err error) {
1625 size := m.Size()
1626 dAtA = make([]byte, size)
1627 n, err := m.MarshalTo(dAtA)
1628 if err != nil {
1629 return nil, err
1630 }
1631 return dAtA[:n], nil
1632}
1633
1634func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) {
1635 var i int
1636 _ = i
1637 var l int
1638 _ = l
1639 dAtA[i] = 0x8
1640 i++
1641 i = encodeVarintGenerated(dAtA, i, uint64(m.Seconds))
1642 dAtA[i] = 0x10
1643 i++
1644 i = encodeVarintGenerated(dAtA, i, uint64(m.Nanos))
1645 return i, nil
1646}
1647
1648func (m *TypeMeta) Marshal() (dAtA []byte, err error) {
1649 size := m.Size()
1650 dAtA = make([]byte, size)
1651 n, err := m.MarshalTo(dAtA)
1652 if err != nil {
1653 return nil, err
1654 }
1655 return dAtA[:n], nil
1656}
1657
1658func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) {
1659 var i int
1660 _ = i
1661 var l int
1662 _ = l
1663 dAtA[i] = 0xa
1664 i++
1665 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
1666 i += copy(dAtA[i:], m.Kind)
1667 dAtA[i] = 0x12
1668 i++
1669 i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
1670 i += copy(dAtA[i:], m.APIVersion)
1671 return i, nil
1672}
1673
1674func (m *UpdateOptions) Marshal() (dAtA []byte, err error) {
1675 size := m.Size()
1676 dAtA = make([]byte, size)
1677 n, err := m.MarshalTo(dAtA)
1678 if err != nil {
1679 return nil, err
1680 }
1681 return dAtA[:n], nil
1682}
1683
1684func (m *UpdateOptions) MarshalTo(dAtA []byte) (int, error) {
1685 var i int
1686 _ = i
1687 var l int
1688 _ = l
1689 if len(m.DryRun) > 0 {
1690 for _, s := range m.DryRun {
1691 dAtA[i] = 0xa
1692 i++
1693 l = len(s)
1694 for l >= 1<<7 {
1695 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1696 l >>= 7
1697 i++
1698 }
1699 dAtA[i] = uint8(l)
1700 i++
1701 i += copy(dAtA[i:], s)
1702 }
1703 }
1704 return i, nil
1705}
1706
1707func (m Verbs) Marshal() (dAtA []byte, err error) {
1708 size := m.Size()
1709 dAtA = make([]byte, size)
1710 n, err := m.MarshalTo(dAtA)
1711 if err != nil {
1712 return nil, err
1713 }
1714 return dAtA[:n], nil
1715}
1716
1717func (m Verbs) MarshalTo(dAtA []byte) (int, error) {
1718 var i int
1719 _ = i
1720 var l int
1721 _ = l
1722 if len(m) > 0 {
1723 for _, s := range m {
1724 dAtA[i] = 0xa
1725 i++
1726 l = len(s)
1727 for l >= 1<<7 {
1728 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
1729 l >>= 7
1730 i++
1731 }
1732 dAtA[i] = uint8(l)
1733 i++
1734 i += copy(dAtA[i:], s)
1735 }
1736 }
1737 return i, nil
1738}
1739
1740func (m *WatchEvent) Marshal() (dAtA []byte, err error) {
1741 size := m.Size()
1742 dAtA = make([]byte, size)
1743 n, err := m.MarshalTo(dAtA)
1744 if err != nil {
1745 return nil, err
1746 }
1747 return dAtA[:n], nil
1748}
1749
1750func (m *WatchEvent) MarshalTo(dAtA []byte) (int, error) {
1751 var i int
1752 _ = i
1753 var l int
1754 _ = l
1755 dAtA[i] = 0xa
1756 i++
1757 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
1758 i += copy(dAtA[i:], m.Type)
1759 dAtA[i] = 0x12
1760 i++
1761 i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size()))
1762 n11, err := m.Object.MarshalTo(dAtA[i:])
1763 if err != nil {
1764 return 0, err
1765 }
1766 i += n11
1767 return i, nil
1768}
1769
1770func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1771 for v >= 1<<7 {
1772 dAtA[offset] = uint8(v&0x7f | 0x80)
1773 v >>= 7
1774 offset++
1775 }
1776 dAtA[offset] = uint8(v)
1777 return offset + 1
1778}
1779func (m *APIGroup) Size() (n int) {
1780 var l int
1781 _ = l
1782 l = len(m.Name)
1783 n += 1 + l + sovGenerated(uint64(l))
1784 if len(m.Versions) > 0 {
1785 for _, e := range m.Versions {
1786 l = e.Size()
1787 n += 1 + l + sovGenerated(uint64(l))
1788 }
1789 }
1790 l = m.PreferredVersion.Size()
1791 n += 1 + l + sovGenerated(uint64(l))
1792 if len(m.ServerAddressByClientCIDRs) > 0 {
1793 for _, e := range m.ServerAddressByClientCIDRs {
1794 l = e.Size()
1795 n += 1 + l + sovGenerated(uint64(l))
1796 }
1797 }
1798 return n
1799}
1800
1801func (m *APIGroupList) Size() (n int) {
1802 var l int
1803 _ = l
1804 if len(m.Groups) > 0 {
1805 for _, e := range m.Groups {
1806 l = e.Size()
1807 n += 1 + l + sovGenerated(uint64(l))
1808 }
1809 }
1810 return n
1811}
1812
1813func (m *APIResource) Size() (n int) {
1814 var l int
1815 _ = l
1816 l = len(m.Name)
1817 n += 1 + l + sovGenerated(uint64(l))
1818 n += 2
1819 l = len(m.Kind)
1820 n += 1 + l + sovGenerated(uint64(l))
1821 if m.Verbs != nil {
1822 l = m.Verbs.Size()
1823 n += 1 + l + sovGenerated(uint64(l))
1824 }
1825 if len(m.ShortNames) > 0 {
1826 for _, s := range m.ShortNames {
1827 l = len(s)
1828 n += 1 + l + sovGenerated(uint64(l))
1829 }
1830 }
1831 l = len(m.SingularName)
1832 n += 1 + l + sovGenerated(uint64(l))
1833 if len(m.Categories) > 0 {
1834 for _, s := range m.Categories {
1835 l = len(s)
1836 n += 1 + l + sovGenerated(uint64(l))
1837 }
1838 }
1839 l = len(m.Group)
1840 n += 1 + l + sovGenerated(uint64(l))
1841 l = len(m.Version)
1842 n += 1 + l + sovGenerated(uint64(l))
1843 return n
1844}
1845
1846func (m *APIResourceList) Size() (n int) {
1847 var l int
1848 _ = l
1849 l = len(m.GroupVersion)
1850 n += 1 + l + sovGenerated(uint64(l))
1851 if len(m.APIResources) > 0 {
1852 for _, e := range m.APIResources {
1853 l = e.Size()
1854 n += 1 + l + sovGenerated(uint64(l))
1855 }
1856 }
1857 return n
1858}
1859
1860func (m *APIVersions) Size() (n int) {
1861 var l int
1862 _ = l
1863 if len(m.Versions) > 0 {
1864 for _, s := range m.Versions {
1865 l = len(s)
1866 n += 1 + l + sovGenerated(uint64(l))
1867 }
1868 }
1869 if len(m.ServerAddressByClientCIDRs) > 0 {
1870 for _, e := range m.ServerAddressByClientCIDRs {
1871 l = e.Size()
1872 n += 1 + l + sovGenerated(uint64(l))
1873 }
1874 }
1875 return n
1876}
1877
1878func (m *CreateOptions) Size() (n int) {
1879 var l int
1880 _ = l
1881 if len(m.DryRun) > 0 {
1882 for _, s := range m.DryRun {
1883 l = len(s)
1884 n += 1 + l + sovGenerated(uint64(l))
1885 }
1886 }
1887 n += 2
1888 return n
1889}
1890
1891func (m *DeleteOptions) Size() (n int) {
1892 var l int
1893 _ = l
1894 if m.GracePeriodSeconds != nil {
1895 n += 1 + sovGenerated(uint64(*m.GracePeriodSeconds))
1896 }
1897 if m.Preconditions != nil {
1898 l = m.Preconditions.Size()
1899 n += 1 + l + sovGenerated(uint64(l))
1900 }
1901 if m.OrphanDependents != nil {
1902 n += 2
1903 }
1904 if m.PropagationPolicy != nil {
1905 l = len(*m.PropagationPolicy)
1906 n += 1 + l + sovGenerated(uint64(l))
1907 }
1908 if len(m.DryRun) > 0 {
1909 for _, s := range m.DryRun {
1910 l = len(s)
1911 n += 1 + l + sovGenerated(uint64(l))
1912 }
1913 }
1914 return n
1915}
1916
1917func (m *Duration) Size() (n int) {
1918 var l int
1919 _ = l
1920 n += 1 + sovGenerated(uint64(m.Duration))
1921 return n
1922}
1923
1924func (m *ExportOptions) Size() (n int) {
1925 var l int
1926 _ = l
1927 n += 2
1928 n += 2
1929 return n
1930}
1931
1932func (m *GetOptions) Size() (n int) {
1933 var l int
1934 _ = l
1935 l = len(m.ResourceVersion)
1936 n += 1 + l + sovGenerated(uint64(l))
1937 n += 2
1938 return n
1939}
1940
1941func (m *GroupKind) Size() (n int) {
1942 var l int
1943 _ = l
1944 l = len(m.Group)
1945 n += 1 + l + sovGenerated(uint64(l))
1946 l = len(m.Kind)
1947 n += 1 + l + sovGenerated(uint64(l))
1948 return n
1949}
1950
1951func (m *GroupResource) Size() (n int) {
1952 var l int
1953 _ = l
1954 l = len(m.Group)
1955 n += 1 + l + sovGenerated(uint64(l))
1956 l = len(m.Resource)
1957 n += 1 + l + sovGenerated(uint64(l))
1958 return n
1959}
1960
1961func (m *GroupVersion) Size() (n int) {
1962 var l int
1963 _ = l
1964 l = len(m.Group)
1965 n += 1 + l + sovGenerated(uint64(l))
1966 l = len(m.Version)
1967 n += 1 + l + sovGenerated(uint64(l))
1968 return n
1969}
1970
1971func (m *GroupVersionForDiscovery) Size() (n int) {
1972 var l int
1973 _ = l
1974 l = len(m.GroupVersion)
1975 n += 1 + l + sovGenerated(uint64(l))
1976 l = len(m.Version)
1977 n += 1 + l + sovGenerated(uint64(l))
1978 return n
1979}
1980
1981func (m *GroupVersionKind) Size() (n int) {
1982 var l int
1983 _ = l
1984 l = len(m.Group)
1985 n += 1 + l + sovGenerated(uint64(l))
1986 l = len(m.Version)
1987 n += 1 + l + sovGenerated(uint64(l))
1988 l = len(m.Kind)
1989 n += 1 + l + sovGenerated(uint64(l))
1990 return n
1991}
1992
1993func (m *GroupVersionResource) Size() (n int) {
1994 var l int
1995 _ = l
1996 l = len(m.Group)
1997 n += 1 + l + sovGenerated(uint64(l))
1998 l = len(m.Version)
1999 n += 1 + l + sovGenerated(uint64(l))
2000 l = len(m.Resource)
2001 n += 1 + l + sovGenerated(uint64(l))
2002 return n
2003}
2004
2005func (m *Initializer) Size() (n int) {
2006 var l int
2007 _ = l
2008 l = len(m.Name)
2009 n += 1 + l + sovGenerated(uint64(l))
2010 return n
2011}
2012
2013func (m *Initializers) Size() (n int) {
2014 var l int
2015 _ = l
2016 if len(m.Pending) > 0 {
2017 for _, e := range m.Pending {
2018 l = e.Size()
2019 n += 1 + l + sovGenerated(uint64(l))
2020 }
2021 }
2022 if m.Result != nil {
2023 l = m.Result.Size()
2024 n += 1 + l + sovGenerated(uint64(l))
2025 }
2026 return n
2027}
2028
2029func (m *LabelSelector) Size() (n int) {
2030 var l int
2031 _ = l
2032 if len(m.MatchLabels) > 0 {
2033 for k, v := range m.MatchLabels {
2034 _ = k
2035 _ = v
2036 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2037 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2038 }
2039 }
2040 if len(m.MatchExpressions) > 0 {
2041 for _, e := range m.MatchExpressions {
2042 l = e.Size()
2043 n += 1 + l + sovGenerated(uint64(l))
2044 }
2045 }
2046 return n
2047}
2048
2049func (m *LabelSelectorRequirement) Size() (n int) {
2050 var l int
2051 _ = l
2052 l = len(m.Key)
2053 n += 1 + l + sovGenerated(uint64(l))
2054 l = len(m.Operator)
2055 n += 1 + l + sovGenerated(uint64(l))
2056 if len(m.Values) > 0 {
2057 for _, s := range m.Values {
2058 l = len(s)
2059 n += 1 + l + sovGenerated(uint64(l))
2060 }
2061 }
2062 return n
2063}
2064
2065func (m *List) Size() (n int) {
2066 var l int
2067 _ = l
2068 l = m.ListMeta.Size()
2069 n += 1 + l + sovGenerated(uint64(l))
2070 if len(m.Items) > 0 {
2071 for _, e := range m.Items {
2072 l = e.Size()
2073 n += 1 + l + sovGenerated(uint64(l))
2074 }
2075 }
2076 return n
2077}
2078
2079func (m *ListMeta) Size() (n int) {
2080 var l int
2081 _ = l
2082 l = len(m.SelfLink)
2083 n += 1 + l + sovGenerated(uint64(l))
2084 l = len(m.ResourceVersion)
2085 n += 1 + l + sovGenerated(uint64(l))
2086 l = len(m.Continue)
2087 n += 1 + l + sovGenerated(uint64(l))
2088 return n
2089}
2090
2091func (m *ListOptions) Size() (n int) {
2092 var l int
2093 _ = l
2094 l = len(m.LabelSelector)
2095 n += 1 + l + sovGenerated(uint64(l))
2096 l = len(m.FieldSelector)
2097 n += 1 + l + sovGenerated(uint64(l))
2098 n += 2
2099 l = len(m.ResourceVersion)
2100 n += 1 + l + sovGenerated(uint64(l))
2101 if m.TimeoutSeconds != nil {
2102 n += 1 + sovGenerated(uint64(*m.TimeoutSeconds))
2103 }
2104 n += 2
2105 n += 1 + sovGenerated(uint64(m.Limit))
2106 l = len(m.Continue)
2107 n += 1 + l + sovGenerated(uint64(l))
2108 return n
2109}
2110
2111func (m *ObjectMeta) Size() (n int) {
2112 var l int
2113 _ = l
2114 l = len(m.Name)
2115 n += 1 + l + sovGenerated(uint64(l))
2116 l = len(m.GenerateName)
2117 n += 1 + l + sovGenerated(uint64(l))
2118 l = len(m.Namespace)
2119 n += 1 + l + sovGenerated(uint64(l))
2120 l = len(m.SelfLink)
2121 n += 1 + l + sovGenerated(uint64(l))
2122 l = len(m.UID)
2123 n += 1 + l + sovGenerated(uint64(l))
2124 l = len(m.ResourceVersion)
2125 n += 1 + l + sovGenerated(uint64(l))
2126 n += 1 + sovGenerated(uint64(m.Generation))
2127 l = m.CreationTimestamp.Size()
2128 n += 1 + l + sovGenerated(uint64(l))
2129 if m.DeletionTimestamp != nil {
2130 l = m.DeletionTimestamp.Size()
2131 n += 1 + l + sovGenerated(uint64(l))
2132 }
2133 if m.DeletionGracePeriodSeconds != nil {
2134 n += 1 + sovGenerated(uint64(*m.DeletionGracePeriodSeconds))
2135 }
2136 if len(m.Labels) > 0 {
2137 for k, v := range m.Labels {
2138 _ = k
2139 _ = v
2140 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2141 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2142 }
2143 }
2144 if len(m.Annotations) > 0 {
2145 for k, v := range m.Annotations {
2146 _ = k
2147 _ = v
2148 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2149 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2150 }
2151 }
2152 if len(m.OwnerReferences) > 0 {
2153 for _, e := range m.OwnerReferences {
2154 l = e.Size()
2155 n += 1 + l + sovGenerated(uint64(l))
2156 }
2157 }
2158 if len(m.Finalizers) > 0 {
2159 for _, s := range m.Finalizers {
2160 l = len(s)
2161 n += 1 + l + sovGenerated(uint64(l))
2162 }
2163 }
2164 l = len(m.ClusterName)
2165 n += 1 + l + sovGenerated(uint64(l))
2166 if m.Initializers != nil {
2167 l = m.Initializers.Size()
2168 n += 2 + l + sovGenerated(uint64(l))
2169 }
2170 return n
2171}
2172
2173func (m *OwnerReference) Size() (n int) {
2174 var l int
2175 _ = l
2176 l = len(m.Kind)
2177 n += 1 + l + sovGenerated(uint64(l))
2178 l = len(m.Name)
2179 n += 1 + l + sovGenerated(uint64(l))
2180 l = len(m.UID)
2181 n += 1 + l + sovGenerated(uint64(l))
2182 l = len(m.APIVersion)
2183 n += 1 + l + sovGenerated(uint64(l))
2184 if m.Controller != nil {
2185 n += 2
2186 }
2187 if m.BlockOwnerDeletion != nil {
2188 n += 2
2189 }
2190 return n
2191}
2192
2193func (m *Patch) Size() (n int) {
2194 var l int
2195 _ = l
2196 return n
2197}
2198
2199func (m *Preconditions) Size() (n int) {
2200 var l int
2201 _ = l
2202 if m.UID != nil {
2203 l = len(*m.UID)
2204 n += 1 + l + sovGenerated(uint64(l))
2205 }
2206 return n
2207}
2208
2209func (m *RootPaths) Size() (n int) {
2210 var l int
2211 _ = l
2212 if len(m.Paths) > 0 {
2213 for _, s := range m.Paths {
2214 l = len(s)
2215 n += 1 + l + sovGenerated(uint64(l))
2216 }
2217 }
2218 return n
2219}
2220
2221func (m *ServerAddressByClientCIDR) Size() (n int) {
2222 var l int
2223 _ = l
2224 l = len(m.ClientCIDR)
2225 n += 1 + l + sovGenerated(uint64(l))
2226 l = len(m.ServerAddress)
2227 n += 1 + l + sovGenerated(uint64(l))
2228 return n
2229}
2230
2231func (m *Status) Size() (n int) {
2232 var l int
2233 _ = l
2234 l = m.ListMeta.Size()
2235 n += 1 + l + sovGenerated(uint64(l))
2236 l = len(m.Status)
2237 n += 1 + l + sovGenerated(uint64(l))
2238 l = len(m.Message)
2239 n += 1 + l + sovGenerated(uint64(l))
2240 l = len(m.Reason)
2241 n += 1 + l + sovGenerated(uint64(l))
2242 if m.Details != nil {
2243 l = m.Details.Size()
2244 n += 1 + l + sovGenerated(uint64(l))
2245 }
2246 n += 1 + sovGenerated(uint64(m.Code))
2247 return n
2248}
2249
2250func (m *StatusCause) Size() (n int) {
2251 var l int
2252 _ = l
2253 l = len(m.Type)
2254 n += 1 + l + sovGenerated(uint64(l))
2255 l = len(m.Message)
2256 n += 1 + l + sovGenerated(uint64(l))
2257 l = len(m.Field)
2258 n += 1 + l + sovGenerated(uint64(l))
2259 return n
2260}
2261
2262func (m *StatusDetails) Size() (n int) {
2263 var l int
2264 _ = l
2265 l = len(m.Name)
2266 n += 1 + l + sovGenerated(uint64(l))
2267 l = len(m.Group)
2268 n += 1 + l + sovGenerated(uint64(l))
2269 l = len(m.Kind)
2270 n += 1 + l + sovGenerated(uint64(l))
2271 if len(m.Causes) > 0 {
2272 for _, e := range m.Causes {
2273 l = e.Size()
2274 n += 1 + l + sovGenerated(uint64(l))
2275 }
2276 }
2277 n += 1 + sovGenerated(uint64(m.RetryAfterSeconds))
2278 l = len(m.UID)
2279 n += 1 + l + sovGenerated(uint64(l))
2280 return n
2281}
2282
2283func (m *Timestamp) Size() (n int) {
2284 var l int
2285 _ = l
2286 n += 1 + sovGenerated(uint64(m.Seconds))
2287 n += 1 + sovGenerated(uint64(m.Nanos))
2288 return n
2289}
2290
2291func (m *TypeMeta) Size() (n int) {
2292 var l int
2293 _ = l
2294 l = len(m.Kind)
2295 n += 1 + l + sovGenerated(uint64(l))
2296 l = len(m.APIVersion)
2297 n += 1 + l + sovGenerated(uint64(l))
2298 return n
2299}
2300
2301func (m *UpdateOptions) Size() (n int) {
2302 var l int
2303 _ = l
2304 if len(m.DryRun) > 0 {
2305 for _, s := range m.DryRun {
2306 l = len(s)
2307 n += 1 + l + sovGenerated(uint64(l))
2308 }
2309 }
2310 return n
2311}
2312
2313func (m Verbs) Size() (n int) {
2314 var l int
2315 _ = l
2316 if len(m) > 0 {
2317 for _, s := range m {
2318 l = len(s)
2319 n += 1 + l + sovGenerated(uint64(l))
2320 }
2321 }
2322 return n
2323}
2324
2325func (m *WatchEvent) Size() (n int) {
2326 var l int
2327 _ = l
2328 l = len(m.Type)
2329 n += 1 + l + sovGenerated(uint64(l))
2330 l = m.Object.Size()
2331 n += 1 + l + sovGenerated(uint64(l))
2332 return n
2333}
2334
2335func sovGenerated(x uint64) (n int) {
2336 for {
2337 n++
2338 x >>= 7
2339 if x == 0 {
2340 break
2341 }
2342 }
2343 return n
2344}
2345func sozGenerated(x uint64) (n int) {
2346 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2347}
2348func (this *APIGroup) String() string {
2349 if this == nil {
2350 return "nil"
2351 }
2352 s := strings.Join([]string{`&APIGroup{`,
2353 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2354 `Versions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Versions), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`,
2355 `PreferredVersion:` + strings.Replace(strings.Replace(this.PreferredVersion.String(), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`,
2356 `ServerAddressByClientCIDRs:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServerAddressByClientCIDRs), "ServerAddressByClientCIDR", "ServerAddressByClientCIDR", 1), `&`, ``, 1) + `,`,
2357 `}`,
2358 }, "")
2359 return s
2360}
2361func (this *APIGroupList) String() string {
2362 if this == nil {
2363 return "nil"
2364 }
2365 s := strings.Join([]string{`&APIGroupList{`,
2366 `Groups:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Groups), "APIGroup", "APIGroup", 1), `&`, ``, 1) + `,`,
2367 `}`,
2368 }, "")
2369 return s
2370}
2371func (this *APIResource) String() string {
2372 if this == nil {
2373 return "nil"
2374 }
2375 s := strings.Join([]string{`&APIResource{`,
2376 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2377 `Namespaced:` + fmt.Sprintf("%v", this.Namespaced) + `,`,
2378 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2379 `Verbs:` + strings.Replace(fmt.Sprintf("%v", this.Verbs), "Verbs", "Verbs", 1) + `,`,
2380 `ShortNames:` + fmt.Sprintf("%v", this.ShortNames) + `,`,
2381 `SingularName:` + fmt.Sprintf("%v", this.SingularName) + `,`,
2382 `Categories:` + fmt.Sprintf("%v", this.Categories) + `,`,
2383 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
2384 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
2385 `}`,
2386 }, "")
2387 return s
2388}
2389func (this *APIResourceList) String() string {
2390 if this == nil {
2391 return "nil"
2392 }
2393 s := strings.Join([]string{`&APIResourceList{`,
2394 `GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`,
2395 `APIResources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.APIResources), "APIResource", "APIResource", 1), `&`, ``, 1) + `,`,
2396 `}`,
2397 }, "")
2398 return s
2399}
2400func (this *CreateOptions) String() string {
2401 if this == nil {
2402 return "nil"
2403 }
2404 s := strings.Join([]string{`&CreateOptions{`,
2405 `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
2406 `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`,
2407 `}`,
2408 }, "")
2409 return s
2410}
2411func (this *DeleteOptions) String() string {
2412 if this == nil {
2413 return "nil"
2414 }
2415 s := strings.Join([]string{`&DeleteOptions{`,
2416 `GracePeriodSeconds:` + valueToStringGenerated(this.GracePeriodSeconds) + `,`,
2417 `Preconditions:` + strings.Replace(fmt.Sprintf("%v", this.Preconditions), "Preconditions", "Preconditions", 1) + `,`,
2418 `OrphanDependents:` + valueToStringGenerated(this.OrphanDependents) + `,`,
2419 `PropagationPolicy:` + valueToStringGenerated(this.PropagationPolicy) + `,`,
2420 `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
2421 `}`,
2422 }, "")
2423 return s
2424}
2425func (this *Duration) String() string {
2426 if this == nil {
2427 return "nil"
2428 }
2429 s := strings.Join([]string{`&Duration{`,
2430 `Duration:` + fmt.Sprintf("%v", this.Duration) + `,`,
2431 `}`,
2432 }, "")
2433 return s
2434}
2435func (this *ExportOptions) String() string {
2436 if this == nil {
2437 return "nil"
2438 }
2439 s := strings.Join([]string{`&ExportOptions{`,
2440 `Export:` + fmt.Sprintf("%v", this.Export) + `,`,
2441 `Exact:` + fmt.Sprintf("%v", this.Exact) + `,`,
2442 `}`,
2443 }, "")
2444 return s
2445}
2446func (this *GetOptions) String() string {
2447 if this == nil {
2448 return "nil"
2449 }
2450 s := strings.Join([]string{`&GetOptions{`,
2451 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2452 `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`,
2453 `}`,
2454 }, "")
2455 return s
2456}
2457func (this *GroupVersionForDiscovery) String() string {
2458 if this == nil {
2459 return "nil"
2460 }
2461 s := strings.Join([]string{`&GroupVersionForDiscovery{`,
2462 `GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`,
2463 `Version:` + fmt.Sprintf("%v", this.Version) + `,`,
2464 `}`,
2465 }, "")
2466 return s
2467}
2468func (this *Initializer) String() string {
2469 if this == nil {
2470 return "nil"
2471 }
2472 s := strings.Join([]string{`&Initializer{`,
2473 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2474 `}`,
2475 }, "")
2476 return s
2477}
2478func (this *Initializers) String() string {
2479 if this == nil {
2480 return "nil"
2481 }
2482 s := strings.Join([]string{`&Initializers{`,
2483 `Pending:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Pending), "Initializer", "Initializer", 1), `&`, ``, 1) + `,`,
2484 `Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Status", "Status", 1) + `,`,
2485 `}`,
2486 }, "")
2487 return s
2488}
2489func (this *LabelSelector) String() string {
2490 if this == nil {
2491 return "nil"
2492 }
2493 keysForMatchLabels := make([]string, 0, len(this.MatchLabels))
2494 for k := range this.MatchLabels {
2495 keysForMatchLabels = append(keysForMatchLabels, k)
2496 }
2497 github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels)
2498 mapStringForMatchLabels := "map[string]string{"
2499 for _, k := range keysForMatchLabels {
2500 mapStringForMatchLabels += fmt.Sprintf("%v: %v,", k, this.MatchLabels[k])
2501 }
2502 mapStringForMatchLabels += "}"
2503 s := strings.Join([]string{`&LabelSelector{`,
2504 `MatchLabels:` + mapStringForMatchLabels + `,`,
2505 `MatchExpressions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.MatchExpressions), "LabelSelectorRequirement", "LabelSelectorRequirement", 1), `&`, ``, 1) + `,`,
2506 `}`,
2507 }, "")
2508 return s
2509}
2510func (this *LabelSelectorRequirement) String() string {
2511 if this == nil {
2512 return "nil"
2513 }
2514 s := strings.Join([]string{`&LabelSelectorRequirement{`,
2515 `Key:` + fmt.Sprintf("%v", this.Key) + `,`,
2516 `Operator:` + fmt.Sprintf("%v", this.Operator) + `,`,
2517 `Values:` + fmt.Sprintf("%v", this.Values) + `,`,
2518 `}`,
2519 }, "")
2520 return s
2521}
2522func (this *List) String() string {
2523 if this == nil {
2524 return "nil"
2525 }
2526 s := strings.Join([]string{`&List{`,
2527 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
2528 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2529 `}`,
2530 }, "")
2531 return s
2532}
2533func (this *ListMeta) String() string {
2534 if this == nil {
2535 return "nil"
2536 }
2537 s := strings.Join([]string{`&ListMeta{`,
2538 `SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`,
2539 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2540 `Continue:` + fmt.Sprintf("%v", this.Continue) + `,`,
2541 `}`,
2542 }, "")
2543 return s
2544}
2545func (this *ListOptions) String() string {
2546 if this == nil {
2547 return "nil"
2548 }
2549 s := strings.Join([]string{`&ListOptions{`,
2550 `LabelSelector:` + fmt.Sprintf("%v", this.LabelSelector) + `,`,
2551 `FieldSelector:` + fmt.Sprintf("%v", this.FieldSelector) + `,`,
2552 `Watch:` + fmt.Sprintf("%v", this.Watch) + `,`,
2553 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2554 `TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`,
2555 `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`,
2556 `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
2557 `Continue:` + fmt.Sprintf("%v", this.Continue) + `,`,
2558 `}`,
2559 }, "")
2560 return s
2561}
2562func (this *ObjectMeta) String() string {
2563 if this == nil {
2564 return "nil"
2565 }
2566 keysForLabels := make([]string, 0, len(this.Labels))
2567 for k := range this.Labels {
2568 keysForLabels = append(keysForLabels, k)
2569 }
2570 github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
2571 mapStringForLabels := "map[string]string{"
2572 for _, k := range keysForLabels {
2573 mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
2574 }
2575 mapStringForLabels += "}"
2576 keysForAnnotations := make([]string, 0, len(this.Annotations))
2577 for k := range this.Annotations {
2578 keysForAnnotations = append(keysForAnnotations, k)
2579 }
2580 github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
2581 mapStringForAnnotations := "map[string]string{"
2582 for _, k := range keysForAnnotations {
2583 mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
2584 }
2585 mapStringForAnnotations += "}"
2586 s := strings.Join([]string{`&ObjectMeta{`,
2587 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2588 `GenerateName:` + fmt.Sprintf("%v", this.GenerateName) + `,`,
2589 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
2590 `SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`,
2591 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2592 `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`,
2593 `Generation:` + fmt.Sprintf("%v", this.Generation) + `,`,
2594 `CreationTimestamp:` + strings.Replace(strings.Replace(this.CreationTimestamp.String(), "Time", "Time", 1), `&`, ``, 1) + `,`,
2595 `DeletionTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.DeletionTimestamp), "Time", "Time", 1) + `,`,
2596 `DeletionGracePeriodSeconds:` + valueToStringGenerated(this.DeletionGracePeriodSeconds) + `,`,
2597 `Labels:` + mapStringForLabels + `,`,
2598 `Annotations:` + mapStringForAnnotations + `,`,
2599 `OwnerReferences:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OwnerReferences), "OwnerReference", "OwnerReference", 1), `&`, ``, 1) + `,`,
2600 `Finalizers:` + fmt.Sprintf("%v", this.Finalizers) + `,`,
2601 `ClusterName:` + fmt.Sprintf("%v", this.ClusterName) + `,`,
2602 `Initializers:` + strings.Replace(fmt.Sprintf("%v", this.Initializers), "Initializers", "Initializers", 1) + `,`,
2603 `}`,
2604 }, "")
2605 return s
2606}
2607func (this *OwnerReference) String() string {
2608 if this == nil {
2609 return "nil"
2610 }
2611 s := strings.Join([]string{`&OwnerReference{`,
2612 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2613 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2614 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2615 `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
2616 `Controller:` + valueToStringGenerated(this.Controller) + `,`,
2617 `BlockOwnerDeletion:` + valueToStringGenerated(this.BlockOwnerDeletion) + `,`,
2618 `}`,
2619 }, "")
2620 return s
2621}
2622func (this *Patch) String() string {
2623 if this == nil {
2624 return "nil"
2625 }
2626 s := strings.Join([]string{`&Patch{`,
2627 `}`,
2628 }, "")
2629 return s
2630}
2631func (this *Preconditions) String() string {
2632 if this == nil {
2633 return "nil"
2634 }
2635 s := strings.Join([]string{`&Preconditions{`,
2636 `UID:` + valueToStringGenerated(this.UID) + `,`,
2637 `}`,
2638 }, "")
2639 return s
2640}
2641func (this *RootPaths) String() string {
2642 if this == nil {
2643 return "nil"
2644 }
2645 s := strings.Join([]string{`&RootPaths{`,
2646 `Paths:` + fmt.Sprintf("%v", this.Paths) + `,`,
2647 `}`,
2648 }, "")
2649 return s
2650}
2651func (this *ServerAddressByClientCIDR) String() string {
2652 if this == nil {
2653 return "nil"
2654 }
2655 s := strings.Join([]string{`&ServerAddressByClientCIDR{`,
2656 `ClientCIDR:` + fmt.Sprintf("%v", this.ClientCIDR) + `,`,
2657 `ServerAddress:` + fmt.Sprintf("%v", this.ServerAddress) + `,`,
2658 `}`,
2659 }, "")
2660 return s
2661}
2662func (this *Status) String() string {
2663 if this == nil {
2664 return "nil"
2665 }
2666 s := strings.Join([]string{`&Status{`,
2667 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`,
2668 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
2669 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2670 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
2671 `Details:` + strings.Replace(fmt.Sprintf("%v", this.Details), "StatusDetails", "StatusDetails", 1) + `,`,
2672 `Code:` + fmt.Sprintf("%v", this.Code) + `,`,
2673 `}`,
2674 }, "")
2675 return s
2676}
2677func (this *StatusCause) String() string {
2678 if this == nil {
2679 return "nil"
2680 }
2681 s := strings.Join([]string{`&StatusCause{`,
2682 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2683 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2684 `Field:` + fmt.Sprintf("%v", this.Field) + `,`,
2685 `}`,
2686 }, "")
2687 return s
2688}
2689func (this *StatusDetails) String() string {
2690 if this == nil {
2691 return "nil"
2692 }
2693 s := strings.Join([]string{`&StatusDetails{`,
2694 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2695 `Group:` + fmt.Sprintf("%v", this.Group) + `,`,
2696 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2697 `Causes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Causes), "StatusCause", "StatusCause", 1), `&`, ``, 1) + `,`,
2698 `RetryAfterSeconds:` + fmt.Sprintf("%v", this.RetryAfterSeconds) + `,`,
2699 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
2700 `}`,
2701 }, "")
2702 return s
2703}
2704func (this *Timestamp) String() string {
2705 if this == nil {
2706 return "nil"
2707 }
2708 s := strings.Join([]string{`&Timestamp{`,
2709 `Seconds:` + fmt.Sprintf("%v", this.Seconds) + `,`,
2710 `Nanos:` + fmt.Sprintf("%v", this.Nanos) + `,`,
2711 `}`,
2712 }, "")
2713 return s
2714}
2715func (this *TypeMeta) String() string {
2716 if this == nil {
2717 return "nil"
2718 }
2719 s := strings.Join([]string{`&TypeMeta{`,
2720 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
2721 `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
2722 `}`,
2723 }, "")
2724 return s
2725}
2726func (this *UpdateOptions) String() string {
2727 if this == nil {
2728 return "nil"
2729 }
2730 s := strings.Join([]string{`&UpdateOptions{`,
2731 `DryRun:` + fmt.Sprintf("%v", this.DryRun) + `,`,
2732 `}`,
2733 }, "")
2734 return s
2735}
2736func (this *WatchEvent) String() string {
2737 if this == nil {
2738 return "nil"
2739 }
2740 s := strings.Join([]string{`&WatchEvent{`,
2741 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
2742 `Object:` + strings.Replace(strings.Replace(this.Object.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
2743 `}`,
2744 }, "")
2745 return s
2746}
2747func valueToStringGenerated(v interface{}) string {
2748 rv := reflect.ValueOf(v)
2749 if rv.IsNil() {
2750 return "nil"
2751 }
2752 pv := reflect.Indirect(rv).Interface()
2753 return fmt.Sprintf("*%v", pv)
2754}
2755func (m *APIGroup) Unmarshal(dAtA []byte) error {
2756 l := len(dAtA)
2757 iNdEx := 0
2758 for iNdEx < l {
2759 preIndex := iNdEx
2760 var wire uint64
2761 for shift := uint(0); ; shift += 7 {
2762 if shift >= 64 {
2763 return ErrIntOverflowGenerated
2764 }
2765 if iNdEx >= l {
2766 return io.ErrUnexpectedEOF
2767 }
2768 b := dAtA[iNdEx]
2769 iNdEx++
2770 wire |= (uint64(b) & 0x7F) << shift
2771 if b < 0x80 {
2772 break
2773 }
2774 }
2775 fieldNum := int32(wire >> 3)
2776 wireType := int(wire & 0x7)
2777 if wireType == 4 {
2778 return fmt.Errorf("proto: APIGroup: wiretype end group for non-group")
2779 }
2780 if fieldNum <= 0 {
2781 return fmt.Errorf("proto: APIGroup: illegal tag %d (wire type %d)", fieldNum, wire)
2782 }
2783 switch fieldNum {
2784 case 1:
2785 if wireType != 2 {
2786 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
2787 }
2788 var stringLen uint64
2789 for shift := uint(0); ; shift += 7 {
2790 if shift >= 64 {
2791 return ErrIntOverflowGenerated
2792 }
2793 if iNdEx >= l {
2794 return io.ErrUnexpectedEOF
2795 }
2796 b := dAtA[iNdEx]
2797 iNdEx++
2798 stringLen |= (uint64(b) & 0x7F) << shift
2799 if b < 0x80 {
2800 break
2801 }
2802 }
2803 intStringLen := int(stringLen)
2804 if intStringLen < 0 {
2805 return ErrInvalidLengthGenerated
2806 }
2807 postIndex := iNdEx + intStringLen
2808 if postIndex > l {
2809 return io.ErrUnexpectedEOF
2810 }
2811 m.Name = string(dAtA[iNdEx:postIndex])
2812 iNdEx = postIndex
2813 case 2:
2814 if wireType != 2 {
2815 return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
2816 }
2817 var msglen int
2818 for shift := uint(0); ; shift += 7 {
2819 if shift >= 64 {
2820 return ErrIntOverflowGenerated
2821 }
2822 if iNdEx >= l {
2823 return io.ErrUnexpectedEOF
2824 }
2825 b := dAtA[iNdEx]
2826 iNdEx++
2827 msglen |= (int(b) & 0x7F) << shift
2828 if b < 0x80 {
2829 break
2830 }
2831 }
2832 if msglen < 0 {
2833 return ErrInvalidLengthGenerated
2834 }
2835 postIndex := iNdEx + msglen
2836 if postIndex > l {
2837 return io.ErrUnexpectedEOF
2838 }
2839 m.Versions = append(m.Versions, GroupVersionForDiscovery{})
2840 if err := m.Versions[len(m.Versions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2841 return err
2842 }
2843 iNdEx = postIndex
2844 case 3:
2845 if wireType != 2 {
2846 return fmt.Errorf("proto: wrong wireType = %d for field PreferredVersion", wireType)
2847 }
2848 var msglen int
2849 for shift := uint(0); ; shift += 7 {
2850 if shift >= 64 {
2851 return ErrIntOverflowGenerated
2852 }
2853 if iNdEx >= l {
2854 return io.ErrUnexpectedEOF
2855 }
2856 b := dAtA[iNdEx]
2857 iNdEx++
2858 msglen |= (int(b) & 0x7F) << shift
2859 if b < 0x80 {
2860 break
2861 }
2862 }
2863 if msglen < 0 {
2864 return ErrInvalidLengthGenerated
2865 }
2866 postIndex := iNdEx + msglen
2867 if postIndex > l {
2868 return io.ErrUnexpectedEOF
2869 }
2870 if err := m.PreferredVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2871 return err
2872 }
2873 iNdEx = postIndex
2874 case 4:
2875 if wireType != 2 {
2876 return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType)
2877 }
2878 var msglen int
2879 for shift := uint(0); ; shift += 7 {
2880 if shift >= 64 {
2881 return ErrIntOverflowGenerated
2882 }
2883 if iNdEx >= l {
2884 return io.ErrUnexpectedEOF
2885 }
2886 b := dAtA[iNdEx]
2887 iNdEx++
2888 msglen |= (int(b) & 0x7F) << shift
2889 if b < 0x80 {
2890 break
2891 }
2892 }
2893 if msglen < 0 {
2894 return ErrInvalidLengthGenerated
2895 }
2896 postIndex := iNdEx + msglen
2897 if postIndex > l {
2898 return io.ErrUnexpectedEOF
2899 }
2900 m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
2901 if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2902 return err
2903 }
2904 iNdEx = postIndex
2905 default:
2906 iNdEx = preIndex
2907 skippy, err := skipGenerated(dAtA[iNdEx:])
2908 if err != nil {
2909 return err
2910 }
2911 if skippy < 0 {
2912 return ErrInvalidLengthGenerated
2913 }
2914 if (iNdEx + skippy) > l {
2915 return io.ErrUnexpectedEOF
2916 }
2917 iNdEx += skippy
2918 }
2919 }
2920
2921 if iNdEx > l {
2922 return io.ErrUnexpectedEOF
2923 }
2924 return nil
2925}
2926func (m *APIGroupList) Unmarshal(dAtA []byte) error {
2927 l := len(dAtA)
2928 iNdEx := 0
2929 for iNdEx < l {
2930 preIndex := iNdEx
2931 var wire uint64
2932 for shift := uint(0); ; shift += 7 {
2933 if shift >= 64 {
2934 return ErrIntOverflowGenerated
2935 }
2936 if iNdEx >= l {
2937 return io.ErrUnexpectedEOF
2938 }
2939 b := dAtA[iNdEx]
2940 iNdEx++
2941 wire |= (uint64(b) & 0x7F) << shift
2942 if b < 0x80 {
2943 break
2944 }
2945 }
2946 fieldNum := int32(wire >> 3)
2947 wireType := int(wire & 0x7)
2948 if wireType == 4 {
2949 return fmt.Errorf("proto: APIGroupList: wiretype end group for non-group")
2950 }
2951 if fieldNum <= 0 {
2952 return fmt.Errorf("proto: APIGroupList: illegal tag %d (wire type %d)", fieldNum, wire)
2953 }
2954 switch fieldNum {
2955 case 1:
2956 if wireType != 2 {
2957 return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType)
2958 }
2959 var msglen int
2960 for shift := uint(0); ; shift += 7 {
2961 if shift >= 64 {
2962 return ErrIntOverflowGenerated
2963 }
2964 if iNdEx >= l {
2965 return io.ErrUnexpectedEOF
2966 }
2967 b := dAtA[iNdEx]
2968 iNdEx++
2969 msglen |= (int(b) & 0x7F) << shift
2970 if b < 0x80 {
2971 break
2972 }
2973 }
2974 if msglen < 0 {
2975 return ErrInvalidLengthGenerated
2976 }
2977 postIndex := iNdEx + msglen
2978 if postIndex > l {
2979 return io.ErrUnexpectedEOF
2980 }
2981 m.Groups = append(m.Groups, APIGroup{})
2982 if err := m.Groups[len(m.Groups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2983 return err
2984 }
2985 iNdEx = postIndex
2986 default:
2987 iNdEx = preIndex
2988 skippy, err := skipGenerated(dAtA[iNdEx:])
2989 if err != nil {
2990 return err
2991 }
2992 if skippy < 0 {
2993 return ErrInvalidLengthGenerated
2994 }
2995 if (iNdEx + skippy) > l {
2996 return io.ErrUnexpectedEOF
2997 }
2998 iNdEx += skippy
2999 }
3000 }
3001
3002 if iNdEx > l {
3003 return io.ErrUnexpectedEOF
3004 }
3005 return nil
3006}
3007func (m *APIResource) Unmarshal(dAtA []byte) error {
3008 l := len(dAtA)
3009 iNdEx := 0
3010 for iNdEx < l {
3011 preIndex := iNdEx
3012 var wire uint64
3013 for shift := uint(0); ; shift += 7 {
3014 if shift >= 64 {
3015 return ErrIntOverflowGenerated
3016 }
3017 if iNdEx >= l {
3018 return io.ErrUnexpectedEOF
3019 }
3020 b := dAtA[iNdEx]
3021 iNdEx++
3022 wire |= (uint64(b) & 0x7F) << shift
3023 if b < 0x80 {
3024 break
3025 }
3026 }
3027 fieldNum := int32(wire >> 3)
3028 wireType := int(wire & 0x7)
3029 if wireType == 4 {
3030 return fmt.Errorf("proto: APIResource: wiretype end group for non-group")
3031 }
3032 if fieldNum <= 0 {
3033 return fmt.Errorf("proto: APIResource: illegal tag %d (wire type %d)", fieldNum, wire)
3034 }
3035 switch fieldNum {
3036 case 1:
3037 if wireType != 2 {
3038 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
3039 }
3040 var stringLen uint64
3041 for shift := uint(0); ; shift += 7 {
3042 if shift >= 64 {
3043 return ErrIntOverflowGenerated
3044 }
3045 if iNdEx >= l {
3046 return io.ErrUnexpectedEOF
3047 }
3048 b := dAtA[iNdEx]
3049 iNdEx++
3050 stringLen |= (uint64(b) & 0x7F) << shift
3051 if b < 0x80 {
3052 break
3053 }
3054 }
3055 intStringLen := int(stringLen)
3056 if intStringLen < 0 {
3057 return ErrInvalidLengthGenerated
3058 }
3059 postIndex := iNdEx + intStringLen
3060 if postIndex > l {
3061 return io.ErrUnexpectedEOF
3062 }
3063 m.Name = string(dAtA[iNdEx:postIndex])
3064 iNdEx = postIndex
3065 case 2:
3066 if wireType != 0 {
3067 return fmt.Errorf("proto: wrong wireType = %d for field Namespaced", wireType)
3068 }
3069 var v int
3070 for shift := uint(0); ; shift += 7 {
3071 if shift >= 64 {
3072 return ErrIntOverflowGenerated
3073 }
3074 if iNdEx >= l {
3075 return io.ErrUnexpectedEOF
3076 }
3077 b := dAtA[iNdEx]
3078 iNdEx++
3079 v |= (int(b) & 0x7F) << shift
3080 if b < 0x80 {
3081 break
3082 }
3083 }
3084 m.Namespaced = bool(v != 0)
3085 case 3:
3086 if wireType != 2 {
3087 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
3088 }
3089 var stringLen uint64
3090 for shift := uint(0); ; shift += 7 {
3091 if shift >= 64 {
3092 return ErrIntOverflowGenerated
3093 }
3094 if iNdEx >= l {
3095 return io.ErrUnexpectedEOF
3096 }
3097 b := dAtA[iNdEx]
3098 iNdEx++
3099 stringLen |= (uint64(b) & 0x7F) << shift
3100 if b < 0x80 {
3101 break
3102 }
3103 }
3104 intStringLen := int(stringLen)
3105 if intStringLen < 0 {
3106 return ErrInvalidLengthGenerated
3107 }
3108 postIndex := iNdEx + intStringLen
3109 if postIndex > l {
3110 return io.ErrUnexpectedEOF
3111 }
3112 m.Kind = string(dAtA[iNdEx:postIndex])
3113 iNdEx = postIndex
3114 case 4:
3115 if wireType != 2 {
3116 return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType)
3117 }
3118 var msglen int
3119 for shift := uint(0); ; shift += 7 {
3120 if shift >= 64 {
3121 return ErrIntOverflowGenerated
3122 }
3123 if iNdEx >= l {
3124 return io.ErrUnexpectedEOF
3125 }
3126 b := dAtA[iNdEx]
3127 iNdEx++
3128 msglen |= (int(b) & 0x7F) << shift
3129 if b < 0x80 {
3130 break
3131 }
3132 }
3133 if msglen < 0 {
3134 return ErrInvalidLengthGenerated
3135 }
3136 postIndex := iNdEx + msglen
3137 if postIndex > l {
3138 return io.ErrUnexpectedEOF
3139 }
3140 if m.Verbs == nil {
3141 m.Verbs = Verbs{}
3142 }
3143 if err := m.Verbs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3144 return err
3145 }
3146 iNdEx = postIndex
3147 case 5:
3148 if wireType != 2 {
3149 return fmt.Errorf("proto: wrong wireType = %d for field ShortNames", wireType)
3150 }
3151 var stringLen uint64
3152 for shift := uint(0); ; shift += 7 {
3153 if shift >= 64 {
3154 return ErrIntOverflowGenerated
3155 }
3156 if iNdEx >= l {
3157 return io.ErrUnexpectedEOF
3158 }
3159 b := dAtA[iNdEx]
3160 iNdEx++
3161 stringLen |= (uint64(b) & 0x7F) << shift
3162 if b < 0x80 {
3163 break
3164 }
3165 }
3166 intStringLen := int(stringLen)
3167 if intStringLen < 0 {
3168 return ErrInvalidLengthGenerated
3169 }
3170 postIndex := iNdEx + intStringLen
3171 if postIndex > l {
3172 return io.ErrUnexpectedEOF
3173 }
3174 m.ShortNames = append(m.ShortNames, string(dAtA[iNdEx:postIndex]))
3175 iNdEx = postIndex
3176 case 6:
3177 if wireType != 2 {
3178 return fmt.Errorf("proto: wrong wireType = %d for field SingularName", wireType)
3179 }
3180 var stringLen uint64
3181 for shift := uint(0); ; shift += 7 {
3182 if shift >= 64 {
3183 return ErrIntOverflowGenerated
3184 }
3185 if iNdEx >= l {
3186 return io.ErrUnexpectedEOF
3187 }
3188 b := dAtA[iNdEx]
3189 iNdEx++
3190 stringLen |= (uint64(b) & 0x7F) << shift
3191 if b < 0x80 {
3192 break
3193 }
3194 }
3195 intStringLen := int(stringLen)
3196 if intStringLen < 0 {
3197 return ErrInvalidLengthGenerated
3198 }
3199 postIndex := iNdEx + intStringLen
3200 if postIndex > l {
3201 return io.ErrUnexpectedEOF
3202 }
3203 m.SingularName = string(dAtA[iNdEx:postIndex])
3204 iNdEx = postIndex
3205 case 7:
3206 if wireType != 2 {
3207 return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType)
3208 }
3209 var stringLen uint64
3210 for shift := uint(0); ; shift += 7 {
3211 if shift >= 64 {
3212 return ErrIntOverflowGenerated
3213 }
3214 if iNdEx >= l {
3215 return io.ErrUnexpectedEOF
3216 }
3217 b := dAtA[iNdEx]
3218 iNdEx++
3219 stringLen |= (uint64(b) & 0x7F) << shift
3220 if b < 0x80 {
3221 break
3222 }
3223 }
3224 intStringLen := int(stringLen)
3225 if intStringLen < 0 {
3226 return ErrInvalidLengthGenerated
3227 }
3228 postIndex := iNdEx + intStringLen
3229 if postIndex > l {
3230 return io.ErrUnexpectedEOF
3231 }
3232 m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex]))
3233 iNdEx = postIndex
3234 case 8:
3235 if wireType != 2 {
3236 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
3237 }
3238 var stringLen uint64
3239 for shift := uint(0); ; shift += 7 {
3240 if shift >= 64 {
3241 return ErrIntOverflowGenerated
3242 }
3243 if iNdEx >= l {
3244 return io.ErrUnexpectedEOF
3245 }
3246 b := dAtA[iNdEx]
3247 iNdEx++
3248 stringLen |= (uint64(b) & 0x7F) << shift
3249 if b < 0x80 {
3250 break
3251 }
3252 }
3253 intStringLen := int(stringLen)
3254 if intStringLen < 0 {
3255 return ErrInvalidLengthGenerated
3256 }
3257 postIndex := iNdEx + intStringLen
3258 if postIndex > l {
3259 return io.ErrUnexpectedEOF
3260 }
3261 m.Group = string(dAtA[iNdEx:postIndex])
3262 iNdEx = postIndex
3263 case 9:
3264 if wireType != 2 {
3265 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
3266 }
3267 var stringLen uint64
3268 for shift := uint(0); ; shift += 7 {
3269 if shift >= 64 {
3270 return ErrIntOverflowGenerated
3271 }
3272 if iNdEx >= l {
3273 return io.ErrUnexpectedEOF
3274 }
3275 b := dAtA[iNdEx]
3276 iNdEx++
3277 stringLen |= (uint64(b) & 0x7F) << shift
3278 if b < 0x80 {
3279 break
3280 }
3281 }
3282 intStringLen := int(stringLen)
3283 if intStringLen < 0 {
3284 return ErrInvalidLengthGenerated
3285 }
3286 postIndex := iNdEx + intStringLen
3287 if postIndex > l {
3288 return io.ErrUnexpectedEOF
3289 }
3290 m.Version = string(dAtA[iNdEx:postIndex])
3291 iNdEx = postIndex
3292 default:
3293 iNdEx = preIndex
3294 skippy, err := skipGenerated(dAtA[iNdEx:])
3295 if err != nil {
3296 return err
3297 }
3298 if skippy < 0 {
3299 return ErrInvalidLengthGenerated
3300 }
3301 if (iNdEx + skippy) > l {
3302 return io.ErrUnexpectedEOF
3303 }
3304 iNdEx += skippy
3305 }
3306 }
3307
3308 if iNdEx > l {
3309 return io.ErrUnexpectedEOF
3310 }
3311 return nil
3312}
3313func (m *APIResourceList) Unmarshal(dAtA []byte) error {
3314 l := len(dAtA)
3315 iNdEx := 0
3316 for iNdEx < l {
3317 preIndex := iNdEx
3318 var wire uint64
3319 for shift := uint(0); ; shift += 7 {
3320 if shift >= 64 {
3321 return ErrIntOverflowGenerated
3322 }
3323 if iNdEx >= l {
3324 return io.ErrUnexpectedEOF
3325 }
3326 b := dAtA[iNdEx]
3327 iNdEx++
3328 wire |= (uint64(b) & 0x7F) << shift
3329 if b < 0x80 {
3330 break
3331 }
3332 }
3333 fieldNum := int32(wire >> 3)
3334 wireType := int(wire & 0x7)
3335 if wireType == 4 {
3336 return fmt.Errorf("proto: APIResourceList: wiretype end group for non-group")
3337 }
3338 if fieldNum <= 0 {
3339 return fmt.Errorf("proto: APIResourceList: illegal tag %d (wire type %d)", fieldNum, wire)
3340 }
3341 switch fieldNum {
3342 case 1:
3343 if wireType != 2 {
3344 return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
3345 }
3346 var stringLen uint64
3347 for shift := uint(0); ; shift += 7 {
3348 if shift >= 64 {
3349 return ErrIntOverflowGenerated
3350 }
3351 if iNdEx >= l {
3352 return io.ErrUnexpectedEOF
3353 }
3354 b := dAtA[iNdEx]
3355 iNdEx++
3356 stringLen |= (uint64(b) & 0x7F) << shift
3357 if b < 0x80 {
3358 break
3359 }
3360 }
3361 intStringLen := int(stringLen)
3362 if intStringLen < 0 {
3363 return ErrInvalidLengthGenerated
3364 }
3365 postIndex := iNdEx + intStringLen
3366 if postIndex > l {
3367 return io.ErrUnexpectedEOF
3368 }
3369 m.GroupVersion = string(dAtA[iNdEx:postIndex])
3370 iNdEx = postIndex
3371 case 2:
3372 if wireType != 2 {
3373 return fmt.Errorf("proto: wrong wireType = %d for field APIResources", wireType)
3374 }
3375 var msglen int
3376 for shift := uint(0); ; shift += 7 {
3377 if shift >= 64 {
3378 return ErrIntOverflowGenerated
3379 }
3380 if iNdEx >= l {
3381 return io.ErrUnexpectedEOF
3382 }
3383 b := dAtA[iNdEx]
3384 iNdEx++
3385 msglen |= (int(b) & 0x7F) << shift
3386 if b < 0x80 {
3387 break
3388 }
3389 }
3390 if msglen < 0 {
3391 return ErrInvalidLengthGenerated
3392 }
3393 postIndex := iNdEx + msglen
3394 if postIndex > l {
3395 return io.ErrUnexpectedEOF
3396 }
3397 m.APIResources = append(m.APIResources, APIResource{})
3398 if err := m.APIResources[len(m.APIResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3399 return err
3400 }
3401 iNdEx = postIndex
3402 default:
3403 iNdEx = preIndex
3404 skippy, err := skipGenerated(dAtA[iNdEx:])
3405 if err != nil {
3406 return err
3407 }
3408 if skippy < 0 {
3409 return ErrInvalidLengthGenerated
3410 }
3411 if (iNdEx + skippy) > l {
3412 return io.ErrUnexpectedEOF
3413 }
3414 iNdEx += skippy
3415 }
3416 }
3417
3418 if iNdEx > l {
3419 return io.ErrUnexpectedEOF
3420 }
3421 return nil
3422}
3423func (m *APIVersions) Unmarshal(dAtA []byte) error {
3424 l := len(dAtA)
3425 iNdEx := 0
3426 for iNdEx < l {
3427 preIndex := iNdEx
3428 var wire uint64
3429 for shift := uint(0); ; shift += 7 {
3430 if shift >= 64 {
3431 return ErrIntOverflowGenerated
3432 }
3433 if iNdEx >= l {
3434 return io.ErrUnexpectedEOF
3435 }
3436 b := dAtA[iNdEx]
3437 iNdEx++
3438 wire |= (uint64(b) & 0x7F) << shift
3439 if b < 0x80 {
3440 break
3441 }
3442 }
3443 fieldNum := int32(wire >> 3)
3444 wireType := int(wire & 0x7)
3445 if wireType == 4 {
3446 return fmt.Errorf("proto: APIVersions: wiretype end group for non-group")
3447 }
3448 if fieldNum <= 0 {
3449 return fmt.Errorf("proto: APIVersions: illegal tag %d (wire type %d)", fieldNum, wire)
3450 }
3451 switch fieldNum {
3452 case 1:
3453 if wireType != 2 {
3454 return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType)
3455 }
3456 var stringLen uint64
3457 for shift := uint(0); ; shift += 7 {
3458 if shift >= 64 {
3459 return ErrIntOverflowGenerated
3460 }
3461 if iNdEx >= l {
3462 return io.ErrUnexpectedEOF
3463 }
3464 b := dAtA[iNdEx]
3465 iNdEx++
3466 stringLen |= (uint64(b) & 0x7F) << shift
3467 if b < 0x80 {
3468 break
3469 }
3470 }
3471 intStringLen := int(stringLen)
3472 if intStringLen < 0 {
3473 return ErrInvalidLengthGenerated
3474 }
3475 postIndex := iNdEx + intStringLen
3476 if postIndex > l {
3477 return io.ErrUnexpectedEOF
3478 }
3479 m.Versions = append(m.Versions, string(dAtA[iNdEx:postIndex]))
3480 iNdEx = postIndex
3481 case 2:
3482 if wireType != 2 {
3483 return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", 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 > l {
3505 return io.ErrUnexpectedEOF
3506 }
3507 m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{})
3508 if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3509 return err
3510 }
3511 iNdEx = postIndex
3512 default:
3513 iNdEx = preIndex
3514 skippy, err := skipGenerated(dAtA[iNdEx:])
3515 if err != nil {
3516 return err
3517 }
3518 if skippy < 0 {
3519 return ErrInvalidLengthGenerated
3520 }
3521 if (iNdEx + skippy) > l {
3522 return io.ErrUnexpectedEOF
3523 }
3524 iNdEx += skippy
3525 }
3526 }
3527
3528 if iNdEx > l {
3529 return io.ErrUnexpectedEOF
3530 }
3531 return nil
3532}
3533func (m *CreateOptions) Unmarshal(dAtA []byte) error {
3534 l := len(dAtA)
3535 iNdEx := 0
3536 for iNdEx < l {
3537 preIndex := iNdEx
3538 var wire uint64
3539 for shift := uint(0); ; shift += 7 {
3540 if shift >= 64 {
3541 return ErrIntOverflowGenerated
3542 }
3543 if iNdEx >= l {
3544 return io.ErrUnexpectedEOF
3545 }
3546 b := dAtA[iNdEx]
3547 iNdEx++
3548 wire |= (uint64(b) & 0x7F) << shift
3549 if b < 0x80 {
3550 break
3551 }
3552 }
3553 fieldNum := int32(wire >> 3)
3554 wireType := int(wire & 0x7)
3555 if wireType == 4 {
3556 return fmt.Errorf("proto: CreateOptions: wiretype end group for non-group")
3557 }
3558 if fieldNum <= 0 {
3559 return fmt.Errorf("proto: CreateOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3560 }
3561 switch fieldNum {
3562 case 1:
3563 if wireType != 2 {
3564 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
3565 }
3566 var stringLen uint64
3567 for shift := uint(0); ; shift += 7 {
3568 if shift >= 64 {
3569 return ErrIntOverflowGenerated
3570 }
3571 if iNdEx >= l {
3572 return io.ErrUnexpectedEOF
3573 }
3574 b := dAtA[iNdEx]
3575 iNdEx++
3576 stringLen |= (uint64(b) & 0x7F) << shift
3577 if b < 0x80 {
3578 break
3579 }
3580 }
3581 intStringLen := int(stringLen)
3582 if intStringLen < 0 {
3583 return ErrInvalidLengthGenerated
3584 }
3585 postIndex := iNdEx + intStringLen
3586 if postIndex > l {
3587 return io.ErrUnexpectedEOF
3588 }
3589 m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
3590 iNdEx = postIndex
3591 case 2:
3592 if wireType != 0 {
3593 return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", wireType)
3594 }
3595 var v int
3596 for shift := uint(0); ; shift += 7 {
3597 if shift >= 64 {
3598 return ErrIntOverflowGenerated
3599 }
3600 if iNdEx >= l {
3601 return io.ErrUnexpectedEOF
3602 }
3603 b := dAtA[iNdEx]
3604 iNdEx++
3605 v |= (int(b) & 0x7F) << shift
3606 if b < 0x80 {
3607 break
3608 }
3609 }
3610 m.IncludeUninitialized = bool(v != 0)
3611 default:
3612 iNdEx = preIndex
3613 skippy, err := skipGenerated(dAtA[iNdEx:])
3614 if err != nil {
3615 return err
3616 }
3617 if skippy < 0 {
3618 return ErrInvalidLengthGenerated
3619 }
3620 if (iNdEx + skippy) > l {
3621 return io.ErrUnexpectedEOF
3622 }
3623 iNdEx += skippy
3624 }
3625 }
3626
3627 if iNdEx > l {
3628 return io.ErrUnexpectedEOF
3629 }
3630 return nil
3631}
3632func (m *DeleteOptions) Unmarshal(dAtA []byte) error {
3633 l := len(dAtA)
3634 iNdEx := 0
3635 for iNdEx < l {
3636 preIndex := iNdEx
3637 var wire uint64
3638 for shift := uint(0); ; shift += 7 {
3639 if shift >= 64 {
3640 return ErrIntOverflowGenerated
3641 }
3642 if iNdEx >= l {
3643 return io.ErrUnexpectedEOF
3644 }
3645 b := dAtA[iNdEx]
3646 iNdEx++
3647 wire |= (uint64(b) & 0x7F) << shift
3648 if b < 0x80 {
3649 break
3650 }
3651 }
3652 fieldNum := int32(wire >> 3)
3653 wireType := int(wire & 0x7)
3654 if wireType == 4 {
3655 return fmt.Errorf("proto: DeleteOptions: wiretype end group for non-group")
3656 }
3657 if fieldNum <= 0 {
3658 return fmt.Errorf("proto: DeleteOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3659 }
3660 switch fieldNum {
3661 case 1:
3662 if wireType != 0 {
3663 return fmt.Errorf("proto: wrong wireType = %d for field GracePeriodSeconds", wireType)
3664 }
3665 var v int64
3666 for shift := uint(0); ; shift += 7 {
3667 if shift >= 64 {
3668 return ErrIntOverflowGenerated
3669 }
3670 if iNdEx >= l {
3671 return io.ErrUnexpectedEOF
3672 }
3673 b := dAtA[iNdEx]
3674 iNdEx++
3675 v |= (int64(b) & 0x7F) << shift
3676 if b < 0x80 {
3677 break
3678 }
3679 }
3680 m.GracePeriodSeconds = &v
3681 case 2:
3682 if wireType != 2 {
3683 return fmt.Errorf("proto: wrong wireType = %d for field Preconditions", wireType)
3684 }
3685 var msglen int
3686 for shift := uint(0); ; shift += 7 {
3687 if shift >= 64 {
3688 return ErrIntOverflowGenerated
3689 }
3690 if iNdEx >= l {
3691 return io.ErrUnexpectedEOF
3692 }
3693 b := dAtA[iNdEx]
3694 iNdEx++
3695 msglen |= (int(b) & 0x7F) << shift
3696 if b < 0x80 {
3697 break
3698 }
3699 }
3700 if msglen < 0 {
3701 return ErrInvalidLengthGenerated
3702 }
3703 postIndex := iNdEx + msglen
3704 if postIndex > l {
3705 return io.ErrUnexpectedEOF
3706 }
3707 if m.Preconditions == nil {
3708 m.Preconditions = &Preconditions{}
3709 }
3710 if err := m.Preconditions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3711 return err
3712 }
3713 iNdEx = postIndex
3714 case 3:
3715 if wireType != 0 {
3716 return fmt.Errorf("proto: wrong wireType = %d for field OrphanDependents", wireType)
3717 }
3718 var v int
3719 for shift := uint(0); ; shift += 7 {
3720 if shift >= 64 {
3721 return ErrIntOverflowGenerated
3722 }
3723 if iNdEx >= l {
3724 return io.ErrUnexpectedEOF
3725 }
3726 b := dAtA[iNdEx]
3727 iNdEx++
3728 v |= (int(b) & 0x7F) << shift
3729 if b < 0x80 {
3730 break
3731 }
3732 }
3733 b := bool(v != 0)
3734 m.OrphanDependents = &b
3735 case 4:
3736 if wireType != 2 {
3737 return fmt.Errorf("proto: wrong wireType = %d for field PropagationPolicy", wireType)
3738 }
3739 var stringLen uint64
3740 for shift := uint(0); ; shift += 7 {
3741 if shift >= 64 {
3742 return ErrIntOverflowGenerated
3743 }
3744 if iNdEx >= l {
3745 return io.ErrUnexpectedEOF
3746 }
3747 b := dAtA[iNdEx]
3748 iNdEx++
3749 stringLen |= (uint64(b) & 0x7F) << shift
3750 if b < 0x80 {
3751 break
3752 }
3753 }
3754 intStringLen := int(stringLen)
3755 if intStringLen < 0 {
3756 return ErrInvalidLengthGenerated
3757 }
3758 postIndex := iNdEx + intStringLen
3759 if postIndex > l {
3760 return io.ErrUnexpectedEOF
3761 }
3762 s := DeletionPropagation(dAtA[iNdEx:postIndex])
3763 m.PropagationPolicy = &s
3764 iNdEx = postIndex
3765 case 5:
3766 if wireType != 2 {
3767 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
3768 }
3769 var stringLen uint64
3770 for shift := uint(0); ; shift += 7 {
3771 if shift >= 64 {
3772 return ErrIntOverflowGenerated
3773 }
3774 if iNdEx >= l {
3775 return io.ErrUnexpectedEOF
3776 }
3777 b := dAtA[iNdEx]
3778 iNdEx++
3779 stringLen |= (uint64(b) & 0x7F) << shift
3780 if b < 0x80 {
3781 break
3782 }
3783 }
3784 intStringLen := int(stringLen)
3785 if intStringLen < 0 {
3786 return ErrInvalidLengthGenerated
3787 }
3788 postIndex := iNdEx + intStringLen
3789 if postIndex > l {
3790 return io.ErrUnexpectedEOF
3791 }
3792 m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
3793 iNdEx = postIndex
3794 default:
3795 iNdEx = preIndex
3796 skippy, err := skipGenerated(dAtA[iNdEx:])
3797 if err != nil {
3798 return err
3799 }
3800 if skippy < 0 {
3801 return ErrInvalidLengthGenerated
3802 }
3803 if (iNdEx + skippy) > l {
3804 return io.ErrUnexpectedEOF
3805 }
3806 iNdEx += skippy
3807 }
3808 }
3809
3810 if iNdEx > l {
3811 return io.ErrUnexpectedEOF
3812 }
3813 return nil
3814}
3815func (m *Duration) Unmarshal(dAtA []byte) error {
3816 l := len(dAtA)
3817 iNdEx := 0
3818 for iNdEx < l {
3819 preIndex := iNdEx
3820 var wire uint64
3821 for shift := uint(0); ; shift += 7 {
3822 if shift >= 64 {
3823 return ErrIntOverflowGenerated
3824 }
3825 if iNdEx >= l {
3826 return io.ErrUnexpectedEOF
3827 }
3828 b := dAtA[iNdEx]
3829 iNdEx++
3830 wire |= (uint64(b) & 0x7F) << shift
3831 if b < 0x80 {
3832 break
3833 }
3834 }
3835 fieldNum := int32(wire >> 3)
3836 wireType := int(wire & 0x7)
3837 if wireType == 4 {
3838 return fmt.Errorf("proto: Duration: wiretype end group for non-group")
3839 }
3840 if fieldNum <= 0 {
3841 return fmt.Errorf("proto: Duration: illegal tag %d (wire type %d)", fieldNum, wire)
3842 }
3843 switch fieldNum {
3844 case 1:
3845 if wireType != 0 {
3846 return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
3847 }
3848 m.Duration = 0
3849 for shift := uint(0); ; shift += 7 {
3850 if shift >= 64 {
3851 return ErrIntOverflowGenerated
3852 }
3853 if iNdEx >= l {
3854 return io.ErrUnexpectedEOF
3855 }
3856 b := dAtA[iNdEx]
3857 iNdEx++
3858 m.Duration |= (time.Duration(b) & 0x7F) << shift
3859 if b < 0x80 {
3860 break
3861 }
3862 }
3863 default:
3864 iNdEx = preIndex
3865 skippy, err := skipGenerated(dAtA[iNdEx:])
3866 if err != nil {
3867 return err
3868 }
3869 if skippy < 0 {
3870 return ErrInvalidLengthGenerated
3871 }
3872 if (iNdEx + skippy) > l {
3873 return io.ErrUnexpectedEOF
3874 }
3875 iNdEx += skippy
3876 }
3877 }
3878
3879 if iNdEx > l {
3880 return io.ErrUnexpectedEOF
3881 }
3882 return nil
3883}
3884func (m *ExportOptions) Unmarshal(dAtA []byte) error {
3885 l := len(dAtA)
3886 iNdEx := 0
3887 for iNdEx < l {
3888 preIndex := iNdEx
3889 var wire uint64
3890 for shift := uint(0); ; shift += 7 {
3891 if shift >= 64 {
3892 return ErrIntOverflowGenerated
3893 }
3894 if iNdEx >= l {
3895 return io.ErrUnexpectedEOF
3896 }
3897 b := dAtA[iNdEx]
3898 iNdEx++
3899 wire |= (uint64(b) & 0x7F) << shift
3900 if b < 0x80 {
3901 break
3902 }
3903 }
3904 fieldNum := int32(wire >> 3)
3905 wireType := int(wire & 0x7)
3906 if wireType == 4 {
3907 return fmt.Errorf("proto: ExportOptions: wiretype end group for non-group")
3908 }
3909 if fieldNum <= 0 {
3910 return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire)
3911 }
3912 switch fieldNum {
3913 case 1:
3914 if wireType != 0 {
3915 return fmt.Errorf("proto: wrong wireType = %d for field Export", wireType)
3916 }
3917 var v int
3918 for shift := uint(0); ; shift += 7 {
3919 if shift >= 64 {
3920 return ErrIntOverflowGenerated
3921 }
3922 if iNdEx >= l {
3923 return io.ErrUnexpectedEOF
3924 }
3925 b := dAtA[iNdEx]
3926 iNdEx++
3927 v |= (int(b) & 0x7F) << shift
3928 if b < 0x80 {
3929 break
3930 }
3931 }
3932 m.Export = bool(v != 0)
3933 case 2:
3934 if wireType != 0 {
3935 return fmt.Errorf("proto: wrong wireType = %d for field Exact", wireType)
3936 }
3937 var v int
3938 for shift := uint(0); ; shift += 7 {
3939 if shift >= 64 {
3940 return ErrIntOverflowGenerated
3941 }
3942 if iNdEx >= l {
3943 return io.ErrUnexpectedEOF
3944 }
3945 b := dAtA[iNdEx]
3946 iNdEx++
3947 v |= (int(b) & 0x7F) << shift
3948 if b < 0x80 {
3949 break
3950 }
3951 }
3952 m.Exact = bool(v != 0)
3953 default:
3954 iNdEx = preIndex
3955 skippy, err := skipGenerated(dAtA[iNdEx:])
3956 if err != nil {
3957 return err
3958 }
3959 if skippy < 0 {
3960 return ErrInvalidLengthGenerated
3961 }
3962 if (iNdEx + skippy) > l {
3963 return io.ErrUnexpectedEOF
3964 }
3965 iNdEx += skippy
3966 }
3967 }
3968
3969 if iNdEx > l {
3970 return io.ErrUnexpectedEOF
3971 }
3972 return nil
3973}
3974func (m *GetOptions) Unmarshal(dAtA []byte) error {
3975 l := len(dAtA)
3976 iNdEx := 0
3977 for iNdEx < l {
3978 preIndex := iNdEx
3979 var wire uint64
3980 for shift := uint(0); ; shift += 7 {
3981 if shift >= 64 {
3982 return ErrIntOverflowGenerated
3983 }
3984 if iNdEx >= l {
3985 return io.ErrUnexpectedEOF
3986 }
3987 b := dAtA[iNdEx]
3988 iNdEx++
3989 wire |= (uint64(b) & 0x7F) << shift
3990 if b < 0x80 {
3991 break
3992 }
3993 }
3994 fieldNum := int32(wire >> 3)
3995 wireType := int(wire & 0x7)
3996 if wireType == 4 {
3997 return fmt.Errorf("proto: GetOptions: wiretype end group for non-group")
3998 }
3999 if fieldNum <= 0 {
4000 return fmt.Errorf("proto: GetOptions: illegal tag %d (wire type %d)", fieldNum, wire)
4001 }
4002 switch fieldNum {
4003 case 1:
4004 if wireType != 2 {
4005 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
4006 }
4007 var stringLen uint64
4008 for shift := uint(0); ; shift += 7 {
4009 if shift >= 64 {
4010 return ErrIntOverflowGenerated
4011 }
4012 if iNdEx >= l {
4013 return io.ErrUnexpectedEOF
4014 }
4015 b := dAtA[iNdEx]
4016 iNdEx++
4017 stringLen |= (uint64(b) & 0x7F) << shift
4018 if b < 0x80 {
4019 break
4020 }
4021 }
4022 intStringLen := int(stringLen)
4023 if intStringLen < 0 {
4024 return ErrInvalidLengthGenerated
4025 }
4026 postIndex := iNdEx + intStringLen
4027 if postIndex > l {
4028 return io.ErrUnexpectedEOF
4029 }
4030 m.ResourceVersion = string(dAtA[iNdEx:postIndex])
4031 iNdEx = postIndex
4032 case 2:
4033 if wireType != 0 {
4034 return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", wireType)
4035 }
4036 var v int
4037 for shift := uint(0); ; shift += 7 {
4038 if shift >= 64 {
4039 return ErrIntOverflowGenerated
4040 }
4041 if iNdEx >= l {
4042 return io.ErrUnexpectedEOF
4043 }
4044 b := dAtA[iNdEx]
4045 iNdEx++
4046 v |= (int(b) & 0x7F) << shift
4047 if b < 0x80 {
4048 break
4049 }
4050 }
4051 m.IncludeUninitialized = bool(v != 0)
4052 default:
4053 iNdEx = preIndex
4054 skippy, err := skipGenerated(dAtA[iNdEx:])
4055 if err != nil {
4056 return err
4057 }
4058 if skippy < 0 {
4059 return ErrInvalidLengthGenerated
4060 }
4061 if (iNdEx + skippy) > l {
4062 return io.ErrUnexpectedEOF
4063 }
4064 iNdEx += skippy
4065 }
4066 }
4067
4068 if iNdEx > l {
4069 return io.ErrUnexpectedEOF
4070 }
4071 return nil
4072}
4073func (m *GroupKind) Unmarshal(dAtA []byte) error {
4074 l := len(dAtA)
4075 iNdEx := 0
4076 for iNdEx < l {
4077 preIndex := iNdEx
4078 var wire uint64
4079 for shift := uint(0); ; shift += 7 {
4080 if shift >= 64 {
4081 return ErrIntOverflowGenerated
4082 }
4083 if iNdEx >= l {
4084 return io.ErrUnexpectedEOF
4085 }
4086 b := dAtA[iNdEx]
4087 iNdEx++
4088 wire |= (uint64(b) & 0x7F) << shift
4089 if b < 0x80 {
4090 break
4091 }
4092 }
4093 fieldNum := int32(wire >> 3)
4094 wireType := int(wire & 0x7)
4095 if wireType == 4 {
4096 return fmt.Errorf("proto: GroupKind: wiretype end group for non-group")
4097 }
4098 if fieldNum <= 0 {
4099 return fmt.Errorf("proto: GroupKind: illegal tag %d (wire type %d)", fieldNum, wire)
4100 }
4101 switch fieldNum {
4102 case 1:
4103 if wireType != 2 {
4104 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4105 }
4106 var stringLen uint64
4107 for shift := uint(0); ; shift += 7 {
4108 if shift >= 64 {
4109 return ErrIntOverflowGenerated
4110 }
4111 if iNdEx >= l {
4112 return io.ErrUnexpectedEOF
4113 }
4114 b := dAtA[iNdEx]
4115 iNdEx++
4116 stringLen |= (uint64(b) & 0x7F) << shift
4117 if b < 0x80 {
4118 break
4119 }
4120 }
4121 intStringLen := int(stringLen)
4122 if intStringLen < 0 {
4123 return ErrInvalidLengthGenerated
4124 }
4125 postIndex := iNdEx + intStringLen
4126 if postIndex > l {
4127 return io.ErrUnexpectedEOF
4128 }
4129 m.Group = string(dAtA[iNdEx:postIndex])
4130 iNdEx = postIndex
4131 case 2:
4132 if wireType != 2 {
4133 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
4134 }
4135 var stringLen uint64
4136 for shift := uint(0); ; shift += 7 {
4137 if shift >= 64 {
4138 return ErrIntOverflowGenerated
4139 }
4140 if iNdEx >= l {
4141 return io.ErrUnexpectedEOF
4142 }
4143 b := dAtA[iNdEx]
4144 iNdEx++
4145 stringLen |= (uint64(b) & 0x7F) << shift
4146 if b < 0x80 {
4147 break
4148 }
4149 }
4150 intStringLen := int(stringLen)
4151 if intStringLen < 0 {
4152 return ErrInvalidLengthGenerated
4153 }
4154 postIndex := iNdEx + intStringLen
4155 if postIndex > l {
4156 return io.ErrUnexpectedEOF
4157 }
4158 m.Kind = string(dAtA[iNdEx:postIndex])
4159 iNdEx = postIndex
4160 default:
4161 iNdEx = preIndex
4162 skippy, err := skipGenerated(dAtA[iNdEx:])
4163 if err != nil {
4164 return err
4165 }
4166 if skippy < 0 {
4167 return ErrInvalidLengthGenerated
4168 }
4169 if (iNdEx + skippy) > l {
4170 return io.ErrUnexpectedEOF
4171 }
4172 iNdEx += skippy
4173 }
4174 }
4175
4176 if iNdEx > l {
4177 return io.ErrUnexpectedEOF
4178 }
4179 return nil
4180}
4181func (m *GroupResource) Unmarshal(dAtA []byte) error {
4182 l := len(dAtA)
4183 iNdEx := 0
4184 for iNdEx < l {
4185 preIndex := iNdEx
4186 var wire uint64
4187 for shift := uint(0); ; shift += 7 {
4188 if shift >= 64 {
4189 return ErrIntOverflowGenerated
4190 }
4191 if iNdEx >= l {
4192 return io.ErrUnexpectedEOF
4193 }
4194 b := dAtA[iNdEx]
4195 iNdEx++
4196 wire |= (uint64(b) & 0x7F) << shift
4197 if b < 0x80 {
4198 break
4199 }
4200 }
4201 fieldNum := int32(wire >> 3)
4202 wireType := int(wire & 0x7)
4203 if wireType == 4 {
4204 return fmt.Errorf("proto: GroupResource: wiretype end group for non-group")
4205 }
4206 if fieldNum <= 0 {
4207 return fmt.Errorf("proto: GroupResource: illegal tag %d (wire type %d)", fieldNum, wire)
4208 }
4209 switch fieldNum {
4210 case 1:
4211 if wireType != 2 {
4212 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4213 }
4214 var stringLen uint64
4215 for shift := uint(0); ; shift += 7 {
4216 if shift >= 64 {
4217 return ErrIntOverflowGenerated
4218 }
4219 if iNdEx >= l {
4220 return io.ErrUnexpectedEOF
4221 }
4222 b := dAtA[iNdEx]
4223 iNdEx++
4224 stringLen |= (uint64(b) & 0x7F) << shift
4225 if b < 0x80 {
4226 break
4227 }
4228 }
4229 intStringLen := int(stringLen)
4230 if intStringLen < 0 {
4231 return ErrInvalidLengthGenerated
4232 }
4233 postIndex := iNdEx + intStringLen
4234 if postIndex > l {
4235 return io.ErrUnexpectedEOF
4236 }
4237 m.Group = string(dAtA[iNdEx:postIndex])
4238 iNdEx = postIndex
4239 case 2:
4240 if wireType != 2 {
4241 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
4242 }
4243 var stringLen uint64
4244 for shift := uint(0); ; shift += 7 {
4245 if shift >= 64 {
4246 return ErrIntOverflowGenerated
4247 }
4248 if iNdEx >= l {
4249 return io.ErrUnexpectedEOF
4250 }
4251 b := dAtA[iNdEx]
4252 iNdEx++
4253 stringLen |= (uint64(b) & 0x7F) << shift
4254 if b < 0x80 {
4255 break
4256 }
4257 }
4258 intStringLen := int(stringLen)
4259 if intStringLen < 0 {
4260 return ErrInvalidLengthGenerated
4261 }
4262 postIndex := iNdEx + intStringLen
4263 if postIndex > l {
4264 return io.ErrUnexpectedEOF
4265 }
4266 m.Resource = string(dAtA[iNdEx:postIndex])
4267 iNdEx = postIndex
4268 default:
4269 iNdEx = preIndex
4270 skippy, err := skipGenerated(dAtA[iNdEx:])
4271 if err != nil {
4272 return err
4273 }
4274 if skippy < 0 {
4275 return ErrInvalidLengthGenerated
4276 }
4277 if (iNdEx + skippy) > l {
4278 return io.ErrUnexpectedEOF
4279 }
4280 iNdEx += skippy
4281 }
4282 }
4283
4284 if iNdEx > l {
4285 return io.ErrUnexpectedEOF
4286 }
4287 return nil
4288}
4289func (m *GroupVersion) Unmarshal(dAtA []byte) error {
4290 l := len(dAtA)
4291 iNdEx := 0
4292 for iNdEx < l {
4293 preIndex := iNdEx
4294 var wire uint64
4295 for shift := uint(0); ; shift += 7 {
4296 if shift >= 64 {
4297 return ErrIntOverflowGenerated
4298 }
4299 if iNdEx >= l {
4300 return io.ErrUnexpectedEOF
4301 }
4302 b := dAtA[iNdEx]
4303 iNdEx++
4304 wire |= (uint64(b) & 0x7F) << shift
4305 if b < 0x80 {
4306 break
4307 }
4308 }
4309 fieldNum := int32(wire >> 3)
4310 wireType := int(wire & 0x7)
4311 if wireType == 4 {
4312 return fmt.Errorf("proto: GroupVersion: wiretype end group for non-group")
4313 }
4314 if fieldNum <= 0 {
4315 return fmt.Errorf("proto: GroupVersion: illegal tag %d (wire type %d)", fieldNum, wire)
4316 }
4317 switch fieldNum {
4318 case 1:
4319 if wireType != 2 {
4320 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4321 }
4322 var stringLen uint64
4323 for shift := uint(0); ; shift += 7 {
4324 if shift >= 64 {
4325 return ErrIntOverflowGenerated
4326 }
4327 if iNdEx >= l {
4328 return io.ErrUnexpectedEOF
4329 }
4330 b := dAtA[iNdEx]
4331 iNdEx++
4332 stringLen |= (uint64(b) & 0x7F) << shift
4333 if b < 0x80 {
4334 break
4335 }
4336 }
4337 intStringLen := int(stringLen)
4338 if intStringLen < 0 {
4339 return ErrInvalidLengthGenerated
4340 }
4341 postIndex := iNdEx + intStringLen
4342 if postIndex > l {
4343 return io.ErrUnexpectedEOF
4344 }
4345 m.Group = string(dAtA[iNdEx:postIndex])
4346 iNdEx = postIndex
4347 case 2:
4348 if wireType != 2 {
4349 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4350 }
4351 var stringLen uint64
4352 for shift := uint(0); ; shift += 7 {
4353 if shift >= 64 {
4354 return ErrIntOverflowGenerated
4355 }
4356 if iNdEx >= l {
4357 return io.ErrUnexpectedEOF
4358 }
4359 b := dAtA[iNdEx]
4360 iNdEx++
4361 stringLen |= (uint64(b) & 0x7F) << shift
4362 if b < 0x80 {
4363 break
4364 }
4365 }
4366 intStringLen := int(stringLen)
4367 if intStringLen < 0 {
4368 return ErrInvalidLengthGenerated
4369 }
4370 postIndex := iNdEx + intStringLen
4371 if postIndex > l {
4372 return io.ErrUnexpectedEOF
4373 }
4374 m.Version = string(dAtA[iNdEx:postIndex])
4375 iNdEx = postIndex
4376 default:
4377 iNdEx = preIndex
4378 skippy, err := skipGenerated(dAtA[iNdEx:])
4379 if err != nil {
4380 return err
4381 }
4382 if skippy < 0 {
4383 return ErrInvalidLengthGenerated
4384 }
4385 if (iNdEx + skippy) > l {
4386 return io.ErrUnexpectedEOF
4387 }
4388 iNdEx += skippy
4389 }
4390 }
4391
4392 if iNdEx > l {
4393 return io.ErrUnexpectedEOF
4394 }
4395 return nil
4396}
4397func (m *GroupVersionForDiscovery) Unmarshal(dAtA []byte) error {
4398 l := len(dAtA)
4399 iNdEx := 0
4400 for iNdEx < l {
4401 preIndex := iNdEx
4402 var wire uint64
4403 for shift := uint(0); ; shift += 7 {
4404 if shift >= 64 {
4405 return ErrIntOverflowGenerated
4406 }
4407 if iNdEx >= l {
4408 return io.ErrUnexpectedEOF
4409 }
4410 b := dAtA[iNdEx]
4411 iNdEx++
4412 wire |= (uint64(b) & 0x7F) << shift
4413 if b < 0x80 {
4414 break
4415 }
4416 }
4417 fieldNum := int32(wire >> 3)
4418 wireType := int(wire & 0x7)
4419 if wireType == 4 {
4420 return fmt.Errorf("proto: GroupVersionForDiscovery: wiretype end group for non-group")
4421 }
4422 if fieldNum <= 0 {
4423 return fmt.Errorf("proto: GroupVersionForDiscovery: illegal tag %d (wire type %d)", fieldNum, wire)
4424 }
4425 switch fieldNum {
4426 case 1:
4427 if wireType != 2 {
4428 return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType)
4429 }
4430 var stringLen uint64
4431 for shift := uint(0); ; shift += 7 {
4432 if shift >= 64 {
4433 return ErrIntOverflowGenerated
4434 }
4435 if iNdEx >= l {
4436 return io.ErrUnexpectedEOF
4437 }
4438 b := dAtA[iNdEx]
4439 iNdEx++
4440 stringLen |= (uint64(b) & 0x7F) << shift
4441 if b < 0x80 {
4442 break
4443 }
4444 }
4445 intStringLen := int(stringLen)
4446 if intStringLen < 0 {
4447 return ErrInvalidLengthGenerated
4448 }
4449 postIndex := iNdEx + intStringLen
4450 if postIndex > l {
4451 return io.ErrUnexpectedEOF
4452 }
4453 m.GroupVersion = string(dAtA[iNdEx:postIndex])
4454 iNdEx = postIndex
4455 case 2:
4456 if wireType != 2 {
4457 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4458 }
4459 var stringLen uint64
4460 for shift := uint(0); ; shift += 7 {
4461 if shift >= 64 {
4462 return ErrIntOverflowGenerated
4463 }
4464 if iNdEx >= l {
4465 return io.ErrUnexpectedEOF
4466 }
4467 b := dAtA[iNdEx]
4468 iNdEx++
4469 stringLen |= (uint64(b) & 0x7F) << shift
4470 if b < 0x80 {
4471 break
4472 }
4473 }
4474 intStringLen := int(stringLen)
4475 if intStringLen < 0 {
4476 return ErrInvalidLengthGenerated
4477 }
4478 postIndex := iNdEx + intStringLen
4479 if postIndex > l {
4480 return io.ErrUnexpectedEOF
4481 }
4482 m.Version = string(dAtA[iNdEx:postIndex])
4483 iNdEx = postIndex
4484 default:
4485 iNdEx = preIndex
4486 skippy, err := skipGenerated(dAtA[iNdEx:])
4487 if err != nil {
4488 return err
4489 }
4490 if skippy < 0 {
4491 return ErrInvalidLengthGenerated
4492 }
4493 if (iNdEx + skippy) > l {
4494 return io.ErrUnexpectedEOF
4495 }
4496 iNdEx += skippy
4497 }
4498 }
4499
4500 if iNdEx > l {
4501 return io.ErrUnexpectedEOF
4502 }
4503 return nil
4504}
4505func (m *GroupVersionKind) Unmarshal(dAtA []byte) error {
4506 l := len(dAtA)
4507 iNdEx := 0
4508 for iNdEx < l {
4509 preIndex := iNdEx
4510 var wire uint64
4511 for shift := uint(0); ; shift += 7 {
4512 if shift >= 64 {
4513 return ErrIntOverflowGenerated
4514 }
4515 if iNdEx >= l {
4516 return io.ErrUnexpectedEOF
4517 }
4518 b := dAtA[iNdEx]
4519 iNdEx++
4520 wire |= (uint64(b) & 0x7F) << shift
4521 if b < 0x80 {
4522 break
4523 }
4524 }
4525 fieldNum := int32(wire >> 3)
4526 wireType := int(wire & 0x7)
4527 if wireType == 4 {
4528 return fmt.Errorf("proto: GroupVersionKind: wiretype end group for non-group")
4529 }
4530 if fieldNum <= 0 {
4531 return fmt.Errorf("proto: GroupVersionKind: illegal tag %d (wire type %d)", fieldNum, wire)
4532 }
4533 switch fieldNum {
4534 case 1:
4535 if wireType != 2 {
4536 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4537 }
4538 var stringLen uint64
4539 for shift := uint(0); ; shift += 7 {
4540 if shift >= 64 {
4541 return ErrIntOverflowGenerated
4542 }
4543 if iNdEx >= l {
4544 return io.ErrUnexpectedEOF
4545 }
4546 b := dAtA[iNdEx]
4547 iNdEx++
4548 stringLen |= (uint64(b) & 0x7F) << shift
4549 if b < 0x80 {
4550 break
4551 }
4552 }
4553 intStringLen := int(stringLen)
4554 if intStringLen < 0 {
4555 return ErrInvalidLengthGenerated
4556 }
4557 postIndex := iNdEx + intStringLen
4558 if postIndex > l {
4559 return io.ErrUnexpectedEOF
4560 }
4561 m.Group = string(dAtA[iNdEx:postIndex])
4562 iNdEx = postIndex
4563 case 2:
4564 if wireType != 2 {
4565 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4566 }
4567 var stringLen uint64
4568 for shift := uint(0); ; shift += 7 {
4569 if shift >= 64 {
4570 return ErrIntOverflowGenerated
4571 }
4572 if iNdEx >= l {
4573 return io.ErrUnexpectedEOF
4574 }
4575 b := dAtA[iNdEx]
4576 iNdEx++
4577 stringLen |= (uint64(b) & 0x7F) << shift
4578 if b < 0x80 {
4579 break
4580 }
4581 }
4582 intStringLen := int(stringLen)
4583 if intStringLen < 0 {
4584 return ErrInvalidLengthGenerated
4585 }
4586 postIndex := iNdEx + intStringLen
4587 if postIndex > l {
4588 return io.ErrUnexpectedEOF
4589 }
4590 m.Version = string(dAtA[iNdEx:postIndex])
4591 iNdEx = postIndex
4592 case 3:
4593 if wireType != 2 {
4594 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
4595 }
4596 var stringLen uint64
4597 for shift := uint(0); ; shift += 7 {
4598 if shift >= 64 {
4599 return ErrIntOverflowGenerated
4600 }
4601 if iNdEx >= l {
4602 return io.ErrUnexpectedEOF
4603 }
4604 b := dAtA[iNdEx]
4605 iNdEx++
4606 stringLen |= (uint64(b) & 0x7F) << shift
4607 if b < 0x80 {
4608 break
4609 }
4610 }
4611 intStringLen := int(stringLen)
4612 if intStringLen < 0 {
4613 return ErrInvalidLengthGenerated
4614 }
4615 postIndex := iNdEx + intStringLen
4616 if postIndex > l {
4617 return io.ErrUnexpectedEOF
4618 }
4619 m.Kind = string(dAtA[iNdEx:postIndex])
4620 iNdEx = postIndex
4621 default:
4622 iNdEx = preIndex
4623 skippy, err := skipGenerated(dAtA[iNdEx:])
4624 if err != nil {
4625 return err
4626 }
4627 if skippy < 0 {
4628 return ErrInvalidLengthGenerated
4629 }
4630 if (iNdEx + skippy) > l {
4631 return io.ErrUnexpectedEOF
4632 }
4633 iNdEx += skippy
4634 }
4635 }
4636
4637 if iNdEx > l {
4638 return io.ErrUnexpectedEOF
4639 }
4640 return nil
4641}
4642func (m *GroupVersionResource) Unmarshal(dAtA []byte) error {
4643 l := len(dAtA)
4644 iNdEx := 0
4645 for iNdEx < l {
4646 preIndex := iNdEx
4647 var wire uint64
4648 for shift := uint(0); ; shift += 7 {
4649 if shift >= 64 {
4650 return ErrIntOverflowGenerated
4651 }
4652 if iNdEx >= l {
4653 return io.ErrUnexpectedEOF
4654 }
4655 b := dAtA[iNdEx]
4656 iNdEx++
4657 wire |= (uint64(b) & 0x7F) << shift
4658 if b < 0x80 {
4659 break
4660 }
4661 }
4662 fieldNum := int32(wire >> 3)
4663 wireType := int(wire & 0x7)
4664 if wireType == 4 {
4665 return fmt.Errorf("proto: GroupVersionResource: wiretype end group for non-group")
4666 }
4667 if fieldNum <= 0 {
4668 return fmt.Errorf("proto: GroupVersionResource: illegal tag %d (wire type %d)", fieldNum, wire)
4669 }
4670 switch fieldNum {
4671 case 1:
4672 if wireType != 2 {
4673 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
4674 }
4675 var stringLen uint64
4676 for shift := uint(0); ; shift += 7 {
4677 if shift >= 64 {
4678 return ErrIntOverflowGenerated
4679 }
4680 if iNdEx >= l {
4681 return io.ErrUnexpectedEOF
4682 }
4683 b := dAtA[iNdEx]
4684 iNdEx++
4685 stringLen |= (uint64(b) & 0x7F) << shift
4686 if b < 0x80 {
4687 break
4688 }
4689 }
4690 intStringLen := int(stringLen)
4691 if intStringLen < 0 {
4692 return ErrInvalidLengthGenerated
4693 }
4694 postIndex := iNdEx + intStringLen
4695 if postIndex > l {
4696 return io.ErrUnexpectedEOF
4697 }
4698 m.Group = string(dAtA[iNdEx:postIndex])
4699 iNdEx = postIndex
4700 case 2:
4701 if wireType != 2 {
4702 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4703 }
4704 var stringLen uint64
4705 for shift := uint(0); ; shift += 7 {
4706 if shift >= 64 {
4707 return ErrIntOverflowGenerated
4708 }
4709 if iNdEx >= l {
4710 return io.ErrUnexpectedEOF
4711 }
4712 b := dAtA[iNdEx]
4713 iNdEx++
4714 stringLen |= (uint64(b) & 0x7F) << shift
4715 if b < 0x80 {
4716 break
4717 }
4718 }
4719 intStringLen := int(stringLen)
4720 if intStringLen < 0 {
4721 return ErrInvalidLengthGenerated
4722 }
4723 postIndex := iNdEx + intStringLen
4724 if postIndex > l {
4725 return io.ErrUnexpectedEOF
4726 }
4727 m.Version = string(dAtA[iNdEx:postIndex])
4728 iNdEx = postIndex
4729 case 3:
4730 if wireType != 2 {
4731 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
4732 }
4733 var stringLen uint64
4734 for shift := uint(0); ; shift += 7 {
4735 if shift >= 64 {
4736 return ErrIntOverflowGenerated
4737 }
4738 if iNdEx >= l {
4739 return io.ErrUnexpectedEOF
4740 }
4741 b := dAtA[iNdEx]
4742 iNdEx++
4743 stringLen |= (uint64(b) & 0x7F) << shift
4744 if b < 0x80 {
4745 break
4746 }
4747 }
4748 intStringLen := int(stringLen)
4749 if intStringLen < 0 {
4750 return ErrInvalidLengthGenerated
4751 }
4752 postIndex := iNdEx + intStringLen
4753 if postIndex > l {
4754 return io.ErrUnexpectedEOF
4755 }
4756 m.Resource = string(dAtA[iNdEx:postIndex])
4757 iNdEx = postIndex
4758 default:
4759 iNdEx = preIndex
4760 skippy, err := skipGenerated(dAtA[iNdEx:])
4761 if err != nil {
4762 return err
4763 }
4764 if skippy < 0 {
4765 return ErrInvalidLengthGenerated
4766 }
4767 if (iNdEx + skippy) > l {
4768 return io.ErrUnexpectedEOF
4769 }
4770 iNdEx += skippy
4771 }
4772 }
4773
4774 if iNdEx > l {
4775 return io.ErrUnexpectedEOF
4776 }
4777 return nil
4778}
4779func (m *Initializer) Unmarshal(dAtA []byte) error {
4780 l := len(dAtA)
4781 iNdEx := 0
4782 for iNdEx < l {
4783 preIndex := iNdEx
4784 var wire uint64
4785 for shift := uint(0); ; shift += 7 {
4786 if shift >= 64 {
4787 return ErrIntOverflowGenerated
4788 }
4789 if iNdEx >= l {
4790 return io.ErrUnexpectedEOF
4791 }
4792 b := dAtA[iNdEx]
4793 iNdEx++
4794 wire |= (uint64(b) & 0x7F) << shift
4795 if b < 0x80 {
4796 break
4797 }
4798 }
4799 fieldNum := int32(wire >> 3)
4800 wireType := int(wire & 0x7)
4801 if wireType == 4 {
4802 return fmt.Errorf("proto: Initializer: wiretype end group for non-group")
4803 }
4804 if fieldNum <= 0 {
4805 return fmt.Errorf("proto: Initializer: illegal tag %d (wire type %d)", fieldNum, wire)
4806 }
4807 switch fieldNum {
4808 case 1:
4809 if wireType != 2 {
4810 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4811 }
4812 var stringLen uint64
4813 for shift := uint(0); ; shift += 7 {
4814 if shift >= 64 {
4815 return ErrIntOverflowGenerated
4816 }
4817 if iNdEx >= l {
4818 return io.ErrUnexpectedEOF
4819 }
4820 b := dAtA[iNdEx]
4821 iNdEx++
4822 stringLen |= (uint64(b) & 0x7F) << shift
4823 if b < 0x80 {
4824 break
4825 }
4826 }
4827 intStringLen := int(stringLen)
4828 if intStringLen < 0 {
4829 return ErrInvalidLengthGenerated
4830 }
4831 postIndex := iNdEx + intStringLen
4832 if postIndex > l {
4833 return io.ErrUnexpectedEOF
4834 }
4835 m.Name = string(dAtA[iNdEx:postIndex])
4836 iNdEx = postIndex
4837 default:
4838 iNdEx = preIndex
4839 skippy, err := skipGenerated(dAtA[iNdEx:])
4840 if err != nil {
4841 return err
4842 }
4843 if skippy < 0 {
4844 return ErrInvalidLengthGenerated
4845 }
4846 if (iNdEx + skippy) > l {
4847 return io.ErrUnexpectedEOF
4848 }
4849 iNdEx += skippy
4850 }
4851 }
4852
4853 if iNdEx > l {
4854 return io.ErrUnexpectedEOF
4855 }
4856 return nil
4857}
4858func (m *Initializers) Unmarshal(dAtA []byte) error {
4859 l := len(dAtA)
4860 iNdEx := 0
4861 for iNdEx < l {
4862 preIndex := iNdEx
4863 var wire uint64
4864 for shift := uint(0); ; shift += 7 {
4865 if shift >= 64 {
4866 return ErrIntOverflowGenerated
4867 }
4868 if iNdEx >= l {
4869 return io.ErrUnexpectedEOF
4870 }
4871 b := dAtA[iNdEx]
4872 iNdEx++
4873 wire |= (uint64(b) & 0x7F) << shift
4874 if b < 0x80 {
4875 break
4876 }
4877 }
4878 fieldNum := int32(wire >> 3)
4879 wireType := int(wire & 0x7)
4880 if wireType == 4 {
4881 return fmt.Errorf("proto: Initializers: wiretype end group for non-group")
4882 }
4883 if fieldNum <= 0 {
4884 return fmt.Errorf("proto: Initializers: illegal tag %d (wire type %d)", fieldNum, wire)
4885 }
4886 switch fieldNum {
4887 case 1:
4888 if wireType != 2 {
4889 return fmt.Errorf("proto: wrong wireType = %d for field Pending", wireType)
4890 }
4891 var msglen int
4892 for shift := uint(0); ; shift += 7 {
4893 if shift >= 64 {
4894 return ErrIntOverflowGenerated
4895 }
4896 if iNdEx >= l {
4897 return io.ErrUnexpectedEOF
4898 }
4899 b := dAtA[iNdEx]
4900 iNdEx++
4901 msglen |= (int(b) & 0x7F) << shift
4902 if b < 0x80 {
4903 break
4904 }
4905 }
4906 if msglen < 0 {
4907 return ErrInvalidLengthGenerated
4908 }
4909 postIndex := iNdEx + msglen
4910 if postIndex > l {
4911 return io.ErrUnexpectedEOF
4912 }
4913 m.Pending = append(m.Pending, Initializer{})
4914 if err := m.Pending[len(m.Pending)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4915 return err
4916 }
4917 iNdEx = postIndex
4918 case 2:
4919 if wireType != 2 {
4920 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
4921 }
4922 var msglen int
4923 for shift := uint(0); ; shift += 7 {
4924 if shift >= 64 {
4925 return ErrIntOverflowGenerated
4926 }
4927 if iNdEx >= l {
4928 return io.ErrUnexpectedEOF
4929 }
4930 b := dAtA[iNdEx]
4931 iNdEx++
4932 msglen |= (int(b) & 0x7F) << shift
4933 if b < 0x80 {
4934 break
4935 }
4936 }
4937 if msglen < 0 {
4938 return ErrInvalidLengthGenerated
4939 }
4940 postIndex := iNdEx + msglen
4941 if postIndex > l {
4942 return io.ErrUnexpectedEOF
4943 }
4944 if m.Result == nil {
4945 m.Result = &Status{}
4946 }
4947 if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4948 return err
4949 }
4950 iNdEx = postIndex
4951 default:
4952 iNdEx = preIndex
4953 skippy, err := skipGenerated(dAtA[iNdEx:])
4954 if err != nil {
4955 return err
4956 }
4957 if skippy < 0 {
4958 return ErrInvalidLengthGenerated
4959 }
4960 if (iNdEx + skippy) > l {
4961 return io.ErrUnexpectedEOF
4962 }
4963 iNdEx += skippy
4964 }
4965 }
4966
4967 if iNdEx > l {
4968 return io.ErrUnexpectedEOF
4969 }
4970 return nil
4971}
4972func (m *LabelSelector) Unmarshal(dAtA []byte) error {
4973 l := len(dAtA)
4974 iNdEx := 0
4975 for iNdEx < l {
4976 preIndex := iNdEx
4977 var wire uint64
4978 for shift := uint(0); ; shift += 7 {
4979 if shift >= 64 {
4980 return ErrIntOverflowGenerated
4981 }
4982 if iNdEx >= l {
4983 return io.ErrUnexpectedEOF
4984 }
4985 b := dAtA[iNdEx]
4986 iNdEx++
4987 wire |= (uint64(b) & 0x7F) << shift
4988 if b < 0x80 {
4989 break
4990 }
4991 }
4992 fieldNum := int32(wire >> 3)
4993 wireType := int(wire & 0x7)
4994 if wireType == 4 {
4995 return fmt.Errorf("proto: LabelSelector: wiretype end group for non-group")
4996 }
4997 if fieldNum <= 0 {
4998 return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
4999 }
5000 switch fieldNum {
5001 case 1:
5002 if wireType != 2 {
5003 return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
5004 }
5005 var msglen int
5006 for shift := uint(0); ; shift += 7 {
5007 if shift >= 64 {
5008 return ErrIntOverflowGenerated
5009 }
5010 if iNdEx >= l {
5011 return io.ErrUnexpectedEOF
5012 }
5013 b := dAtA[iNdEx]
5014 iNdEx++
5015 msglen |= (int(b) & 0x7F) << shift
5016 if b < 0x80 {
5017 break
5018 }
5019 }
5020 if msglen < 0 {
5021 return ErrInvalidLengthGenerated
5022 }
5023 postIndex := iNdEx + msglen
5024 if postIndex > l {
5025 return io.ErrUnexpectedEOF
5026 }
5027 if m.MatchLabels == nil {
5028 m.MatchLabels = make(map[string]string)
5029 }
5030 var mapkey string
5031 var mapvalue string
5032 for iNdEx < postIndex {
5033 entryPreIndex := iNdEx
5034 var wire uint64
5035 for shift := uint(0); ; shift += 7 {
5036 if shift >= 64 {
5037 return ErrIntOverflowGenerated
5038 }
5039 if iNdEx >= l {
5040 return io.ErrUnexpectedEOF
5041 }
5042 b := dAtA[iNdEx]
5043 iNdEx++
5044 wire |= (uint64(b) & 0x7F) << shift
5045 if b < 0x80 {
5046 break
5047 }
5048 }
5049 fieldNum := int32(wire >> 3)
5050 if fieldNum == 1 {
5051 var stringLenmapkey uint64
5052 for shift := uint(0); ; shift += 7 {
5053 if shift >= 64 {
5054 return ErrIntOverflowGenerated
5055 }
5056 if iNdEx >= l {
5057 return io.ErrUnexpectedEOF
5058 }
5059 b := dAtA[iNdEx]
5060 iNdEx++
5061 stringLenmapkey |= (uint64(b) & 0x7F) << shift
5062 if b < 0x80 {
5063 break
5064 }
5065 }
5066 intStringLenmapkey := int(stringLenmapkey)
5067 if intStringLenmapkey < 0 {
5068 return ErrInvalidLengthGenerated
5069 }
5070 postStringIndexmapkey := iNdEx + intStringLenmapkey
5071 if postStringIndexmapkey > l {
5072 return io.ErrUnexpectedEOF
5073 }
5074 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5075 iNdEx = postStringIndexmapkey
5076 } else if fieldNum == 2 {
5077 var stringLenmapvalue uint64
5078 for shift := uint(0); ; shift += 7 {
5079 if shift >= 64 {
5080 return ErrIntOverflowGenerated
5081 }
5082 if iNdEx >= l {
5083 return io.ErrUnexpectedEOF
5084 }
5085 b := dAtA[iNdEx]
5086 iNdEx++
5087 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
5088 if b < 0x80 {
5089 break
5090 }
5091 }
5092 intStringLenmapvalue := int(stringLenmapvalue)
5093 if intStringLenmapvalue < 0 {
5094 return ErrInvalidLengthGenerated
5095 }
5096 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
5097 if postStringIndexmapvalue > l {
5098 return io.ErrUnexpectedEOF
5099 }
5100 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
5101 iNdEx = postStringIndexmapvalue
5102 } else {
5103 iNdEx = entryPreIndex
5104 skippy, err := skipGenerated(dAtA[iNdEx:])
5105 if err != nil {
5106 return err
5107 }
5108 if skippy < 0 {
5109 return ErrInvalidLengthGenerated
5110 }
5111 if (iNdEx + skippy) > postIndex {
5112 return io.ErrUnexpectedEOF
5113 }
5114 iNdEx += skippy
5115 }
5116 }
5117 m.MatchLabels[mapkey] = mapvalue
5118 iNdEx = postIndex
5119 case 2:
5120 if wireType != 2 {
5121 return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", 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 > l {
5143 return io.ErrUnexpectedEOF
5144 }
5145 m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{})
5146 if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5147 return err
5148 }
5149 iNdEx = postIndex
5150 default:
5151 iNdEx = preIndex
5152 skippy, err := skipGenerated(dAtA[iNdEx:])
5153 if err != nil {
5154 return err
5155 }
5156 if skippy < 0 {
5157 return ErrInvalidLengthGenerated
5158 }
5159 if (iNdEx + skippy) > l {
5160 return io.ErrUnexpectedEOF
5161 }
5162 iNdEx += skippy
5163 }
5164 }
5165
5166 if iNdEx > l {
5167 return io.ErrUnexpectedEOF
5168 }
5169 return nil
5170}
5171func (m *LabelSelectorRequirement) Unmarshal(dAtA []byte) error {
5172 l := len(dAtA)
5173 iNdEx := 0
5174 for iNdEx < l {
5175 preIndex := iNdEx
5176 var wire uint64
5177 for shift := uint(0); ; shift += 7 {
5178 if shift >= 64 {
5179 return ErrIntOverflowGenerated
5180 }
5181 if iNdEx >= l {
5182 return io.ErrUnexpectedEOF
5183 }
5184 b := dAtA[iNdEx]
5185 iNdEx++
5186 wire |= (uint64(b) & 0x7F) << shift
5187 if b < 0x80 {
5188 break
5189 }
5190 }
5191 fieldNum := int32(wire >> 3)
5192 wireType := int(wire & 0x7)
5193 if wireType == 4 {
5194 return fmt.Errorf("proto: LabelSelectorRequirement: wiretype end group for non-group")
5195 }
5196 if fieldNum <= 0 {
5197 return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
5198 }
5199 switch fieldNum {
5200 case 1:
5201 if wireType != 2 {
5202 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
5203 }
5204 var stringLen uint64
5205 for shift := uint(0); ; shift += 7 {
5206 if shift >= 64 {
5207 return ErrIntOverflowGenerated
5208 }
5209 if iNdEx >= l {
5210 return io.ErrUnexpectedEOF
5211 }
5212 b := dAtA[iNdEx]
5213 iNdEx++
5214 stringLen |= (uint64(b) & 0x7F) << shift
5215 if b < 0x80 {
5216 break
5217 }
5218 }
5219 intStringLen := int(stringLen)
5220 if intStringLen < 0 {
5221 return ErrInvalidLengthGenerated
5222 }
5223 postIndex := iNdEx + intStringLen
5224 if postIndex > l {
5225 return io.ErrUnexpectedEOF
5226 }
5227 m.Key = string(dAtA[iNdEx:postIndex])
5228 iNdEx = postIndex
5229 case 2:
5230 if wireType != 2 {
5231 return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
5232 }
5233 var stringLen uint64
5234 for shift := uint(0); ; shift += 7 {
5235 if shift >= 64 {
5236 return ErrIntOverflowGenerated
5237 }
5238 if iNdEx >= l {
5239 return io.ErrUnexpectedEOF
5240 }
5241 b := dAtA[iNdEx]
5242 iNdEx++
5243 stringLen |= (uint64(b) & 0x7F) << shift
5244 if b < 0x80 {
5245 break
5246 }
5247 }
5248 intStringLen := int(stringLen)
5249 if intStringLen < 0 {
5250 return ErrInvalidLengthGenerated
5251 }
5252 postIndex := iNdEx + intStringLen
5253 if postIndex > l {
5254 return io.ErrUnexpectedEOF
5255 }
5256 m.Operator = LabelSelectorOperator(dAtA[iNdEx:postIndex])
5257 iNdEx = postIndex
5258 case 3:
5259 if wireType != 2 {
5260 return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
5261 }
5262 var stringLen uint64
5263 for shift := uint(0); ; shift += 7 {
5264 if shift >= 64 {
5265 return ErrIntOverflowGenerated
5266 }
5267 if iNdEx >= l {
5268 return io.ErrUnexpectedEOF
5269 }
5270 b := dAtA[iNdEx]
5271 iNdEx++
5272 stringLen |= (uint64(b) & 0x7F) << shift
5273 if b < 0x80 {
5274 break
5275 }
5276 }
5277 intStringLen := int(stringLen)
5278 if intStringLen < 0 {
5279 return ErrInvalidLengthGenerated
5280 }
5281 postIndex := iNdEx + intStringLen
5282 if postIndex > l {
5283 return io.ErrUnexpectedEOF
5284 }
5285 m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
5286 iNdEx = postIndex
5287 default:
5288 iNdEx = preIndex
5289 skippy, err := skipGenerated(dAtA[iNdEx:])
5290 if err != nil {
5291 return err
5292 }
5293 if skippy < 0 {
5294 return ErrInvalidLengthGenerated
5295 }
5296 if (iNdEx + skippy) > l {
5297 return io.ErrUnexpectedEOF
5298 }
5299 iNdEx += skippy
5300 }
5301 }
5302
5303 if iNdEx > l {
5304 return io.ErrUnexpectedEOF
5305 }
5306 return nil
5307}
5308func (m *List) Unmarshal(dAtA []byte) error {
5309 l := len(dAtA)
5310 iNdEx := 0
5311 for iNdEx < l {
5312 preIndex := iNdEx
5313 var wire uint64
5314 for shift := uint(0); ; shift += 7 {
5315 if shift >= 64 {
5316 return ErrIntOverflowGenerated
5317 }
5318 if iNdEx >= l {
5319 return io.ErrUnexpectedEOF
5320 }
5321 b := dAtA[iNdEx]
5322 iNdEx++
5323 wire |= (uint64(b) & 0x7F) << shift
5324 if b < 0x80 {
5325 break
5326 }
5327 }
5328 fieldNum := int32(wire >> 3)
5329 wireType := int(wire & 0x7)
5330 if wireType == 4 {
5331 return fmt.Errorf("proto: List: wiretype end group for non-group")
5332 }
5333 if fieldNum <= 0 {
5334 return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
5335 }
5336 switch fieldNum {
5337 case 1:
5338 if wireType != 2 {
5339 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
5340 }
5341 var msglen int
5342 for shift := uint(0); ; shift += 7 {
5343 if shift >= 64 {
5344 return ErrIntOverflowGenerated
5345 }
5346 if iNdEx >= l {
5347 return io.ErrUnexpectedEOF
5348 }
5349 b := dAtA[iNdEx]
5350 iNdEx++
5351 msglen |= (int(b) & 0x7F) << shift
5352 if b < 0x80 {
5353 break
5354 }
5355 }
5356 if msglen < 0 {
5357 return ErrInvalidLengthGenerated
5358 }
5359 postIndex := iNdEx + msglen
5360 if postIndex > l {
5361 return io.ErrUnexpectedEOF
5362 }
5363 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5364 return err
5365 }
5366 iNdEx = postIndex
5367 case 2:
5368 if wireType != 2 {
5369 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
5370 }
5371 var msglen int
5372 for shift := uint(0); ; shift += 7 {
5373 if shift >= 64 {
5374 return ErrIntOverflowGenerated
5375 }
5376 if iNdEx >= l {
5377 return io.ErrUnexpectedEOF
5378 }
5379 b := dAtA[iNdEx]
5380 iNdEx++
5381 msglen |= (int(b) & 0x7F) << shift
5382 if b < 0x80 {
5383 break
5384 }
5385 }
5386 if msglen < 0 {
5387 return ErrInvalidLengthGenerated
5388 }
5389 postIndex := iNdEx + msglen
5390 if postIndex > l {
5391 return io.ErrUnexpectedEOF
5392 }
5393 m.Items = append(m.Items, k8s_io_apimachinery_pkg_runtime.RawExtension{})
5394 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5395 return err
5396 }
5397 iNdEx = postIndex
5398 default:
5399 iNdEx = preIndex
5400 skippy, err := skipGenerated(dAtA[iNdEx:])
5401 if err != nil {
5402 return err
5403 }
5404 if skippy < 0 {
5405 return ErrInvalidLengthGenerated
5406 }
5407 if (iNdEx + skippy) > l {
5408 return io.ErrUnexpectedEOF
5409 }
5410 iNdEx += skippy
5411 }
5412 }
5413
5414 if iNdEx > l {
5415 return io.ErrUnexpectedEOF
5416 }
5417 return nil
5418}
5419func (m *ListMeta) Unmarshal(dAtA []byte) error {
5420 l := len(dAtA)
5421 iNdEx := 0
5422 for iNdEx < l {
5423 preIndex := iNdEx
5424 var wire uint64
5425 for shift := uint(0); ; shift += 7 {
5426 if shift >= 64 {
5427 return ErrIntOverflowGenerated
5428 }
5429 if iNdEx >= l {
5430 return io.ErrUnexpectedEOF
5431 }
5432 b := dAtA[iNdEx]
5433 iNdEx++
5434 wire |= (uint64(b) & 0x7F) << shift
5435 if b < 0x80 {
5436 break
5437 }
5438 }
5439 fieldNum := int32(wire >> 3)
5440 wireType := int(wire & 0x7)
5441 if wireType == 4 {
5442 return fmt.Errorf("proto: ListMeta: wiretype end group for non-group")
5443 }
5444 if fieldNum <= 0 {
5445 return fmt.Errorf("proto: ListMeta: illegal tag %d (wire type %d)", fieldNum, wire)
5446 }
5447 switch fieldNum {
5448 case 1:
5449 if wireType != 2 {
5450 return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
5451 }
5452 var stringLen uint64
5453 for shift := uint(0); ; shift += 7 {
5454 if shift >= 64 {
5455 return ErrIntOverflowGenerated
5456 }
5457 if iNdEx >= l {
5458 return io.ErrUnexpectedEOF
5459 }
5460 b := dAtA[iNdEx]
5461 iNdEx++
5462 stringLen |= (uint64(b) & 0x7F) << shift
5463 if b < 0x80 {
5464 break
5465 }
5466 }
5467 intStringLen := int(stringLen)
5468 if intStringLen < 0 {
5469 return ErrInvalidLengthGenerated
5470 }
5471 postIndex := iNdEx + intStringLen
5472 if postIndex > l {
5473 return io.ErrUnexpectedEOF
5474 }
5475 m.SelfLink = string(dAtA[iNdEx:postIndex])
5476 iNdEx = postIndex
5477 case 2:
5478 if wireType != 2 {
5479 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
5480 }
5481 var stringLen uint64
5482 for shift := uint(0); ; shift += 7 {
5483 if shift >= 64 {
5484 return ErrIntOverflowGenerated
5485 }
5486 if iNdEx >= l {
5487 return io.ErrUnexpectedEOF
5488 }
5489 b := dAtA[iNdEx]
5490 iNdEx++
5491 stringLen |= (uint64(b) & 0x7F) << shift
5492 if b < 0x80 {
5493 break
5494 }
5495 }
5496 intStringLen := int(stringLen)
5497 if intStringLen < 0 {
5498 return ErrInvalidLengthGenerated
5499 }
5500 postIndex := iNdEx + intStringLen
5501 if postIndex > l {
5502 return io.ErrUnexpectedEOF
5503 }
5504 m.ResourceVersion = string(dAtA[iNdEx:postIndex])
5505 iNdEx = postIndex
5506 case 3:
5507 if wireType != 2 {
5508 return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType)
5509 }
5510 var stringLen uint64
5511 for shift := uint(0); ; shift += 7 {
5512 if shift >= 64 {
5513 return ErrIntOverflowGenerated
5514 }
5515 if iNdEx >= l {
5516 return io.ErrUnexpectedEOF
5517 }
5518 b := dAtA[iNdEx]
5519 iNdEx++
5520 stringLen |= (uint64(b) & 0x7F) << shift
5521 if b < 0x80 {
5522 break
5523 }
5524 }
5525 intStringLen := int(stringLen)
5526 if intStringLen < 0 {
5527 return ErrInvalidLengthGenerated
5528 }
5529 postIndex := iNdEx + intStringLen
5530 if postIndex > l {
5531 return io.ErrUnexpectedEOF
5532 }
5533 m.Continue = string(dAtA[iNdEx:postIndex])
5534 iNdEx = postIndex
5535 default:
5536 iNdEx = preIndex
5537 skippy, err := skipGenerated(dAtA[iNdEx:])
5538 if err != nil {
5539 return err
5540 }
5541 if skippy < 0 {
5542 return ErrInvalidLengthGenerated
5543 }
5544 if (iNdEx + skippy) > l {
5545 return io.ErrUnexpectedEOF
5546 }
5547 iNdEx += skippy
5548 }
5549 }
5550
5551 if iNdEx > l {
5552 return io.ErrUnexpectedEOF
5553 }
5554 return nil
5555}
5556func (m *ListOptions) Unmarshal(dAtA []byte) error {
5557 l := len(dAtA)
5558 iNdEx := 0
5559 for iNdEx < l {
5560 preIndex := iNdEx
5561 var wire uint64
5562 for shift := uint(0); ; shift += 7 {
5563 if shift >= 64 {
5564 return ErrIntOverflowGenerated
5565 }
5566 if iNdEx >= l {
5567 return io.ErrUnexpectedEOF
5568 }
5569 b := dAtA[iNdEx]
5570 iNdEx++
5571 wire |= (uint64(b) & 0x7F) << shift
5572 if b < 0x80 {
5573 break
5574 }
5575 }
5576 fieldNum := int32(wire >> 3)
5577 wireType := int(wire & 0x7)
5578 if wireType == 4 {
5579 return fmt.Errorf("proto: ListOptions: wiretype end group for non-group")
5580 }
5581 if fieldNum <= 0 {
5582 return fmt.Errorf("proto: ListOptions: illegal tag %d (wire type %d)", fieldNum, wire)
5583 }
5584 switch fieldNum {
5585 case 1:
5586 if wireType != 2 {
5587 return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType)
5588 }
5589 var stringLen uint64
5590 for shift := uint(0); ; shift += 7 {
5591 if shift >= 64 {
5592 return ErrIntOverflowGenerated
5593 }
5594 if iNdEx >= l {
5595 return io.ErrUnexpectedEOF
5596 }
5597 b := dAtA[iNdEx]
5598 iNdEx++
5599 stringLen |= (uint64(b) & 0x7F) << shift
5600 if b < 0x80 {
5601 break
5602 }
5603 }
5604 intStringLen := int(stringLen)
5605 if intStringLen < 0 {
5606 return ErrInvalidLengthGenerated
5607 }
5608 postIndex := iNdEx + intStringLen
5609 if postIndex > l {
5610 return io.ErrUnexpectedEOF
5611 }
5612 m.LabelSelector = string(dAtA[iNdEx:postIndex])
5613 iNdEx = postIndex
5614 case 2:
5615 if wireType != 2 {
5616 return fmt.Errorf("proto: wrong wireType = %d for field FieldSelector", wireType)
5617 }
5618 var stringLen uint64
5619 for shift := uint(0); ; shift += 7 {
5620 if shift >= 64 {
5621 return ErrIntOverflowGenerated
5622 }
5623 if iNdEx >= l {
5624 return io.ErrUnexpectedEOF
5625 }
5626 b := dAtA[iNdEx]
5627 iNdEx++
5628 stringLen |= (uint64(b) & 0x7F) << shift
5629 if b < 0x80 {
5630 break
5631 }
5632 }
5633 intStringLen := int(stringLen)
5634 if intStringLen < 0 {
5635 return ErrInvalidLengthGenerated
5636 }
5637 postIndex := iNdEx + intStringLen
5638 if postIndex > l {
5639 return io.ErrUnexpectedEOF
5640 }
5641 m.FieldSelector = string(dAtA[iNdEx:postIndex])
5642 iNdEx = postIndex
5643 case 3:
5644 if wireType != 0 {
5645 return fmt.Errorf("proto: wrong wireType = %d for field Watch", wireType)
5646 }
5647 var v int
5648 for shift := uint(0); ; shift += 7 {
5649 if shift >= 64 {
5650 return ErrIntOverflowGenerated
5651 }
5652 if iNdEx >= l {
5653 return io.ErrUnexpectedEOF
5654 }
5655 b := dAtA[iNdEx]
5656 iNdEx++
5657 v |= (int(b) & 0x7F) << shift
5658 if b < 0x80 {
5659 break
5660 }
5661 }
5662 m.Watch = bool(v != 0)
5663 case 4:
5664 if wireType != 2 {
5665 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
5666 }
5667 var stringLen uint64
5668 for shift := uint(0); ; shift += 7 {
5669 if shift >= 64 {
5670 return ErrIntOverflowGenerated
5671 }
5672 if iNdEx >= l {
5673 return io.ErrUnexpectedEOF
5674 }
5675 b := dAtA[iNdEx]
5676 iNdEx++
5677 stringLen |= (uint64(b) & 0x7F) << shift
5678 if b < 0x80 {
5679 break
5680 }
5681 }
5682 intStringLen := int(stringLen)
5683 if intStringLen < 0 {
5684 return ErrInvalidLengthGenerated
5685 }
5686 postIndex := iNdEx + intStringLen
5687 if postIndex > l {
5688 return io.ErrUnexpectedEOF
5689 }
5690 m.ResourceVersion = string(dAtA[iNdEx:postIndex])
5691 iNdEx = postIndex
5692 case 5:
5693 if wireType != 0 {
5694 return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType)
5695 }
5696 var v int64
5697 for shift := uint(0); ; shift += 7 {
5698 if shift >= 64 {
5699 return ErrIntOverflowGenerated
5700 }
5701 if iNdEx >= l {
5702 return io.ErrUnexpectedEOF
5703 }
5704 b := dAtA[iNdEx]
5705 iNdEx++
5706 v |= (int64(b) & 0x7F) << shift
5707 if b < 0x80 {
5708 break
5709 }
5710 }
5711 m.TimeoutSeconds = &v
5712 case 6:
5713 if wireType != 0 {
5714 return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", wireType)
5715 }
5716 var v int
5717 for shift := uint(0); ; shift += 7 {
5718 if shift >= 64 {
5719 return ErrIntOverflowGenerated
5720 }
5721 if iNdEx >= l {
5722 return io.ErrUnexpectedEOF
5723 }
5724 b := dAtA[iNdEx]
5725 iNdEx++
5726 v |= (int(b) & 0x7F) << shift
5727 if b < 0x80 {
5728 break
5729 }
5730 }
5731 m.IncludeUninitialized = bool(v != 0)
5732 case 7:
5733 if wireType != 0 {
5734 return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
5735 }
5736 m.Limit = 0
5737 for shift := uint(0); ; shift += 7 {
5738 if shift >= 64 {
5739 return ErrIntOverflowGenerated
5740 }
5741 if iNdEx >= l {
5742 return io.ErrUnexpectedEOF
5743 }
5744 b := dAtA[iNdEx]
5745 iNdEx++
5746 m.Limit |= (int64(b) & 0x7F) << shift
5747 if b < 0x80 {
5748 break
5749 }
5750 }
5751 case 8:
5752 if wireType != 2 {
5753 return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType)
5754 }
5755 var stringLen uint64
5756 for shift := uint(0); ; shift += 7 {
5757 if shift >= 64 {
5758 return ErrIntOverflowGenerated
5759 }
5760 if iNdEx >= l {
5761 return io.ErrUnexpectedEOF
5762 }
5763 b := dAtA[iNdEx]
5764 iNdEx++
5765 stringLen |= (uint64(b) & 0x7F) << shift
5766 if b < 0x80 {
5767 break
5768 }
5769 }
5770 intStringLen := int(stringLen)
5771 if intStringLen < 0 {
5772 return ErrInvalidLengthGenerated
5773 }
5774 postIndex := iNdEx + intStringLen
5775 if postIndex > l {
5776 return io.ErrUnexpectedEOF
5777 }
5778 m.Continue = string(dAtA[iNdEx:postIndex])
5779 iNdEx = postIndex
5780 default:
5781 iNdEx = preIndex
5782 skippy, err := skipGenerated(dAtA[iNdEx:])
5783 if err != nil {
5784 return err
5785 }
5786 if skippy < 0 {
5787 return ErrInvalidLengthGenerated
5788 }
5789 if (iNdEx + skippy) > l {
5790 return io.ErrUnexpectedEOF
5791 }
5792 iNdEx += skippy
5793 }
5794 }
5795
5796 if iNdEx > l {
5797 return io.ErrUnexpectedEOF
5798 }
5799 return nil
5800}
5801func (m *ObjectMeta) Unmarshal(dAtA []byte) error {
5802 l := len(dAtA)
5803 iNdEx := 0
5804 for iNdEx < l {
5805 preIndex := iNdEx
5806 var wire uint64
5807 for shift := uint(0); ; shift += 7 {
5808 if shift >= 64 {
5809 return ErrIntOverflowGenerated
5810 }
5811 if iNdEx >= l {
5812 return io.ErrUnexpectedEOF
5813 }
5814 b := dAtA[iNdEx]
5815 iNdEx++
5816 wire |= (uint64(b) & 0x7F) << shift
5817 if b < 0x80 {
5818 break
5819 }
5820 }
5821 fieldNum := int32(wire >> 3)
5822 wireType := int(wire & 0x7)
5823 if wireType == 4 {
5824 return fmt.Errorf("proto: ObjectMeta: wiretype end group for non-group")
5825 }
5826 if fieldNum <= 0 {
5827 return fmt.Errorf("proto: ObjectMeta: illegal tag %d (wire type %d)", fieldNum, wire)
5828 }
5829 switch fieldNum {
5830 case 1:
5831 if wireType != 2 {
5832 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
5833 }
5834 var stringLen uint64
5835 for shift := uint(0); ; shift += 7 {
5836 if shift >= 64 {
5837 return ErrIntOverflowGenerated
5838 }
5839 if iNdEx >= l {
5840 return io.ErrUnexpectedEOF
5841 }
5842 b := dAtA[iNdEx]
5843 iNdEx++
5844 stringLen |= (uint64(b) & 0x7F) << shift
5845 if b < 0x80 {
5846 break
5847 }
5848 }
5849 intStringLen := int(stringLen)
5850 if intStringLen < 0 {
5851 return ErrInvalidLengthGenerated
5852 }
5853 postIndex := iNdEx + intStringLen
5854 if postIndex > l {
5855 return io.ErrUnexpectedEOF
5856 }
5857 m.Name = string(dAtA[iNdEx:postIndex])
5858 iNdEx = postIndex
5859 case 2:
5860 if wireType != 2 {
5861 return fmt.Errorf("proto: wrong wireType = %d for field GenerateName", wireType)
5862 }
5863 var stringLen uint64
5864 for shift := uint(0); ; shift += 7 {
5865 if shift >= 64 {
5866 return ErrIntOverflowGenerated
5867 }
5868 if iNdEx >= l {
5869 return io.ErrUnexpectedEOF
5870 }
5871 b := dAtA[iNdEx]
5872 iNdEx++
5873 stringLen |= (uint64(b) & 0x7F) << shift
5874 if b < 0x80 {
5875 break
5876 }
5877 }
5878 intStringLen := int(stringLen)
5879 if intStringLen < 0 {
5880 return ErrInvalidLengthGenerated
5881 }
5882 postIndex := iNdEx + intStringLen
5883 if postIndex > l {
5884 return io.ErrUnexpectedEOF
5885 }
5886 m.GenerateName = string(dAtA[iNdEx:postIndex])
5887 iNdEx = postIndex
5888 case 3:
5889 if wireType != 2 {
5890 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
5891 }
5892 var stringLen uint64
5893 for shift := uint(0); ; shift += 7 {
5894 if shift >= 64 {
5895 return ErrIntOverflowGenerated
5896 }
5897 if iNdEx >= l {
5898 return io.ErrUnexpectedEOF
5899 }
5900 b := dAtA[iNdEx]
5901 iNdEx++
5902 stringLen |= (uint64(b) & 0x7F) << shift
5903 if b < 0x80 {
5904 break
5905 }
5906 }
5907 intStringLen := int(stringLen)
5908 if intStringLen < 0 {
5909 return ErrInvalidLengthGenerated
5910 }
5911 postIndex := iNdEx + intStringLen
5912 if postIndex > l {
5913 return io.ErrUnexpectedEOF
5914 }
5915 m.Namespace = string(dAtA[iNdEx:postIndex])
5916 iNdEx = postIndex
5917 case 4:
5918 if wireType != 2 {
5919 return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType)
5920 }
5921 var stringLen uint64
5922 for shift := uint(0); ; shift += 7 {
5923 if shift >= 64 {
5924 return ErrIntOverflowGenerated
5925 }
5926 if iNdEx >= l {
5927 return io.ErrUnexpectedEOF
5928 }
5929 b := dAtA[iNdEx]
5930 iNdEx++
5931 stringLen |= (uint64(b) & 0x7F) << shift
5932 if b < 0x80 {
5933 break
5934 }
5935 }
5936 intStringLen := int(stringLen)
5937 if intStringLen < 0 {
5938 return ErrInvalidLengthGenerated
5939 }
5940 postIndex := iNdEx + intStringLen
5941 if postIndex > l {
5942 return io.ErrUnexpectedEOF
5943 }
5944 m.SelfLink = string(dAtA[iNdEx:postIndex])
5945 iNdEx = postIndex
5946 case 5:
5947 if wireType != 2 {
5948 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
5949 }
5950 var stringLen uint64
5951 for shift := uint(0); ; shift += 7 {
5952 if shift >= 64 {
5953 return ErrIntOverflowGenerated
5954 }
5955 if iNdEx >= l {
5956 return io.ErrUnexpectedEOF
5957 }
5958 b := dAtA[iNdEx]
5959 iNdEx++
5960 stringLen |= (uint64(b) & 0x7F) << shift
5961 if b < 0x80 {
5962 break
5963 }
5964 }
5965 intStringLen := int(stringLen)
5966 if intStringLen < 0 {
5967 return ErrInvalidLengthGenerated
5968 }
5969 postIndex := iNdEx + intStringLen
5970 if postIndex > l {
5971 return io.ErrUnexpectedEOF
5972 }
5973 m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
5974 iNdEx = postIndex
5975 case 6:
5976 if wireType != 2 {
5977 return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType)
5978 }
5979 var stringLen uint64
5980 for shift := uint(0); ; shift += 7 {
5981 if shift >= 64 {
5982 return ErrIntOverflowGenerated
5983 }
5984 if iNdEx >= l {
5985 return io.ErrUnexpectedEOF
5986 }
5987 b := dAtA[iNdEx]
5988 iNdEx++
5989 stringLen |= (uint64(b) & 0x7F) << shift
5990 if b < 0x80 {
5991 break
5992 }
5993 }
5994 intStringLen := int(stringLen)
5995 if intStringLen < 0 {
5996 return ErrInvalidLengthGenerated
5997 }
5998 postIndex := iNdEx + intStringLen
5999 if postIndex > l {
6000 return io.ErrUnexpectedEOF
6001 }
6002 m.ResourceVersion = string(dAtA[iNdEx:postIndex])
6003 iNdEx = postIndex
6004 case 7:
6005 if wireType != 0 {
6006 return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)
6007 }
6008 m.Generation = 0
6009 for shift := uint(0); ; shift += 7 {
6010 if shift >= 64 {
6011 return ErrIntOverflowGenerated
6012 }
6013 if iNdEx >= l {
6014 return io.ErrUnexpectedEOF
6015 }
6016 b := dAtA[iNdEx]
6017 iNdEx++
6018 m.Generation |= (int64(b) & 0x7F) << shift
6019 if b < 0x80 {
6020 break
6021 }
6022 }
6023 case 8:
6024 if wireType != 2 {
6025 return fmt.Errorf("proto: wrong wireType = %d for field CreationTimestamp", wireType)
6026 }
6027 var msglen int
6028 for shift := uint(0); ; shift += 7 {
6029 if shift >= 64 {
6030 return ErrIntOverflowGenerated
6031 }
6032 if iNdEx >= l {
6033 return io.ErrUnexpectedEOF
6034 }
6035 b := dAtA[iNdEx]
6036 iNdEx++
6037 msglen |= (int(b) & 0x7F) << shift
6038 if b < 0x80 {
6039 break
6040 }
6041 }
6042 if msglen < 0 {
6043 return ErrInvalidLengthGenerated
6044 }
6045 postIndex := iNdEx + msglen
6046 if postIndex > l {
6047 return io.ErrUnexpectedEOF
6048 }
6049 if err := m.CreationTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6050 return err
6051 }
6052 iNdEx = postIndex
6053 case 9:
6054 if wireType != 2 {
6055 return fmt.Errorf("proto: wrong wireType = %d for field DeletionTimestamp", wireType)
6056 }
6057 var msglen int
6058 for shift := uint(0); ; shift += 7 {
6059 if shift >= 64 {
6060 return ErrIntOverflowGenerated
6061 }
6062 if iNdEx >= l {
6063 return io.ErrUnexpectedEOF
6064 }
6065 b := dAtA[iNdEx]
6066 iNdEx++
6067 msglen |= (int(b) & 0x7F) << shift
6068 if b < 0x80 {
6069 break
6070 }
6071 }
6072 if msglen < 0 {
6073 return ErrInvalidLengthGenerated
6074 }
6075 postIndex := iNdEx + msglen
6076 if postIndex > l {
6077 return io.ErrUnexpectedEOF
6078 }
6079 if m.DeletionTimestamp == nil {
6080 m.DeletionTimestamp = &Time{}
6081 }
6082 if err := m.DeletionTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6083 return err
6084 }
6085 iNdEx = postIndex
6086 case 10:
6087 if wireType != 0 {
6088 return fmt.Errorf("proto: wrong wireType = %d for field DeletionGracePeriodSeconds", wireType)
6089 }
6090 var v int64
6091 for shift := uint(0); ; shift += 7 {
6092 if shift >= 64 {
6093 return ErrIntOverflowGenerated
6094 }
6095 if iNdEx >= l {
6096 return io.ErrUnexpectedEOF
6097 }
6098 b := dAtA[iNdEx]
6099 iNdEx++
6100 v |= (int64(b) & 0x7F) << shift
6101 if b < 0x80 {
6102 break
6103 }
6104 }
6105 m.DeletionGracePeriodSeconds = &v
6106 case 11:
6107 if wireType != 2 {
6108 return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
6109 }
6110 var msglen int
6111 for shift := uint(0); ; shift += 7 {
6112 if shift >= 64 {
6113 return ErrIntOverflowGenerated
6114 }
6115 if iNdEx >= l {
6116 return io.ErrUnexpectedEOF
6117 }
6118 b := dAtA[iNdEx]
6119 iNdEx++
6120 msglen |= (int(b) & 0x7F) << shift
6121 if b < 0x80 {
6122 break
6123 }
6124 }
6125 if msglen < 0 {
6126 return ErrInvalidLengthGenerated
6127 }
6128 postIndex := iNdEx + msglen
6129 if postIndex > l {
6130 return io.ErrUnexpectedEOF
6131 }
6132 if m.Labels == nil {
6133 m.Labels = make(map[string]string)
6134 }
6135 var mapkey string
6136 var mapvalue string
6137 for iNdEx < postIndex {
6138 entryPreIndex := iNdEx
6139 var wire uint64
6140 for shift := uint(0); ; shift += 7 {
6141 if shift >= 64 {
6142 return ErrIntOverflowGenerated
6143 }
6144 if iNdEx >= l {
6145 return io.ErrUnexpectedEOF
6146 }
6147 b := dAtA[iNdEx]
6148 iNdEx++
6149 wire |= (uint64(b) & 0x7F) << shift
6150 if b < 0x80 {
6151 break
6152 }
6153 }
6154 fieldNum := int32(wire >> 3)
6155 if fieldNum == 1 {
6156 var stringLenmapkey uint64
6157 for shift := uint(0); ; shift += 7 {
6158 if shift >= 64 {
6159 return ErrIntOverflowGenerated
6160 }
6161 if iNdEx >= l {
6162 return io.ErrUnexpectedEOF
6163 }
6164 b := dAtA[iNdEx]
6165 iNdEx++
6166 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6167 if b < 0x80 {
6168 break
6169 }
6170 }
6171 intStringLenmapkey := int(stringLenmapkey)
6172 if intStringLenmapkey < 0 {
6173 return ErrInvalidLengthGenerated
6174 }
6175 postStringIndexmapkey := iNdEx + intStringLenmapkey
6176 if postStringIndexmapkey > l {
6177 return io.ErrUnexpectedEOF
6178 }
6179 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6180 iNdEx = postStringIndexmapkey
6181 } else if fieldNum == 2 {
6182 var stringLenmapvalue uint64
6183 for shift := uint(0); ; shift += 7 {
6184 if shift >= 64 {
6185 return ErrIntOverflowGenerated
6186 }
6187 if iNdEx >= l {
6188 return io.ErrUnexpectedEOF
6189 }
6190 b := dAtA[iNdEx]
6191 iNdEx++
6192 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6193 if b < 0x80 {
6194 break
6195 }
6196 }
6197 intStringLenmapvalue := int(stringLenmapvalue)
6198 if intStringLenmapvalue < 0 {
6199 return ErrInvalidLengthGenerated
6200 }
6201 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6202 if postStringIndexmapvalue > l {
6203 return io.ErrUnexpectedEOF
6204 }
6205 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6206 iNdEx = postStringIndexmapvalue
6207 } else {
6208 iNdEx = entryPreIndex
6209 skippy, err := skipGenerated(dAtA[iNdEx:])
6210 if err != nil {
6211 return err
6212 }
6213 if skippy < 0 {
6214 return ErrInvalidLengthGenerated
6215 }
6216 if (iNdEx + skippy) > postIndex {
6217 return io.ErrUnexpectedEOF
6218 }
6219 iNdEx += skippy
6220 }
6221 }
6222 m.Labels[mapkey] = mapvalue
6223 iNdEx = postIndex
6224 case 12:
6225 if wireType != 2 {
6226 return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
6227 }
6228 var msglen int
6229 for shift := uint(0); ; shift += 7 {
6230 if shift >= 64 {
6231 return ErrIntOverflowGenerated
6232 }
6233 if iNdEx >= l {
6234 return io.ErrUnexpectedEOF
6235 }
6236 b := dAtA[iNdEx]
6237 iNdEx++
6238 msglen |= (int(b) & 0x7F) << shift
6239 if b < 0x80 {
6240 break
6241 }
6242 }
6243 if msglen < 0 {
6244 return ErrInvalidLengthGenerated
6245 }
6246 postIndex := iNdEx + msglen
6247 if postIndex > l {
6248 return io.ErrUnexpectedEOF
6249 }
6250 if m.Annotations == nil {
6251 m.Annotations = make(map[string]string)
6252 }
6253 var mapkey string
6254 var mapvalue string
6255 for iNdEx < postIndex {
6256 entryPreIndex := iNdEx
6257 var wire uint64
6258 for shift := uint(0); ; shift += 7 {
6259 if shift >= 64 {
6260 return ErrIntOverflowGenerated
6261 }
6262 if iNdEx >= l {
6263 return io.ErrUnexpectedEOF
6264 }
6265 b := dAtA[iNdEx]
6266 iNdEx++
6267 wire |= (uint64(b) & 0x7F) << shift
6268 if b < 0x80 {
6269 break
6270 }
6271 }
6272 fieldNum := int32(wire >> 3)
6273 if fieldNum == 1 {
6274 var stringLenmapkey uint64
6275 for shift := uint(0); ; shift += 7 {
6276 if shift >= 64 {
6277 return ErrIntOverflowGenerated
6278 }
6279 if iNdEx >= l {
6280 return io.ErrUnexpectedEOF
6281 }
6282 b := dAtA[iNdEx]
6283 iNdEx++
6284 stringLenmapkey |= (uint64(b) & 0x7F) << shift
6285 if b < 0x80 {
6286 break
6287 }
6288 }
6289 intStringLenmapkey := int(stringLenmapkey)
6290 if intStringLenmapkey < 0 {
6291 return ErrInvalidLengthGenerated
6292 }
6293 postStringIndexmapkey := iNdEx + intStringLenmapkey
6294 if postStringIndexmapkey > l {
6295 return io.ErrUnexpectedEOF
6296 }
6297 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
6298 iNdEx = postStringIndexmapkey
6299 } else if fieldNum == 2 {
6300 var stringLenmapvalue uint64
6301 for shift := uint(0); ; shift += 7 {
6302 if shift >= 64 {
6303 return ErrIntOverflowGenerated
6304 }
6305 if iNdEx >= l {
6306 return io.ErrUnexpectedEOF
6307 }
6308 b := dAtA[iNdEx]
6309 iNdEx++
6310 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
6311 if b < 0x80 {
6312 break
6313 }
6314 }
6315 intStringLenmapvalue := int(stringLenmapvalue)
6316 if intStringLenmapvalue < 0 {
6317 return ErrInvalidLengthGenerated
6318 }
6319 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
6320 if postStringIndexmapvalue > l {
6321 return io.ErrUnexpectedEOF
6322 }
6323 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
6324 iNdEx = postStringIndexmapvalue
6325 } else {
6326 iNdEx = entryPreIndex
6327 skippy, err := skipGenerated(dAtA[iNdEx:])
6328 if err != nil {
6329 return err
6330 }
6331 if skippy < 0 {
6332 return ErrInvalidLengthGenerated
6333 }
6334 if (iNdEx + skippy) > postIndex {
6335 return io.ErrUnexpectedEOF
6336 }
6337 iNdEx += skippy
6338 }
6339 }
6340 m.Annotations[mapkey] = mapvalue
6341 iNdEx = postIndex
6342 case 13:
6343 if wireType != 2 {
6344 return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType)
6345 }
6346 var msglen int
6347 for shift := uint(0); ; shift += 7 {
6348 if shift >= 64 {
6349 return ErrIntOverflowGenerated
6350 }
6351 if iNdEx >= l {
6352 return io.ErrUnexpectedEOF
6353 }
6354 b := dAtA[iNdEx]
6355 iNdEx++
6356 msglen |= (int(b) & 0x7F) << shift
6357 if b < 0x80 {
6358 break
6359 }
6360 }
6361 if msglen < 0 {
6362 return ErrInvalidLengthGenerated
6363 }
6364 postIndex := iNdEx + msglen
6365 if postIndex > l {
6366 return io.ErrUnexpectedEOF
6367 }
6368 m.OwnerReferences = append(m.OwnerReferences, OwnerReference{})
6369 if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6370 return err
6371 }
6372 iNdEx = postIndex
6373 case 14:
6374 if wireType != 2 {
6375 return fmt.Errorf("proto: wrong wireType = %d for field Finalizers", wireType)
6376 }
6377 var stringLen uint64
6378 for shift := uint(0); ; shift += 7 {
6379 if shift >= 64 {
6380 return ErrIntOverflowGenerated
6381 }
6382 if iNdEx >= l {
6383 return io.ErrUnexpectedEOF
6384 }
6385 b := dAtA[iNdEx]
6386 iNdEx++
6387 stringLen |= (uint64(b) & 0x7F) << shift
6388 if b < 0x80 {
6389 break
6390 }
6391 }
6392 intStringLen := int(stringLen)
6393 if intStringLen < 0 {
6394 return ErrInvalidLengthGenerated
6395 }
6396 postIndex := iNdEx + intStringLen
6397 if postIndex > l {
6398 return io.ErrUnexpectedEOF
6399 }
6400 m.Finalizers = append(m.Finalizers, string(dAtA[iNdEx:postIndex]))
6401 iNdEx = postIndex
6402 case 15:
6403 if wireType != 2 {
6404 return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType)
6405 }
6406 var stringLen uint64
6407 for shift := uint(0); ; shift += 7 {
6408 if shift >= 64 {
6409 return ErrIntOverflowGenerated
6410 }
6411 if iNdEx >= l {
6412 return io.ErrUnexpectedEOF
6413 }
6414 b := dAtA[iNdEx]
6415 iNdEx++
6416 stringLen |= (uint64(b) & 0x7F) << shift
6417 if b < 0x80 {
6418 break
6419 }
6420 }
6421 intStringLen := int(stringLen)
6422 if intStringLen < 0 {
6423 return ErrInvalidLengthGenerated
6424 }
6425 postIndex := iNdEx + intStringLen
6426 if postIndex > l {
6427 return io.ErrUnexpectedEOF
6428 }
6429 m.ClusterName = string(dAtA[iNdEx:postIndex])
6430 iNdEx = postIndex
6431 case 16:
6432 if wireType != 2 {
6433 return fmt.Errorf("proto: wrong wireType = %d for field Initializers", wireType)
6434 }
6435 var msglen int
6436 for shift := uint(0); ; shift += 7 {
6437 if shift >= 64 {
6438 return ErrIntOverflowGenerated
6439 }
6440 if iNdEx >= l {
6441 return io.ErrUnexpectedEOF
6442 }
6443 b := dAtA[iNdEx]
6444 iNdEx++
6445 msglen |= (int(b) & 0x7F) << shift
6446 if b < 0x80 {
6447 break
6448 }
6449 }
6450 if msglen < 0 {
6451 return ErrInvalidLengthGenerated
6452 }
6453 postIndex := iNdEx + msglen
6454 if postIndex > l {
6455 return io.ErrUnexpectedEOF
6456 }
6457 if m.Initializers == nil {
6458 m.Initializers = &Initializers{}
6459 }
6460 if err := m.Initializers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
6461 return err
6462 }
6463 iNdEx = postIndex
6464 default:
6465 iNdEx = preIndex
6466 skippy, err := skipGenerated(dAtA[iNdEx:])
6467 if err != nil {
6468 return err
6469 }
6470 if skippy < 0 {
6471 return ErrInvalidLengthGenerated
6472 }
6473 if (iNdEx + skippy) > l {
6474 return io.ErrUnexpectedEOF
6475 }
6476 iNdEx += skippy
6477 }
6478 }
6479
6480 if iNdEx > l {
6481 return io.ErrUnexpectedEOF
6482 }
6483 return nil
6484}
6485func (m *OwnerReference) Unmarshal(dAtA []byte) error {
6486 l := len(dAtA)
6487 iNdEx := 0
6488 for iNdEx < l {
6489 preIndex := iNdEx
6490 var wire uint64
6491 for shift := uint(0); ; shift += 7 {
6492 if shift >= 64 {
6493 return ErrIntOverflowGenerated
6494 }
6495 if iNdEx >= l {
6496 return io.ErrUnexpectedEOF
6497 }
6498 b := dAtA[iNdEx]
6499 iNdEx++
6500 wire |= (uint64(b) & 0x7F) << shift
6501 if b < 0x80 {
6502 break
6503 }
6504 }
6505 fieldNum := int32(wire >> 3)
6506 wireType := int(wire & 0x7)
6507 if wireType == 4 {
6508 return fmt.Errorf("proto: OwnerReference: wiretype end group for non-group")
6509 }
6510 if fieldNum <= 0 {
6511 return fmt.Errorf("proto: OwnerReference: illegal tag %d (wire type %d)", fieldNum, wire)
6512 }
6513 switch fieldNum {
6514 case 1:
6515 if wireType != 2 {
6516 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
6517 }
6518 var stringLen uint64
6519 for shift := uint(0); ; shift += 7 {
6520 if shift >= 64 {
6521 return ErrIntOverflowGenerated
6522 }
6523 if iNdEx >= l {
6524 return io.ErrUnexpectedEOF
6525 }
6526 b := dAtA[iNdEx]
6527 iNdEx++
6528 stringLen |= (uint64(b) & 0x7F) << shift
6529 if b < 0x80 {
6530 break
6531 }
6532 }
6533 intStringLen := int(stringLen)
6534 if intStringLen < 0 {
6535 return ErrInvalidLengthGenerated
6536 }
6537 postIndex := iNdEx + intStringLen
6538 if postIndex > l {
6539 return io.ErrUnexpectedEOF
6540 }
6541 m.Kind = string(dAtA[iNdEx:postIndex])
6542 iNdEx = postIndex
6543 case 3:
6544 if wireType != 2 {
6545 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
6546 }
6547 var stringLen uint64
6548 for shift := uint(0); ; shift += 7 {
6549 if shift >= 64 {
6550 return ErrIntOverflowGenerated
6551 }
6552 if iNdEx >= l {
6553 return io.ErrUnexpectedEOF
6554 }
6555 b := dAtA[iNdEx]
6556 iNdEx++
6557 stringLen |= (uint64(b) & 0x7F) << shift
6558 if b < 0x80 {
6559 break
6560 }
6561 }
6562 intStringLen := int(stringLen)
6563 if intStringLen < 0 {
6564 return ErrInvalidLengthGenerated
6565 }
6566 postIndex := iNdEx + intStringLen
6567 if postIndex > l {
6568 return io.ErrUnexpectedEOF
6569 }
6570 m.Name = string(dAtA[iNdEx:postIndex])
6571 iNdEx = postIndex
6572 case 4:
6573 if wireType != 2 {
6574 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
6575 }
6576 var stringLen uint64
6577 for shift := uint(0); ; shift += 7 {
6578 if shift >= 64 {
6579 return ErrIntOverflowGenerated
6580 }
6581 if iNdEx >= l {
6582 return io.ErrUnexpectedEOF
6583 }
6584 b := dAtA[iNdEx]
6585 iNdEx++
6586 stringLen |= (uint64(b) & 0x7F) << shift
6587 if b < 0x80 {
6588 break
6589 }
6590 }
6591 intStringLen := int(stringLen)
6592 if intStringLen < 0 {
6593 return ErrInvalidLengthGenerated
6594 }
6595 postIndex := iNdEx + intStringLen
6596 if postIndex > l {
6597 return io.ErrUnexpectedEOF
6598 }
6599 m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
6600 iNdEx = postIndex
6601 case 5:
6602 if wireType != 2 {
6603 return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
6604 }
6605 var stringLen uint64
6606 for shift := uint(0); ; shift += 7 {
6607 if shift >= 64 {
6608 return ErrIntOverflowGenerated
6609 }
6610 if iNdEx >= l {
6611 return io.ErrUnexpectedEOF
6612 }
6613 b := dAtA[iNdEx]
6614 iNdEx++
6615 stringLen |= (uint64(b) & 0x7F) << shift
6616 if b < 0x80 {
6617 break
6618 }
6619 }
6620 intStringLen := int(stringLen)
6621 if intStringLen < 0 {
6622 return ErrInvalidLengthGenerated
6623 }
6624 postIndex := iNdEx + intStringLen
6625 if postIndex > l {
6626 return io.ErrUnexpectedEOF
6627 }
6628 m.APIVersion = string(dAtA[iNdEx:postIndex])
6629 iNdEx = postIndex
6630 case 6:
6631 if wireType != 0 {
6632 return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
6633 }
6634 var v int
6635 for shift := uint(0); ; shift += 7 {
6636 if shift >= 64 {
6637 return ErrIntOverflowGenerated
6638 }
6639 if iNdEx >= l {
6640 return io.ErrUnexpectedEOF
6641 }
6642 b := dAtA[iNdEx]
6643 iNdEx++
6644 v |= (int(b) & 0x7F) << shift
6645 if b < 0x80 {
6646 break
6647 }
6648 }
6649 b := bool(v != 0)
6650 m.Controller = &b
6651 case 7:
6652 if wireType != 0 {
6653 return fmt.Errorf("proto: wrong wireType = %d for field BlockOwnerDeletion", wireType)
6654 }
6655 var v int
6656 for shift := uint(0); ; shift += 7 {
6657 if shift >= 64 {
6658 return ErrIntOverflowGenerated
6659 }
6660 if iNdEx >= l {
6661 return io.ErrUnexpectedEOF
6662 }
6663 b := dAtA[iNdEx]
6664 iNdEx++
6665 v |= (int(b) & 0x7F) << shift
6666 if b < 0x80 {
6667 break
6668 }
6669 }
6670 b := bool(v != 0)
6671 m.BlockOwnerDeletion = &b
6672 default:
6673 iNdEx = preIndex
6674 skippy, err := skipGenerated(dAtA[iNdEx:])
6675 if err != nil {
6676 return err
6677 }
6678 if skippy < 0 {
6679 return ErrInvalidLengthGenerated
6680 }
6681 if (iNdEx + skippy) > l {
6682 return io.ErrUnexpectedEOF
6683 }
6684 iNdEx += skippy
6685 }
6686 }
6687
6688 if iNdEx > l {
6689 return io.ErrUnexpectedEOF
6690 }
6691 return nil
6692}
6693func (m *Patch) Unmarshal(dAtA []byte) error {
6694 l := len(dAtA)
6695 iNdEx := 0
6696 for iNdEx < l {
6697 preIndex := iNdEx
6698 var wire uint64
6699 for shift := uint(0); ; shift += 7 {
6700 if shift >= 64 {
6701 return ErrIntOverflowGenerated
6702 }
6703 if iNdEx >= l {
6704 return io.ErrUnexpectedEOF
6705 }
6706 b := dAtA[iNdEx]
6707 iNdEx++
6708 wire |= (uint64(b) & 0x7F) << shift
6709 if b < 0x80 {
6710 break
6711 }
6712 }
6713 fieldNum := int32(wire >> 3)
6714 wireType := int(wire & 0x7)
6715 if wireType == 4 {
6716 return fmt.Errorf("proto: Patch: wiretype end group for non-group")
6717 }
6718 if fieldNum <= 0 {
6719 return fmt.Errorf("proto: Patch: illegal tag %d (wire type %d)", fieldNum, wire)
6720 }
6721 switch fieldNum {
6722 default:
6723 iNdEx = preIndex
6724 skippy, err := skipGenerated(dAtA[iNdEx:])
6725 if err != nil {
6726 return err
6727 }
6728 if skippy < 0 {
6729 return ErrInvalidLengthGenerated
6730 }
6731 if (iNdEx + skippy) > l {
6732 return io.ErrUnexpectedEOF
6733 }
6734 iNdEx += skippy
6735 }
6736 }
6737
6738 if iNdEx > l {
6739 return io.ErrUnexpectedEOF
6740 }
6741 return nil
6742}
6743func (m *Preconditions) Unmarshal(dAtA []byte) error {
6744 l := len(dAtA)
6745 iNdEx := 0
6746 for iNdEx < l {
6747 preIndex := iNdEx
6748 var wire uint64
6749 for shift := uint(0); ; shift += 7 {
6750 if shift >= 64 {
6751 return ErrIntOverflowGenerated
6752 }
6753 if iNdEx >= l {
6754 return io.ErrUnexpectedEOF
6755 }
6756 b := dAtA[iNdEx]
6757 iNdEx++
6758 wire |= (uint64(b) & 0x7F) << shift
6759 if b < 0x80 {
6760 break
6761 }
6762 }
6763 fieldNum := int32(wire >> 3)
6764 wireType := int(wire & 0x7)
6765 if wireType == 4 {
6766 return fmt.Errorf("proto: Preconditions: wiretype end group for non-group")
6767 }
6768 if fieldNum <= 0 {
6769 return fmt.Errorf("proto: Preconditions: illegal tag %d (wire type %d)", fieldNum, wire)
6770 }
6771 switch fieldNum {
6772 case 1:
6773 if wireType != 2 {
6774 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
6775 }
6776 var stringLen uint64
6777 for shift := uint(0); ; shift += 7 {
6778 if shift >= 64 {
6779 return ErrIntOverflowGenerated
6780 }
6781 if iNdEx >= l {
6782 return io.ErrUnexpectedEOF
6783 }
6784 b := dAtA[iNdEx]
6785 iNdEx++
6786 stringLen |= (uint64(b) & 0x7F) << shift
6787 if b < 0x80 {
6788 break
6789 }
6790 }
6791 intStringLen := int(stringLen)
6792 if intStringLen < 0 {
6793 return ErrInvalidLengthGenerated
6794 }
6795 postIndex := iNdEx + intStringLen
6796 if postIndex > l {
6797 return io.ErrUnexpectedEOF
6798 }
6799 s := k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
6800 m.UID = &s
6801 iNdEx = postIndex
6802 default:
6803 iNdEx = preIndex
6804 skippy, err := skipGenerated(dAtA[iNdEx:])
6805 if err != nil {
6806 return err
6807 }
6808 if skippy < 0 {
6809 return ErrInvalidLengthGenerated
6810 }
6811 if (iNdEx + skippy) > l {
6812 return io.ErrUnexpectedEOF
6813 }
6814 iNdEx += skippy
6815 }
6816 }
6817
6818 if iNdEx > l {
6819 return io.ErrUnexpectedEOF
6820 }
6821 return nil
6822}
6823func (m *RootPaths) Unmarshal(dAtA []byte) error {
6824 l := len(dAtA)
6825 iNdEx := 0
6826 for iNdEx < l {
6827 preIndex := iNdEx
6828 var wire uint64
6829 for shift := uint(0); ; shift += 7 {
6830 if shift >= 64 {
6831 return ErrIntOverflowGenerated
6832 }
6833 if iNdEx >= l {
6834 return io.ErrUnexpectedEOF
6835 }
6836 b := dAtA[iNdEx]
6837 iNdEx++
6838 wire |= (uint64(b) & 0x7F) << shift
6839 if b < 0x80 {
6840 break
6841 }
6842 }
6843 fieldNum := int32(wire >> 3)
6844 wireType := int(wire & 0x7)
6845 if wireType == 4 {
6846 return fmt.Errorf("proto: RootPaths: wiretype end group for non-group")
6847 }
6848 if fieldNum <= 0 {
6849 return fmt.Errorf("proto: RootPaths: illegal tag %d (wire type %d)", fieldNum, wire)
6850 }
6851 switch fieldNum {
6852 case 1:
6853 if wireType != 2 {
6854 return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
6855 }
6856 var stringLen uint64
6857 for shift := uint(0); ; shift += 7 {
6858 if shift >= 64 {
6859 return ErrIntOverflowGenerated
6860 }
6861 if iNdEx >= l {
6862 return io.ErrUnexpectedEOF
6863 }
6864 b := dAtA[iNdEx]
6865 iNdEx++
6866 stringLen |= (uint64(b) & 0x7F) << shift
6867 if b < 0x80 {
6868 break
6869 }
6870 }
6871 intStringLen := int(stringLen)
6872 if intStringLen < 0 {
6873 return ErrInvalidLengthGenerated
6874 }
6875 postIndex := iNdEx + intStringLen
6876 if postIndex > l {
6877 return io.ErrUnexpectedEOF
6878 }
6879 m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex]))
6880 iNdEx = postIndex
6881 default:
6882 iNdEx = preIndex
6883 skippy, err := skipGenerated(dAtA[iNdEx:])
6884 if err != nil {
6885 return err
6886 }
6887 if skippy < 0 {
6888 return ErrInvalidLengthGenerated
6889 }
6890 if (iNdEx + skippy) > l {
6891 return io.ErrUnexpectedEOF
6892 }
6893 iNdEx += skippy
6894 }
6895 }
6896
6897 if iNdEx > l {
6898 return io.ErrUnexpectedEOF
6899 }
6900 return nil
6901}
6902func (m *ServerAddressByClientCIDR) Unmarshal(dAtA []byte) error {
6903 l := len(dAtA)
6904 iNdEx := 0
6905 for iNdEx < l {
6906 preIndex := iNdEx
6907 var wire uint64
6908 for shift := uint(0); ; shift += 7 {
6909 if shift >= 64 {
6910 return ErrIntOverflowGenerated
6911 }
6912 if iNdEx >= l {
6913 return io.ErrUnexpectedEOF
6914 }
6915 b := dAtA[iNdEx]
6916 iNdEx++
6917 wire |= (uint64(b) & 0x7F) << shift
6918 if b < 0x80 {
6919 break
6920 }
6921 }
6922 fieldNum := int32(wire >> 3)
6923 wireType := int(wire & 0x7)
6924 if wireType == 4 {
6925 return fmt.Errorf("proto: ServerAddressByClientCIDR: wiretype end group for non-group")
6926 }
6927 if fieldNum <= 0 {
6928 return fmt.Errorf("proto: ServerAddressByClientCIDR: illegal tag %d (wire type %d)", fieldNum, wire)
6929 }
6930 switch fieldNum {
6931 case 1:
6932 if wireType != 2 {
6933 return fmt.Errorf("proto: wrong wireType = %d for field ClientCIDR", wireType)
6934 }
6935 var stringLen uint64
6936 for shift := uint(0); ; shift += 7 {
6937 if shift >= 64 {
6938 return ErrIntOverflowGenerated
6939 }
6940 if iNdEx >= l {
6941 return io.ErrUnexpectedEOF
6942 }
6943 b := dAtA[iNdEx]
6944 iNdEx++
6945 stringLen |= (uint64(b) & 0x7F) << shift
6946 if b < 0x80 {
6947 break
6948 }
6949 }
6950 intStringLen := int(stringLen)
6951 if intStringLen < 0 {
6952 return ErrInvalidLengthGenerated
6953 }
6954 postIndex := iNdEx + intStringLen
6955 if postIndex > l {
6956 return io.ErrUnexpectedEOF
6957 }
6958 m.ClientCIDR = string(dAtA[iNdEx:postIndex])
6959 iNdEx = postIndex
6960 case 2:
6961 if wireType != 2 {
6962 return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", wireType)
6963 }
6964 var stringLen uint64
6965 for shift := uint(0); ; shift += 7 {
6966 if shift >= 64 {
6967 return ErrIntOverflowGenerated
6968 }
6969 if iNdEx >= l {
6970 return io.ErrUnexpectedEOF
6971 }
6972 b := dAtA[iNdEx]
6973 iNdEx++
6974 stringLen |= (uint64(b) & 0x7F) << shift
6975 if b < 0x80 {
6976 break
6977 }
6978 }
6979 intStringLen := int(stringLen)
6980 if intStringLen < 0 {
6981 return ErrInvalidLengthGenerated
6982 }
6983 postIndex := iNdEx + intStringLen
6984 if postIndex > l {
6985 return io.ErrUnexpectedEOF
6986 }
6987 m.ServerAddress = string(dAtA[iNdEx:postIndex])
6988 iNdEx = postIndex
6989 default:
6990 iNdEx = preIndex
6991 skippy, err := skipGenerated(dAtA[iNdEx:])
6992 if err != nil {
6993 return err
6994 }
6995 if skippy < 0 {
6996 return ErrInvalidLengthGenerated
6997 }
6998 if (iNdEx + skippy) > l {
6999 return io.ErrUnexpectedEOF
7000 }
7001 iNdEx += skippy
7002 }
7003 }
7004
7005 if iNdEx > l {
7006 return io.ErrUnexpectedEOF
7007 }
7008 return nil
7009}
7010func (m *Status) Unmarshal(dAtA []byte) error {
7011 l := len(dAtA)
7012 iNdEx := 0
7013 for iNdEx < l {
7014 preIndex := iNdEx
7015 var wire uint64
7016 for shift := uint(0); ; shift += 7 {
7017 if shift >= 64 {
7018 return ErrIntOverflowGenerated
7019 }
7020 if iNdEx >= l {
7021 return io.ErrUnexpectedEOF
7022 }
7023 b := dAtA[iNdEx]
7024 iNdEx++
7025 wire |= (uint64(b) & 0x7F) << shift
7026 if b < 0x80 {
7027 break
7028 }
7029 }
7030 fieldNum := int32(wire >> 3)
7031 wireType := int(wire & 0x7)
7032 if wireType == 4 {
7033 return fmt.Errorf("proto: Status: wiretype end group for non-group")
7034 }
7035 if fieldNum <= 0 {
7036 return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
7037 }
7038 switch fieldNum {
7039 case 1:
7040 if wireType != 2 {
7041 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
7042 }
7043 var msglen int
7044 for shift := uint(0); ; shift += 7 {
7045 if shift >= 64 {
7046 return ErrIntOverflowGenerated
7047 }
7048 if iNdEx >= l {
7049 return io.ErrUnexpectedEOF
7050 }
7051 b := dAtA[iNdEx]
7052 iNdEx++
7053 msglen |= (int(b) & 0x7F) << shift
7054 if b < 0x80 {
7055 break
7056 }
7057 }
7058 if msglen < 0 {
7059 return ErrInvalidLengthGenerated
7060 }
7061 postIndex := iNdEx + msglen
7062 if postIndex > l {
7063 return io.ErrUnexpectedEOF
7064 }
7065 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7066 return err
7067 }
7068 iNdEx = postIndex
7069 case 2:
7070 if wireType != 2 {
7071 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
7072 }
7073 var stringLen uint64
7074 for shift := uint(0); ; shift += 7 {
7075 if shift >= 64 {
7076 return ErrIntOverflowGenerated
7077 }
7078 if iNdEx >= l {
7079 return io.ErrUnexpectedEOF
7080 }
7081 b := dAtA[iNdEx]
7082 iNdEx++
7083 stringLen |= (uint64(b) & 0x7F) << shift
7084 if b < 0x80 {
7085 break
7086 }
7087 }
7088 intStringLen := int(stringLen)
7089 if intStringLen < 0 {
7090 return ErrInvalidLengthGenerated
7091 }
7092 postIndex := iNdEx + intStringLen
7093 if postIndex > l {
7094 return io.ErrUnexpectedEOF
7095 }
7096 m.Status = string(dAtA[iNdEx:postIndex])
7097 iNdEx = postIndex
7098 case 3:
7099 if wireType != 2 {
7100 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
7101 }
7102 var stringLen uint64
7103 for shift := uint(0); ; shift += 7 {
7104 if shift >= 64 {
7105 return ErrIntOverflowGenerated
7106 }
7107 if iNdEx >= l {
7108 return io.ErrUnexpectedEOF
7109 }
7110 b := dAtA[iNdEx]
7111 iNdEx++
7112 stringLen |= (uint64(b) & 0x7F) << shift
7113 if b < 0x80 {
7114 break
7115 }
7116 }
7117 intStringLen := int(stringLen)
7118 if intStringLen < 0 {
7119 return ErrInvalidLengthGenerated
7120 }
7121 postIndex := iNdEx + intStringLen
7122 if postIndex > l {
7123 return io.ErrUnexpectedEOF
7124 }
7125 m.Message = string(dAtA[iNdEx:postIndex])
7126 iNdEx = postIndex
7127 case 4:
7128 if wireType != 2 {
7129 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
7130 }
7131 var stringLen uint64
7132 for shift := uint(0); ; shift += 7 {
7133 if shift >= 64 {
7134 return ErrIntOverflowGenerated
7135 }
7136 if iNdEx >= l {
7137 return io.ErrUnexpectedEOF
7138 }
7139 b := dAtA[iNdEx]
7140 iNdEx++
7141 stringLen |= (uint64(b) & 0x7F) << shift
7142 if b < 0x80 {
7143 break
7144 }
7145 }
7146 intStringLen := int(stringLen)
7147 if intStringLen < 0 {
7148 return ErrInvalidLengthGenerated
7149 }
7150 postIndex := iNdEx + intStringLen
7151 if postIndex > l {
7152 return io.ErrUnexpectedEOF
7153 }
7154 m.Reason = StatusReason(dAtA[iNdEx:postIndex])
7155 iNdEx = postIndex
7156 case 5:
7157 if wireType != 2 {
7158 return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
7159 }
7160 var msglen int
7161 for shift := uint(0); ; shift += 7 {
7162 if shift >= 64 {
7163 return ErrIntOverflowGenerated
7164 }
7165 if iNdEx >= l {
7166 return io.ErrUnexpectedEOF
7167 }
7168 b := dAtA[iNdEx]
7169 iNdEx++
7170 msglen |= (int(b) & 0x7F) << shift
7171 if b < 0x80 {
7172 break
7173 }
7174 }
7175 if msglen < 0 {
7176 return ErrInvalidLengthGenerated
7177 }
7178 postIndex := iNdEx + msglen
7179 if postIndex > l {
7180 return io.ErrUnexpectedEOF
7181 }
7182 if m.Details == nil {
7183 m.Details = &StatusDetails{}
7184 }
7185 if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7186 return err
7187 }
7188 iNdEx = postIndex
7189 case 6:
7190 if wireType != 0 {
7191 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
7192 }
7193 m.Code = 0
7194 for shift := uint(0); ; shift += 7 {
7195 if shift >= 64 {
7196 return ErrIntOverflowGenerated
7197 }
7198 if iNdEx >= l {
7199 return io.ErrUnexpectedEOF
7200 }
7201 b := dAtA[iNdEx]
7202 iNdEx++
7203 m.Code |= (int32(b) & 0x7F) << shift
7204 if b < 0x80 {
7205 break
7206 }
7207 }
7208 default:
7209 iNdEx = preIndex
7210 skippy, err := skipGenerated(dAtA[iNdEx:])
7211 if err != nil {
7212 return err
7213 }
7214 if skippy < 0 {
7215 return ErrInvalidLengthGenerated
7216 }
7217 if (iNdEx + skippy) > l {
7218 return io.ErrUnexpectedEOF
7219 }
7220 iNdEx += skippy
7221 }
7222 }
7223
7224 if iNdEx > l {
7225 return io.ErrUnexpectedEOF
7226 }
7227 return nil
7228}
7229func (m *StatusCause) Unmarshal(dAtA []byte) error {
7230 l := len(dAtA)
7231 iNdEx := 0
7232 for iNdEx < l {
7233 preIndex := iNdEx
7234 var wire uint64
7235 for shift := uint(0); ; shift += 7 {
7236 if shift >= 64 {
7237 return ErrIntOverflowGenerated
7238 }
7239 if iNdEx >= l {
7240 return io.ErrUnexpectedEOF
7241 }
7242 b := dAtA[iNdEx]
7243 iNdEx++
7244 wire |= (uint64(b) & 0x7F) << shift
7245 if b < 0x80 {
7246 break
7247 }
7248 }
7249 fieldNum := int32(wire >> 3)
7250 wireType := int(wire & 0x7)
7251 if wireType == 4 {
7252 return fmt.Errorf("proto: StatusCause: wiretype end group for non-group")
7253 }
7254 if fieldNum <= 0 {
7255 return fmt.Errorf("proto: StatusCause: illegal tag %d (wire type %d)", fieldNum, wire)
7256 }
7257 switch fieldNum {
7258 case 1:
7259 if wireType != 2 {
7260 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7261 }
7262 var stringLen uint64
7263 for shift := uint(0); ; shift += 7 {
7264 if shift >= 64 {
7265 return ErrIntOverflowGenerated
7266 }
7267 if iNdEx >= l {
7268 return io.ErrUnexpectedEOF
7269 }
7270 b := dAtA[iNdEx]
7271 iNdEx++
7272 stringLen |= (uint64(b) & 0x7F) << shift
7273 if b < 0x80 {
7274 break
7275 }
7276 }
7277 intStringLen := int(stringLen)
7278 if intStringLen < 0 {
7279 return ErrInvalidLengthGenerated
7280 }
7281 postIndex := iNdEx + intStringLen
7282 if postIndex > l {
7283 return io.ErrUnexpectedEOF
7284 }
7285 m.Type = CauseType(dAtA[iNdEx:postIndex])
7286 iNdEx = postIndex
7287 case 2:
7288 if wireType != 2 {
7289 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
7290 }
7291 var stringLen uint64
7292 for shift := uint(0); ; shift += 7 {
7293 if shift >= 64 {
7294 return ErrIntOverflowGenerated
7295 }
7296 if iNdEx >= l {
7297 return io.ErrUnexpectedEOF
7298 }
7299 b := dAtA[iNdEx]
7300 iNdEx++
7301 stringLen |= (uint64(b) & 0x7F) << shift
7302 if b < 0x80 {
7303 break
7304 }
7305 }
7306 intStringLen := int(stringLen)
7307 if intStringLen < 0 {
7308 return ErrInvalidLengthGenerated
7309 }
7310 postIndex := iNdEx + intStringLen
7311 if postIndex > l {
7312 return io.ErrUnexpectedEOF
7313 }
7314 m.Message = string(dAtA[iNdEx:postIndex])
7315 iNdEx = postIndex
7316 case 3:
7317 if wireType != 2 {
7318 return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
7319 }
7320 var stringLen uint64
7321 for shift := uint(0); ; shift += 7 {
7322 if shift >= 64 {
7323 return ErrIntOverflowGenerated
7324 }
7325 if iNdEx >= l {
7326 return io.ErrUnexpectedEOF
7327 }
7328 b := dAtA[iNdEx]
7329 iNdEx++
7330 stringLen |= (uint64(b) & 0x7F) << shift
7331 if b < 0x80 {
7332 break
7333 }
7334 }
7335 intStringLen := int(stringLen)
7336 if intStringLen < 0 {
7337 return ErrInvalidLengthGenerated
7338 }
7339 postIndex := iNdEx + intStringLen
7340 if postIndex > l {
7341 return io.ErrUnexpectedEOF
7342 }
7343 m.Field = string(dAtA[iNdEx:postIndex])
7344 iNdEx = postIndex
7345 default:
7346 iNdEx = preIndex
7347 skippy, err := skipGenerated(dAtA[iNdEx:])
7348 if err != nil {
7349 return err
7350 }
7351 if skippy < 0 {
7352 return ErrInvalidLengthGenerated
7353 }
7354 if (iNdEx + skippy) > l {
7355 return io.ErrUnexpectedEOF
7356 }
7357 iNdEx += skippy
7358 }
7359 }
7360
7361 if iNdEx > l {
7362 return io.ErrUnexpectedEOF
7363 }
7364 return nil
7365}
7366func (m *StatusDetails) Unmarshal(dAtA []byte) error {
7367 l := len(dAtA)
7368 iNdEx := 0
7369 for iNdEx < l {
7370 preIndex := iNdEx
7371 var wire uint64
7372 for shift := uint(0); ; shift += 7 {
7373 if shift >= 64 {
7374 return ErrIntOverflowGenerated
7375 }
7376 if iNdEx >= l {
7377 return io.ErrUnexpectedEOF
7378 }
7379 b := dAtA[iNdEx]
7380 iNdEx++
7381 wire |= (uint64(b) & 0x7F) << shift
7382 if b < 0x80 {
7383 break
7384 }
7385 }
7386 fieldNum := int32(wire >> 3)
7387 wireType := int(wire & 0x7)
7388 if wireType == 4 {
7389 return fmt.Errorf("proto: StatusDetails: wiretype end group for non-group")
7390 }
7391 if fieldNum <= 0 {
7392 return fmt.Errorf("proto: StatusDetails: illegal tag %d (wire type %d)", fieldNum, wire)
7393 }
7394 switch fieldNum {
7395 case 1:
7396 if wireType != 2 {
7397 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
7398 }
7399 var stringLen uint64
7400 for shift := uint(0); ; shift += 7 {
7401 if shift >= 64 {
7402 return ErrIntOverflowGenerated
7403 }
7404 if iNdEx >= l {
7405 return io.ErrUnexpectedEOF
7406 }
7407 b := dAtA[iNdEx]
7408 iNdEx++
7409 stringLen |= (uint64(b) & 0x7F) << shift
7410 if b < 0x80 {
7411 break
7412 }
7413 }
7414 intStringLen := int(stringLen)
7415 if intStringLen < 0 {
7416 return ErrInvalidLengthGenerated
7417 }
7418 postIndex := iNdEx + intStringLen
7419 if postIndex > l {
7420 return io.ErrUnexpectedEOF
7421 }
7422 m.Name = string(dAtA[iNdEx:postIndex])
7423 iNdEx = postIndex
7424 case 2:
7425 if wireType != 2 {
7426 return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
7427 }
7428 var stringLen uint64
7429 for shift := uint(0); ; shift += 7 {
7430 if shift >= 64 {
7431 return ErrIntOverflowGenerated
7432 }
7433 if iNdEx >= l {
7434 return io.ErrUnexpectedEOF
7435 }
7436 b := dAtA[iNdEx]
7437 iNdEx++
7438 stringLen |= (uint64(b) & 0x7F) << shift
7439 if b < 0x80 {
7440 break
7441 }
7442 }
7443 intStringLen := int(stringLen)
7444 if intStringLen < 0 {
7445 return ErrInvalidLengthGenerated
7446 }
7447 postIndex := iNdEx + intStringLen
7448 if postIndex > l {
7449 return io.ErrUnexpectedEOF
7450 }
7451 m.Group = string(dAtA[iNdEx:postIndex])
7452 iNdEx = postIndex
7453 case 3:
7454 if wireType != 2 {
7455 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
7456 }
7457 var stringLen uint64
7458 for shift := uint(0); ; shift += 7 {
7459 if shift >= 64 {
7460 return ErrIntOverflowGenerated
7461 }
7462 if iNdEx >= l {
7463 return io.ErrUnexpectedEOF
7464 }
7465 b := dAtA[iNdEx]
7466 iNdEx++
7467 stringLen |= (uint64(b) & 0x7F) << shift
7468 if b < 0x80 {
7469 break
7470 }
7471 }
7472 intStringLen := int(stringLen)
7473 if intStringLen < 0 {
7474 return ErrInvalidLengthGenerated
7475 }
7476 postIndex := iNdEx + intStringLen
7477 if postIndex > l {
7478 return io.ErrUnexpectedEOF
7479 }
7480 m.Kind = string(dAtA[iNdEx:postIndex])
7481 iNdEx = postIndex
7482 case 4:
7483 if wireType != 2 {
7484 return fmt.Errorf("proto: wrong wireType = %d for field Causes", wireType)
7485 }
7486 var msglen int
7487 for shift := uint(0); ; shift += 7 {
7488 if shift >= 64 {
7489 return ErrIntOverflowGenerated
7490 }
7491 if iNdEx >= l {
7492 return io.ErrUnexpectedEOF
7493 }
7494 b := dAtA[iNdEx]
7495 iNdEx++
7496 msglen |= (int(b) & 0x7F) << shift
7497 if b < 0x80 {
7498 break
7499 }
7500 }
7501 if msglen < 0 {
7502 return ErrInvalidLengthGenerated
7503 }
7504 postIndex := iNdEx + msglen
7505 if postIndex > l {
7506 return io.ErrUnexpectedEOF
7507 }
7508 m.Causes = append(m.Causes, StatusCause{})
7509 if err := m.Causes[len(m.Causes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
7510 return err
7511 }
7512 iNdEx = postIndex
7513 case 5:
7514 if wireType != 0 {
7515 return fmt.Errorf("proto: wrong wireType = %d for field RetryAfterSeconds", wireType)
7516 }
7517 m.RetryAfterSeconds = 0
7518 for shift := uint(0); ; shift += 7 {
7519 if shift >= 64 {
7520 return ErrIntOverflowGenerated
7521 }
7522 if iNdEx >= l {
7523 return io.ErrUnexpectedEOF
7524 }
7525 b := dAtA[iNdEx]
7526 iNdEx++
7527 m.RetryAfterSeconds |= (int32(b) & 0x7F) << shift
7528 if b < 0x80 {
7529 break
7530 }
7531 }
7532 case 6:
7533 if wireType != 2 {
7534 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
7535 }
7536 var stringLen uint64
7537 for shift := uint(0); ; shift += 7 {
7538 if shift >= 64 {
7539 return ErrIntOverflowGenerated
7540 }
7541 if iNdEx >= l {
7542 return io.ErrUnexpectedEOF
7543 }
7544 b := dAtA[iNdEx]
7545 iNdEx++
7546 stringLen |= (uint64(b) & 0x7F) << shift
7547 if b < 0x80 {
7548 break
7549 }
7550 }
7551 intStringLen := int(stringLen)
7552 if intStringLen < 0 {
7553 return ErrInvalidLengthGenerated
7554 }
7555 postIndex := iNdEx + intStringLen
7556 if postIndex > l {
7557 return io.ErrUnexpectedEOF
7558 }
7559 m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
7560 iNdEx = postIndex
7561 default:
7562 iNdEx = preIndex
7563 skippy, err := skipGenerated(dAtA[iNdEx:])
7564 if err != nil {
7565 return err
7566 }
7567 if skippy < 0 {
7568 return ErrInvalidLengthGenerated
7569 }
7570 if (iNdEx + skippy) > l {
7571 return io.ErrUnexpectedEOF
7572 }
7573 iNdEx += skippy
7574 }
7575 }
7576
7577 if iNdEx > l {
7578 return io.ErrUnexpectedEOF
7579 }
7580 return nil
7581}
7582func (m *Timestamp) Unmarshal(dAtA []byte) error {
7583 l := len(dAtA)
7584 iNdEx := 0
7585 for iNdEx < l {
7586 preIndex := iNdEx
7587 var wire uint64
7588 for shift := uint(0); ; shift += 7 {
7589 if shift >= 64 {
7590 return ErrIntOverflowGenerated
7591 }
7592 if iNdEx >= l {
7593 return io.ErrUnexpectedEOF
7594 }
7595 b := dAtA[iNdEx]
7596 iNdEx++
7597 wire |= (uint64(b) & 0x7F) << shift
7598 if b < 0x80 {
7599 break
7600 }
7601 }
7602 fieldNum := int32(wire >> 3)
7603 wireType := int(wire & 0x7)
7604 if wireType == 4 {
7605 return fmt.Errorf("proto: Timestamp: wiretype end group for non-group")
7606 }
7607 if fieldNum <= 0 {
7608 return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire)
7609 }
7610 switch fieldNum {
7611 case 1:
7612 if wireType != 0 {
7613 return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType)
7614 }
7615 m.Seconds = 0
7616 for shift := uint(0); ; shift += 7 {
7617 if shift >= 64 {
7618 return ErrIntOverflowGenerated
7619 }
7620 if iNdEx >= l {
7621 return io.ErrUnexpectedEOF
7622 }
7623 b := dAtA[iNdEx]
7624 iNdEx++
7625 m.Seconds |= (int64(b) & 0x7F) << shift
7626 if b < 0x80 {
7627 break
7628 }
7629 }
7630 case 2:
7631 if wireType != 0 {
7632 return fmt.Errorf("proto: wrong wireType = %d for field Nanos", wireType)
7633 }
7634 m.Nanos = 0
7635 for shift := uint(0); ; shift += 7 {
7636 if shift >= 64 {
7637 return ErrIntOverflowGenerated
7638 }
7639 if iNdEx >= l {
7640 return io.ErrUnexpectedEOF
7641 }
7642 b := dAtA[iNdEx]
7643 iNdEx++
7644 m.Nanos |= (int32(b) & 0x7F) << shift
7645 if b < 0x80 {
7646 break
7647 }
7648 }
7649 default:
7650 iNdEx = preIndex
7651 skippy, err := skipGenerated(dAtA[iNdEx:])
7652 if err != nil {
7653 return err
7654 }
7655 if skippy < 0 {
7656 return ErrInvalidLengthGenerated
7657 }
7658 if (iNdEx + skippy) > l {
7659 return io.ErrUnexpectedEOF
7660 }
7661 iNdEx += skippy
7662 }
7663 }
7664
7665 if iNdEx > l {
7666 return io.ErrUnexpectedEOF
7667 }
7668 return nil
7669}
7670func (m *TypeMeta) Unmarshal(dAtA []byte) error {
7671 l := len(dAtA)
7672 iNdEx := 0
7673 for iNdEx < l {
7674 preIndex := iNdEx
7675 var wire uint64
7676 for shift := uint(0); ; shift += 7 {
7677 if shift >= 64 {
7678 return ErrIntOverflowGenerated
7679 }
7680 if iNdEx >= l {
7681 return io.ErrUnexpectedEOF
7682 }
7683 b := dAtA[iNdEx]
7684 iNdEx++
7685 wire |= (uint64(b) & 0x7F) << shift
7686 if b < 0x80 {
7687 break
7688 }
7689 }
7690 fieldNum := int32(wire >> 3)
7691 wireType := int(wire & 0x7)
7692 if wireType == 4 {
7693 return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
7694 }
7695 if fieldNum <= 0 {
7696 return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
7697 }
7698 switch fieldNum {
7699 case 1:
7700 if wireType != 2 {
7701 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
7702 }
7703 var stringLen uint64
7704 for shift := uint(0); ; shift += 7 {
7705 if shift >= 64 {
7706 return ErrIntOverflowGenerated
7707 }
7708 if iNdEx >= l {
7709 return io.ErrUnexpectedEOF
7710 }
7711 b := dAtA[iNdEx]
7712 iNdEx++
7713 stringLen |= (uint64(b) & 0x7F) << shift
7714 if b < 0x80 {
7715 break
7716 }
7717 }
7718 intStringLen := int(stringLen)
7719 if intStringLen < 0 {
7720 return ErrInvalidLengthGenerated
7721 }
7722 postIndex := iNdEx + intStringLen
7723 if postIndex > l {
7724 return io.ErrUnexpectedEOF
7725 }
7726 m.Kind = string(dAtA[iNdEx:postIndex])
7727 iNdEx = postIndex
7728 case 2:
7729 if wireType != 2 {
7730 return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
7731 }
7732 var stringLen uint64
7733 for shift := uint(0); ; shift += 7 {
7734 if shift >= 64 {
7735 return ErrIntOverflowGenerated
7736 }
7737 if iNdEx >= l {
7738 return io.ErrUnexpectedEOF
7739 }
7740 b := dAtA[iNdEx]
7741 iNdEx++
7742 stringLen |= (uint64(b) & 0x7F) << shift
7743 if b < 0x80 {
7744 break
7745 }
7746 }
7747 intStringLen := int(stringLen)
7748 if intStringLen < 0 {
7749 return ErrInvalidLengthGenerated
7750 }
7751 postIndex := iNdEx + intStringLen
7752 if postIndex > l {
7753 return io.ErrUnexpectedEOF
7754 }
7755 m.APIVersion = string(dAtA[iNdEx:postIndex])
7756 iNdEx = postIndex
7757 default:
7758 iNdEx = preIndex
7759 skippy, err := skipGenerated(dAtA[iNdEx:])
7760 if err != nil {
7761 return err
7762 }
7763 if skippy < 0 {
7764 return ErrInvalidLengthGenerated
7765 }
7766 if (iNdEx + skippy) > l {
7767 return io.ErrUnexpectedEOF
7768 }
7769 iNdEx += skippy
7770 }
7771 }
7772
7773 if iNdEx > l {
7774 return io.ErrUnexpectedEOF
7775 }
7776 return nil
7777}
7778func (m *UpdateOptions) Unmarshal(dAtA []byte) error {
7779 l := len(dAtA)
7780 iNdEx := 0
7781 for iNdEx < l {
7782 preIndex := iNdEx
7783 var wire uint64
7784 for shift := uint(0); ; shift += 7 {
7785 if shift >= 64 {
7786 return ErrIntOverflowGenerated
7787 }
7788 if iNdEx >= l {
7789 return io.ErrUnexpectedEOF
7790 }
7791 b := dAtA[iNdEx]
7792 iNdEx++
7793 wire |= (uint64(b) & 0x7F) << shift
7794 if b < 0x80 {
7795 break
7796 }
7797 }
7798 fieldNum := int32(wire >> 3)
7799 wireType := int(wire & 0x7)
7800 if wireType == 4 {
7801 return fmt.Errorf("proto: UpdateOptions: wiretype end group for non-group")
7802 }
7803 if fieldNum <= 0 {
7804 return fmt.Errorf("proto: UpdateOptions: illegal tag %d (wire type %d)", fieldNum, wire)
7805 }
7806 switch fieldNum {
7807 case 1:
7808 if wireType != 2 {
7809 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
7810 }
7811 var stringLen uint64
7812 for shift := uint(0); ; shift += 7 {
7813 if shift >= 64 {
7814 return ErrIntOverflowGenerated
7815 }
7816 if iNdEx >= l {
7817 return io.ErrUnexpectedEOF
7818 }
7819 b := dAtA[iNdEx]
7820 iNdEx++
7821 stringLen |= (uint64(b) & 0x7F) << shift
7822 if b < 0x80 {
7823 break
7824 }
7825 }
7826 intStringLen := int(stringLen)
7827 if intStringLen < 0 {
7828 return ErrInvalidLengthGenerated
7829 }
7830 postIndex := iNdEx + intStringLen
7831 if postIndex > l {
7832 return io.ErrUnexpectedEOF
7833 }
7834 m.DryRun = append(m.DryRun, string(dAtA[iNdEx:postIndex]))
7835 iNdEx = postIndex
7836 default:
7837 iNdEx = preIndex
7838 skippy, err := skipGenerated(dAtA[iNdEx:])
7839 if err != nil {
7840 return err
7841 }
7842 if skippy < 0 {
7843 return ErrInvalidLengthGenerated
7844 }
7845 if (iNdEx + skippy) > l {
7846 return io.ErrUnexpectedEOF
7847 }
7848 iNdEx += skippy
7849 }
7850 }
7851
7852 if iNdEx > l {
7853 return io.ErrUnexpectedEOF
7854 }
7855 return nil
7856}
7857func (m *Verbs) Unmarshal(dAtA []byte) error {
7858 l := len(dAtA)
7859 iNdEx := 0
7860 for iNdEx < l {
7861 preIndex := iNdEx
7862 var wire uint64
7863 for shift := uint(0); ; shift += 7 {
7864 if shift >= 64 {
7865 return ErrIntOverflowGenerated
7866 }
7867 if iNdEx >= l {
7868 return io.ErrUnexpectedEOF
7869 }
7870 b := dAtA[iNdEx]
7871 iNdEx++
7872 wire |= (uint64(b) & 0x7F) << shift
7873 if b < 0x80 {
7874 break
7875 }
7876 }
7877 fieldNum := int32(wire >> 3)
7878 wireType := int(wire & 0x7)
7879 if wireType == 4 {
7880 return fmt.Errorf("proto: Verbs: wiretype end group for non-group")
7881 }
7882 if fieldNum <= 0 {
7883 return fmt.Errorf("proto: Verbs: illegal tag %d (wire type %d)", fieldNum, wire)
7884 }
7885 switch fieldNum {
7886 case 1:
7887 if wireType != 2 {
7888 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
7889 }
7890 var stringLen uint64
7891 for shift := uint(0); ; shift += 7 {
7892 if shift >= 64 {
7893 return ErrIntOverflowGenerated
7894 }
7895 if iNdEx >= l {
7896 return io.ErrUnexpectedEOF
7897 }
7898 b := dAtA[iNdEx]
7899 iNdEx++
7900 stringLen |= (uint64(b) & 0x7F) << shift
7901 if b < 0x80 {
7902 break
7903 }
7904 }
7905 intStringLen := int(stringLen)
7906 if intStringLen < 0 {
7907 return ErrInvalidLengthGenerated
7908 }
7909 postIndex := iNdEx + intStringLen
7910 if postIndex > l {
7911 return io.ErrUnexpectedEOF
7912 }
7913 *m = append(*m, string(dAtA[iNdEx:postIndex]))
7914 iNdEx = postIndex
7915 default:
7916 iNdEx = preIndex
7917 skippy, err := skipGenerated(dAtA[iNdEx:])
7918 if err != nil {
7919 return err
7920 }
7921 if skippy < 0 {
7922 return ErrInvalidLengthGenerated
7923 }
7924 if (iNdEx + skippy) > l {
7925 return io.ErrUnexpectedEOF
7926 }
7927 iNdEx += skippy
7928 }
7929 }
7930
7931 if iNdEx > l {
7932 return io.ErrUnexpectedEOF
7933 }
7934 return nil
7935}
7936func (m *WatchEvent) Unmarshal(dAtA []byte) error {
7937 l := len(dAtA)
7938 iNdEx := 0
7939 for iNdEx < l {
7940 preIndex := iNdEx
7941 var wire uint64
7942 for shift := uint(0); ; shift += 7 {
7943 if shift >= 64 {
7944 return ErrIntOverflowGenerated
7945 }
7946 if iNdEx >= l {
7947 return io.ErrUnexpectedEOF
7948 }
7949 b := dAtA[iNdEx]
7950 iNdEx++
7951 wire |= (uint64(b) & 0x7F) << shift
7952 if b < 0x80 {
7953 break
7954 }
7955 }
7956 fieldNum := int32(wire >> 3)
7957 wireType := int(wire & 0x7)
7958 if wireType == 4 {
7959 return fmt.Errorf("proto: WatchEvent: wiretype end group for non-group")
7960 }
7961 if fieldNum <= 0 {
7962 return fmt.Errorf("proto: WatchEvent: illegal tag %d (wire type %d)", fieldNum, wire)
7963 }
7964 switch fieldNum {
7965 case 1:
7966 if wireType != 2 {
7967 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
7968 }
7969 var stringLen uint64
7970 for shift := uint(0); ; shift += 7 {
7971 if shift >= 64 {
7972 return ErrIntOverflowGenerated
7973 }
7974 if iNdEx >= l {
7975 return io.ErrUnexpectedEOF
7976 }
7977 b := dAtA[iNdEx]
7978 iNdEx++
7979 stringLen |= (uint64(b) & 0x7F) << shift
7980 if b < 0x80 {
7981 break
7982 }
7983 }
7984 intStringLen := int(stringLen)
7985 if intStringLen < 0 {
7986 return ErrInvalidLengthGenerated
7987 }
7988 postIndex := iNdEx + intStringLen
7989 if postIndex > l {
7990 return io.ErrUnexpectedEOF
7991 }
7992 m.Type = string(dAtA[iNdEx:postIndex])
7993 iNdEx = postIndex
7994 case 2:
7995 if wireType != 2 {
7996 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
7997 }
7998 var msglen int
7999 for shift := uint(0); ; shift += 7 {
8000 if shift >= 64 {
8001 return ErrIntOverflowGenerated
8002 }
8003 if iNdEx >= l {
8004 return io.ErrUnexpectedEOF
8005 }
8006 b := dAtA[iNdEx]
8007 iNdEx++
8008 msglen |= (int(b) & 0x7F) << shift
8009 if b < 0x80 {
8010 break
8011 }
8012 }
8013 if msglen < 0 {
8014 return ErrInvalidLengthGenerated
8015 }
8016 postIndex := iNdEx + msglen
8017 if postIndex > l {
8018 return io.ErrUnexpectedEOF
8019 }
8020 if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
8021 return err
8022 }
8023 iNdEx = postIndex
8024 default:
8025 iNdEx = preIndex
8026 skippy, err := skipGenerated(dAtA[iNdEx:])
8027 if err != nil {
8028 return err
8029 }
8030 if skippy < 0 {
8031 return ErrInvalidLengthGenerated
8032 }
8033 if (iNdEx + skippy) > l {
8034 return io.ErrUnexpectedEOF
8035 }
8036 iNdEx += skippy
8037 }
8038 }
8039
8040 if iNdEx > l {
8041 return io.ErrUnexpectedEOF
8042 }
8043 return nil
8044}
8045func skipGenerated(dAtA []byte) (n int, err error) {
8046 l := len(dAtA)
8047 iNdEx := 0
8048 for iNdEx < l {
8049 var wire uint64
8050 for shift := uint(0); ; shift += 7 {
8051 if shift >= 64 {
8052 return 0, ErrIntOverflowGenerated
8053 }
8054 if iNdEx >= l {
8055 return 0, io.ErrUnexpectedEOF
8056 }
8057 b := dAtA[iNdEx]
8058 iNdEx++
8059 wire |= (uint64(b) & 0x7F) << shift
8060 if b < 0x80 {
8061 break
8062 }
8063 }
8064 wireType := int(wire & 0x7)
8065 switch wireType {
8066 case 0:
8067 for shift := uint(0); ; shift += 7 {
8068 if shift >= 64 {
8069 return 0, ErrIntOverflowGenerated
8070 }
8071 if iNdEx >= l {
8072 return 0, io.ErrUnexpectedEOF
8073 }
8074 iNdEx++
8075 if dAtA[iNdEx-1] < 0x80 {
8076 break
8077 }
8078 }
8079 return iNdEx, nil
8080 case 1:
8081 iNdEx += 8
8082 return iNdEx, nil
8083 case 2:
8084 var length int
8085 for shift := uint(0); ; shift += 7 {
8086 if shift >= 64 {
8087 return 0, ErrIntOverflowGenerated
8088 }
8089 if iNdEx >= l {
8090 return 0, io.ErrUnexpectedEOF
8091 }
8092 b := dAtA[iNdEx]
8093 iNdEx++
8094 length |= (int(b) & 0x7F) << shift
8095 if b < 0x80 {
8096 break
8097 }
8098 }
8099 iNdEx += length
8100 if length < 0 {
8101 return 0, ErrInvalidLengthGenerated
8102 }
8103 return iNdEx, nil
8104 case 3:
8105 for {
8106 var innerWire uint64
8107 var start int = iNdEx
8108 for shift := uint(0); ; shift += 7 {
8109 if shift >= 64 {
8110 return 0, ErrIntOverflowGenerated
8111 }
8112 if iNdEx >= l {
8113 return 0, io.ErrUnexpectedEOF
8114 }
8115 b := dAtA[iNdEx]
8116 iNdEx++
8117 innerWire |= (uint64(b) & 0x7F) << shift
8118 if b < 0x80 {
8119 break
8120 }
8121 }
8122 innerWireType := int(innerWire & 0x7)
8123 if innerWireType == 4 {
8124 break
8125 }
8126 next, err := skipGenerated(dAtA[start:])
8127 if err != nil {
8128 return 0, err
8129 }
8130 iNdEx = start + next
8131 }
8132 return iNdEx, nil
8133 case 4:
8134 return iNdEx, nil
8135 case 5:
8136 iNdEx += 4
8137 return iNdEx, nil
8138 default:
8139 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
8140 }
8141 }
8142 panic("unreachable")
8143}
8144
8145var (
8146 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
8147 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
8148)
8149
8150func init() {
8151 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto", fileDescriptorGenerated)
8152}
8153
8154var fileDescriptorGenerated = []byte{
8155 // 2465 bytes of a gzipped FileDescriptorProto
8156 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4d, 0x6c, 0x23, 0x49,
8157 0xf5, 0x4f, 0xdb, 0xb1, 0x63, 0x3f, 0xc7, 0xf9, 0xa8, 0xcd, 0xfe, 0xff, 0xde, 0x08, 0xec, 0x6c,
8158 0x2f, 0x5a, 0x65, 0x61, 0xd6, 0x26, 0x59, 0x58, 0x0d, 0x03, 0x2c, 0xc4, 0x71, 0x66, 0x14, 0xed,
8159 0x64, 0xc6, 0xaa, 0xec, 0x0c, 0x62, 0x18, 0x21, 0x3a, 0xdd, 0x15, 0xa7, 0x49, 0xbb, 0xdb, 0x5b,
8160 0xd5, 0xce, 0x8c, 0xe1, 0xc0, 0x1e, 0x40, 0x70, 0x40, 0x68, 0x8e, 0x9c, 0xd0, 0x8e, 0xe0, 0xc2,
8161 0x95, 0x13, 0x17, 0x38, 0x21, 0x31, 0xc7, 0x91, 0xb8, 0xec, 0x01, 0x59, 0x3b, 0xe6, 0xc0, 0x09,
8162 0x71, 0xcf, 0x09, 0x55, 0x75, 0x75, 0x75, 0xb7, 0x1d, 0x4f, 0xda, 0x3b, 0xbb, 0x88, 0x53, 0xd2,
8163 0xef, 0xe3, 0xf7, 0x5e, 0x55, 0xbd, 0x7a, 0xef, 0xd5, 0x33, 0x1c, 0x9c, 0x5e, 0x65, 0x75, 0xdb,
8164 0x6b, 0x9c, 0xf6, 0x8f, 0x08, 0x75, 0x89, 0x4f, 0x58, 0xe3, 0x8c, 0xb8, 0x96, 0x47, 0x1b, 0x92,
8165 0x61, 0xf4, 0xec, 0xae, 0x61, 0x9e, 0xd8, 0x2e, 0xa1, 0x83, 0x46, 0xef, 0xb4, 0xc3, 0x09, 0xac,
8166 0xd1, 0x25, 0xbe, 0xd1, 0x38, 0xdb, 0x6a, 0x74, 0x88, 0x4b, 0xa8, 0xe1, 0x13, 0xab, 0xde, 0xa3,
8167 0x9e, 0xef, 0xa1, 0x2f, 0x04, 0x5a, 0xf5, 0xb8, 0x56, 0xbd, 0x77, 0xda, 0xe1, 0x04, 0x56, 0xe7,
8168 0x5a, 0xf5, 0xb3, 0xad, 0xf5, 0x37, 0x3b, 0xb6, 0x7f, 0xd2, 0x3f, 0xaa, 0x9b, 0x5e, 0xb7, 0xd1,
8169 0xf1, 0x3a, 0x5e, 0x43, 0x28, 0x1f, 0xf5, 0x8f, 0xc5, 0x97, 0xf8, 0x10, 0xff, 0x05, 0xa0, 0xeb,
8170 0x53, 0x5d, 0xa1, 0x7d, 0xd7, 0xb7, 0xbb, 0x64, 0xdc, 0x8b, 0xf5, 0xb7, 0x2f, 0x53, 0x60, 0xe6,
8171 0x09, 0xe9, 0x1a, 0xe3, 0x7a, 0xfa, 0x5f, 0xb3, 0x50, 0xd8, 0x69, 0xef, 0xdf, 0xa0, 0x5e, 0xbf,
8172 0x87, 0x36, 0x60, 0xde, 0x35, 0xba, 0xa4, 0xa2, 0x6d, 0x68, 0x9b, 0xc5, 0xe6, 0xe2, 0x93, 0x61,
8173 0x6d, 0x6e, 0x34, 0xac, 0xcd, 0xdf, 0x32, 0xba, 0x04, 0x0b, 0x0e, 0x72, 0xa0, 0x70, 0x46, 0x28,
8174 0xb3, 0x3d, 0x97, 0x55, 0x32, 0x1b, 0xd9, 0xcd, 0xd2, 0xf6, 0x3b, 0xf5, 0x34, 0xeb, 0xaf, 0x0b,
8175 0x03, 0x77, 0x03, 0xd5, 0xeb, 0x1e, 0x6d, 0xd9, 0xcc, 0xf4, 0xce, 0x08, 0x1d, 0x34, 0x57, 0xa4,
8176 0x95, 0x82, 0x64, 0x32, 0xac, 0x2c, 0xa0, 0x9f, 0x6a, 0xb0, 0xd2, 0xa3, 0xe4, 0x98, 0x50, 0x4a,
8177 0x2c, 0xc9, 0xaf, 0x64, 0x37, 0xb4, 0x4f, 0xc1, 0x6c, 0x45, 0x9a, 0x5d, 0x69, 0x8f, 0xe1, 0xe3,
8178 0x09, 0x8b, 0xe8, 0xb7, 0x1a, 0xac, 0x33, 0x42, 0xcf, 0x08, 0xdd, 0xb1, 0x2c, 0x4a, 0x18, 0x6b,
8179 0x0e, 0x76, 0x1d, 0x9b, 0xb8, 0xfe, 0xee, 0x7e, 0x0b, 0xb3, 0xca, 0xbc, 0xd8, 0x87, 0x6f, 0xa5,
8180 0x73, 0xe8, 0x70, 0x1a, 0x4e, 0x53, 0x97, 0x1e, 0xad, 0x4f, 0x15, 0x61, 0xf8, 0x39, 0x6e, 0xe8,
8181 0xc7, 0xb0, 0x18, 0x1e, 0xe4, 0x4d, 0x9b, 0xf9, 0xe8, 0x2e, 0xe4, 0x3b, 0xfc, 0x83, 0x55, 0x34,
8182 0xe1, 0x60, 0x3d, 0x9d, 0x83, 0x21, 0x46, 0x73, 0x49, 0xfa, 0x93, 0x17, 0x9f, 0x0c, 0x4b, 0x34,
8183 0xfd, 0x4f, 0x59, 0x28, 0xed, 0xb4, 0xf7, 0x31, 0x61, 0x5e, 0x9f, 0x9a, 0x24, 0x45, 0xd0, 0x6c,
8184 0x03, 0xf0, 0xbf, 0xac, 0x67, 0x98, 0xc4, 0xaa, 0x64, 0x36, 0xb4, 0xcd, 0x42, 0x13, 0x49, 0x39,
8185 0xb8, 0xa5, 0x38, 0x38, 0x26, 0xc5, 0x51, 0x4f, 0x6d, 0xd7, 0x12, 0xa7, 0x1d, 0x43, 0x7d, 0xd7,
8186 0x76, 0x2d, 0x2c, 0x38, 0xe8, 0x26, 0xe4, 0xce, 0x08, 0x3d, 0xe2, 0xfb, 0xcf, 0x03, 0xe2, 0x4b,
8187 0xe9, 0x96, 0x77, 0x97, 0xab, 0x34, 0x8b, 0xa3, 0x61, 0x2d, 0x27, 0xfe, 0xc5, 0x01, 0x08, 0xaa,
8188 0x03, 0xb0, 0x13, 0x8f, 0xfa, 0xc2, 0x9d, 0x4a, 0x6e, 0x23, 0xbb, 0x59, 0x6c, 0x2e, 0x71, 0xff,
8189 0x0e, 0x15, 0x15, 0xc7, 0x24, 0xd0, 0x55, 0x58, 0x64, 0xb6, 0xdb, 0xe9, 0x3b, 0x06, 0xe5, 0x84,
8190 0x4a, 0x5e, 0xf8, 0xb9, 0x26, 0xfd, 0x5c, 0x3c, 0x8c, 0xf1, 0x70, 0x42, 0x92, 0x5b, 0x32, 0x0d,
8191 0x9f, 0x74, 0x3c, 0x6a, 0x13, 0x56, 0x59, 0x88, 0x2c, 0xed, 0x2a, 0x2a, 0x8e, 0x49, 0xa0, 0xd7,
8192 0x20, 0x27, 0x76, 0xbe, 0x52, 0x10, 0x26, 0xca, 0xd2, 0x44, 0x4e, 0x1c, 0x0b, 0x0e, 0x78, 0xe8,
8193 0x0d, 0x58, 0x90, 0xb7, 0xa6, 0x52, 0x14, 0x62, 0xcb, 0x52, 0x6c, 0x21, 0x0c, 0xeb, 0x90, 0xaf,
8194 0xff, 0x41, 0x83, 0xe5, 0xd8, 0xf9, 0x89, 0x58, 0xb9, 0x0a, 0x8b, 0x9d, 0xd8, 0x4d, 0x91, 0x67,
8195 0xa9, 0x56, 0x13, 0xbf, 0x45, 0x38, 0x21, 0x89, 0x08, 0x14, 0xa9, 0x44, 0x0a, 0x33, 0xc2, 0x56,
8196 0xea, 0x40, 0x0b, 0x7d, 0x88, 0x2c, 0xc5, 0x88, 0x0c, 0x47, 0xc8, 0xfa, 0x3f, 0x35, 0x11, 0x74,
8197 0x61, 0x8e, 0x40, 0x9b, 0xb1, 0x3c, 0xa4, 0x89, 0x2d, 0x5c, 0x9c, 0x92, 0x43, 0x2e, 0xb9, 0xbc,
8198 0x99, 0xff, 0x89, 0xcb, 0x7b, 0xad, 0xf0, 0xeb, 0x0f, 0x6b, 0x73, 0x1f, 0xfc, 0x7d, 0x63, 0x4e,
8199 0xff, 0x99, 0x06, 0xe5, 0x5d, 0x4a, 0x0c, 0x9f, 0xdc, 0xee, 0xf9, 0x62, 0x05, 0x3a, 0xe4, 0x2d,
8200 0x3a, 0xc0, 0x7d, 0x57, 0xae, 0x14, 0xf8, 0xa5, 0x6c, 0x09, 0x0a, 0x96, 0x1c, 0xd4, 0x86, 0x35,
8201 0xdb, 0x35, 0x9d, 0xbe, 0x45, 0xee, 0xb8, 0xb6, 0x6b, 0xfb, 0xb6, 0xe1, 0xd8, 0x3f, 0x52, 0x97,
8202 0xed, 0x73, 0xd2, 0xbb, 0xb5, 0xfd, 0x0b, 0x64, 0xf0, 0x85, 0x9a, 0xfa, 0xcf, 0xb3, 0x50, 0x6e,
8203 0x11, 0x87, 0x44, 0x7e, 0x5c, 0x07, 0xd4, 0xa1, 0x86, 0x49, 0xda, 0x84, 0xda, 0x9e, 0x75, 0x48,
8204 0x4c, 0xcf, 0xb5, 0x98, 0x08, 0x95, 0x6c, 0xf3, 0xff, 0x46, 0xc3, 0x1a, 0xba, 0x31, 0xc1, 0xc5,
8205 0x17, 0x68, 0x20, 0x07, 0xca, 0x3d, 0x2a, 0xfe, 0xb7, 0x7d, 0x59, 0x48, 0xf8, 0x05, 0x7e, 0x2b,
8206 0xdd, 0x19, 0xb4, 0xe3, 0xaa, 0xcd, 0xd5, 0xd1, 0xb0, 0x56, 0x4e, 0x90, 0x70, 0x12, 0x1c, 0x7d,
8207 0x1b, 0x56, 0x3c, 0xda, 0x3b, 0x31, 0xdc, 0x16, 0xe9, 0x11, 0xd7, 0x22, 0xae, 0xcf, 0x44, 0x52,
8208 0x29, 0x34, 0xd7, 0x78, 0xfa, 0xbf, 0x3d, 0xc6, 0xc3, 0x13, 0xd2, 0xe8, 0x1e, 0xac, 0xf6, 0xa8,
8209 0xd7, 0x33, 0x3a, 0x06, 0x47, 0x6c, 0x7b, 0x8e, 0x6d, 0x0e, 0x44, 0xd2, 0x29, 0x36, 0xaf, 0x8c,
8210 0x86, 0xb5, 0xd5, 0xf6, 0x38, 0xf3, 0x7c, 0x58, 0x7b, 0x49, 0x6c, 0x1d, 0xa7, 0x44, 0x4c, 0x3c,
8211 0x09, 0x13, 0x3b, 0xdb, 0xdc, 0xb4, 0xb3, 0xd5, 0xf7, 0xa1, 0xd0, 0xea, 0x53, 0xa1, 0x85, 0xbe,
8212 0x09, 0x05, 0x4b, 0xfe, 0x2f, 0x77, 0xfe, 0xd5, 0xb0, 0x7e, 0x86, 0x32, 0xe7, 0xc3, 0x5a, 0x99,
8213 0x57, 0xfc, 0x7a, 0x48, 0xc0, 0x4a, 0x45, 0xbf, 0x0f, 0xe5, 0xbd, 0x87, 0x3d, 0x8f, 0xfa, 0xe1,
8214 0x99, 0xbe, 0x0e, 0x79, 0x22, 0x08, 0x02, 0xad, 0x10, 0x25, 0xfd, 0x40, 0x0c, 0x4b, 0x2e, 0x4f,
8215 0x42, 0xe4, 0xa1, 0x61, 0xfa, 0x32, 0xa0, 0x54, 0x12, 0xda, 0xe3, 0x44, 0x1c, 0xf0, 0xf4, 0xc7,
8216 0x1a, 0xc0, 0x0d, 0xa2, 0xb0, 0x77, 0x60, 0x39, 0xbc, 0xc0, 0xc9, 0xbc, 0xf2, 0xff, 0x52, 0x7b,
8217 0x19, 0x27, 0xd9, 0x78, 0x5c, 0xfe, 0x33, 0x08, 0xeb, 0xfb, 0x50, 0x14, 0xd9, 0x8c, 0x17, 0x92,
8218 0x28, 0xb5, 0x6a, 0xcf, 0x49, 0xad, 0x61, 0x25, 0xca, 0x4c, 0xab, 0x44, 0xb1, 0xcb, 0xeb, 0x40,
8219 0x39, 0xd0, 0x0d, 0x8b, 0x63, 0x2a, 0x0b, 0x57, 0xa0, 0x10, 0x2e, 0x5c, 0x5a, 0x51, 0x4d, 0x51,
8220 0x08, 0x84, 0x95, 0x44, 0xcc, 0xda, 0x09, 0x24, 0x32, 0x73, 0x3a, 0x63, 0xb1, 0x4a, 0x91, 0x79,
8221 0x7e, 0xa5, 0x88, 0x59, 0xfa, 0x09, 0x54, 0xa6, 0x75, 0x52, 0x2f, 0x50, 0x3b, 0xd2, 0xbb, 0xa2,
8222 0xff, 0x4a, 0x83, 0x95, 0x38, 0x52, 0xfa, 0xe3, 0x4b, 0x6f, 0xe4, 0xf2, 0x9e, 0x23, 0xb6, 0x23,
8223 0xbf, 0xd1, 0x60, 0x2d, 0xb1, 0xb4, 0x99, 0x4e, 0x7c, 0x06, 0xa7, 0xe2, 0xc1, 0x91, 0x9d, 0x21,
8224 0x38, 0x1a, 0x50, 0xda, 0x57, 0x71, 0x4f, 0x2f, 0xef, 0xd2, 0xf4, 0x3f, 0x6b, 0xb0, 0x18, 0xd3,
8225 0x60, 0xe8, 0x3e, 0x2c, 0xf0, 0x1c, 0x68, 0xbb, 0x1d, 0xd9, 0x41, 0xa6, 0x2c, 0xec, 0x31, 0x90,
8226 0x68, 0x5d, 0xed, 0x00, 0x09, 0x87, 0x90, 0xa8, 0x0d, 0x79, 0x4a, 0x58, 0xdf, 0xf1, 0x65, 0xfa,
8227 0xbf, 0x92, 0xb2, 0x04, 0xfb, 0x86, 0xdf, 0x67, 0x41, 0x9e, 0xc4, 0x42, 0x1f, 0x4b, 0x1c, 0xfd,
8228 0x6f, 0x19, 0x28, 0xdf, 0x34, 0x8e, 0x88, 0x73, 0x48, 0x1c, 0x62, 0xfa, 0x1e, 0x45, 0x3f, 0x86,
8229 0x52, 0xd7, 0xf0, 0xcd, 0x13, 0x41, 0x0d, 0xfb, 0xe0, 0x56, 0x3a, 0x43, 0x09, 0xa4, 0xfa, 0x41,
8230 0x04, 0xb3, 0xe7, 0xfa, 0x74, 0xd0, 0x7c, 0x49, 0x2e, 0xac, 0x14, 0xe3, 0xe0, 0xb8, 0x35, 0xf1,
8231 0x78, 0x11, 0xdf, 0x7b, 0x0f, 0x7b, 0xbc, 0xe0, 0xcf, 0xfe, 0x66, 0x4a, 0xb8, 0x80, 0xc9, 0xfb,
8232 0x7d, 0x9b, 0x92, 0x2e, 0x71, 0xfd, 0xe8, 0xf1, 0x72, 0x30, 0x86, 0x8f, 0x27, 0x2c, 0xae, 0xbf,
8233 0x03, 0x2b, 0xe3, 0xce, 0xa3, 0x15, 0xc8, 0x9e, 0x92, 0x41, 0x10, 0x0b, 0x98, 0xff, 0x8b, 0xd6,
8234 0x20, 0x77, 0x66, 0x38, 0x7d, 0x99, 0x7f, 0x70, 0xf0, 0x71, 0x2d, 0x73, 0x55, 0xd3, 0x7f, 0xa7,
8235 0x41, 0x65, 0x9a, 0x23, 0xe8, 0xf3, 0x31, 0xa0, 0x66, 0x49, 0x7a, 0x95, 0x7d, 0x97, 0x0c, 0x02,
8236 0xd4, 0x3d, 0x28, 0x78, 0x3d, 0xfe, 0xdc, 0xf4, 0xa8, 0x8c, 0xf3, 0x37, 0xc2, 0xd8, 0xbd, 0x2d,
8237 0xe9, 0xe7, 0xc3, 0xda, 0xcb, 0x09, 0xf8, 0x90, 0x81, 0x95, 0x2a, 0x2f, 0x92, 0xc2, 0x1f, 0x5e,
8238 0xb8, 0x55, 0x91, 0xbc, 0x2b, 0x28, 0x58, 0x72, 0xf4, 0x3f, 0x6a, 0x30, 0x2f, 0x5a, 0xd9, 0xfb,
8239 0x50, 0xe0, 0xfb, 0x67, 0x19, 0xbe, 0x21, 0xfc, 0x4a, 0xfd, 0xf0, 0xe1, 0xda, 0x07, 0xc4, 0x37,
8240 0xa2, 0xfb, 0x15, 0x52, 0xb0, 0x42, 0x44, 0x18, 0x72, 0xb6, 0x4f, 0xba, 0xe1, 0x41, 0xbe, 0x39,
8241 0x15, 0x5a, 0x3e, 0xbb, 0xeb, 0xd8, 0x78, 0xb0, 0xf7, 0xd0, 0x27, 0x2e, 0x3f, 0x8c, 0x28, 0x19,
8242 0xec, 0x73, 0x0c, 0x1c, 0x40, 0xe9, 0xbf, 0xd7, 0x40, 0x99, 0xe2, 0xd7, 0x9d, 0x11, 0xe7, 0xf8,
8243 0xa6, 0xed, 0x9e, 0xca, 0x6d, 0x55, 0xee, 0x1c, 0x4a, 0x3a, 0x56, 0x12, 0x17, 0x95, 0xd8, 0xcc,
8244 0x8c, 0x25, 0xf6, 0x0a, 0x14, 0x4c, 0xcf, 0xf5, 0x6d, 0xb7, 0x3f, 0x91, 0x5f, 0x76, 0x25, 0x1d,
8245 0x2b, 0x09, 0xfd, 0x69, 0x16, 0x4a, 0xdc, 0xd7, 0xb0, 0xc6, 0x7f, 0x1d, 0xca, 0x4e, 0xfc, 0xf4,
8246 0xa4, 0xcf, 0x2f, 0x4b, 0x88, 0xe4, 0x7d, 0xc4, 0x49, 0x59, 0xae, 0x7c, 0x6c, 0x13, 0xc7, 0x52,
8247 0xca, 0x99, 0xa4, 0xf2, 0xf5, 0x38, 0x13, 0x27, 0x65, 0x79, 0x9e, 0x7d, 0xc0, 0xe3, 0x5a, 0x36,
8248 0x73, 0x6a, 0x6b, 0xbf, 0xc3, 0x89, 0x38, 0xe0, 0x5d, 0xb4, 0x3f, 0xf3, 0x33, 0xee, 0xcf, 0x35,
8249 0x58, 0xe2, 0x07, 0xe9, 0xf5, 0xfd, 0xb0, 0xe3, 0xcd, 0x89, 0xbe, 0x0b, 0x8d, 0x86, 0xb5, 0xa5,
8250 0xf7, 0x12, 0x1c, 0x3c, 0x26, 0x39, 0xb5, 0x7d, 0xc9, 0x7f, 0xd2, 0xf6, 0x85, 0xaf, 0xda, 0xb1,
8251 0xbb, 0xb6, 0x5f, 0x59, 0x10, 0x4e, 0xa8, 0x55, 0xdf, 0xe4, 0x44, 0x1c, 0xf0, 0x12, 0x47, 0x5a,
8252 0xb8, 0xf4, 0x48, 0xdf, 0x87, 0xe2, 0x81, 0x6d, 0x52, 0x8f, 0xaf, 0x85, 0x17, 0x26, 0x96, 0x68,
8253 0xec, 0x55, 0x02, 0x0f, 0xd7, 0x18, 0xf2, 0xb9, 0x2b, 0xae, 0xe1, 0x7a, 0x41, 0xfb, 0x9e, 0x8b,
8254 0x5c, 0xb9, 0xc5, 0x89, 0x38, 0xe0, 0x5d, 0x5b, 0xe3, 0xf5, 0xe8, 0x17, 0x8f, 0x6b, 0x73, 0x8f,
8255 0x1e, 0xd7, 0xe6, 0x3e, 0x7c, 0x2c, 0x6b, 0xd3, 0xbf, 0x00, 0xe0, 0xf6, 0xd1, 0x0f, 0x89, 0x19,
8256 0xc4, 0xfc, 0xe5, 0x13, 0x04, 0xde, 0x63, 0xc8, 0xc1, 0x95, 0x78, 0x6d, 0x67, 0xc6, 0x7a, 0x8c,
8257 0x18, 0x0f, 0x27, 0x24, 0x51, 0x03, 0x8a, 0x6a, 0xaa, 0x20, 0xe3, 0x7b, 0x55, 0xaa, 0x15, 0xd5,
8258 0xe8, 0x01, 0x47, 0x32, 0x89, 0x0b, 0x38, 0x7f, 0xe9, 0x05, 0x6c, 0x42, 0xb6, 0x6f, 0x5b, 0x22,
8259 0x24, 0x8a, 0xcd, 0x2f, 0x87, 0x09, 0xf0, 0xce, 0x7e, 0xeb, 0x7c, 0x58, 0x7b, 0x75, 0xda, 0x48,
8260 0xce, 0x1f, 0xf4, 0x08, 0xab, 0xdf, 0xd9, 0x6f, 0x61, 0xae, 0x7c, 0x51, 0x90, 0xe6, 0x67, 0x0c,
8261 0xd2, 0x6d, 0x00, 0xb9, 0x6a, 0xae, 0x1d, 0xc4, 0x86, 0x9a, 0xb0, 0xdc, 0x50, 0x1c, 0x1c, 0x93,
8262 0x42, 0x0c, 0x56, 0x4d, 0xfe, 0xce, 0xb4, 0x3d, 0x97, 0x1f, 0x3d, 0xf3, 0x8d, 0x6e, 0x30, 0x63,
8263 0x28, 0x6d, 0x7f, 0x31, 0x5d, 0xc6, 0xe4, 0x6a, 0xcd, 0x57, 0xa4, 0x99, 0xd5, 0xdd, 0x71, 0x30,
8264 0x3c, 0x89, 0x8f, 0x3c, 0x58, 0xb5, 0xe4, 0xcb, 0x28, 0x32, 0x5a, 0x9c, 0xd9, 0xe8, 0xcb, 0xdc,
8265 0x60, 0x6b, 0x1c, 0x08, 0x4f, 0x62, 0xa3, 0xef, 0xc3, 0x7a, 0x48, 0x9c, 0x7c, 0x9e, 0x56, 0x40,
8266 0xec, 0x54, 0x95, 0x3f, 0xdc, 0x5b, 0x53, 0xa5, 0xf0, 0x73, 0x10, 0x90, 0x05, 0x79, 0x27, 0xe8,
8267 0x2e, 0x4a, 0xa2, 0x22, 0x7c, 0x23, 0xdd, 0x2a, 0xa2, 0xe8, 0xaf, 0xc7, 0xbb, 0x0a, 0xf5, 0xfc,
8268 0x92, 0x0d, 0x85, 0xc4, 0x46, 0x0f, 0xa1, 0x64, 0xb8, 0xae, 0xe7, 0x1b, 0xc1, 0x83, 0x79, 0x51,
8269 0x98, 0xda, 0x99, 0xd9, 0xd4, 0x4e, 0x84, 0x31, 0xd6, 0xc5, 0xc4, 0x38, 0x38, 0x6e, 0x0a, 0x3d,
8270 0x80, 0x65, 0xef, 0x81, 0x4b, 0x28, 0x26, 0xc7, 0x84, 0x12, 0xd7, 0x24, 0xac, 0x52, 0x16, 0xd6,
8271 0xbf, 0x92, 0xd2, 0x7a, 0x42, 0x39, 0x0a, 0xe9, 0x24, 0x9d, 0xe1, 0x71, 0x2b, 0xa8, 0x0e, 0x70,
8272 0x6c, 0xbb, 0xb2, 0x17, 0xad, 0x2c, 0x45, 0x63, 0xb2, 0xeb, 0x8a, 0x8a, 0x63, 0x12, 0xe8, 0xab,
8273 0x50, 0x32, 0x9d, 0x3e, 0xf3, 0x49, 0x30, 0x8f, 0x5b, 0x16, 0x37, 0x48, 0xad, 0x6f, 0x37, 0x62,
8274 0xe1, 0xb8, 0x1c, 0x3a, 0x81, 0x45, 0x3b, 0xd6, 0xf4, 0x56, 0x56, 0x44, 0x2c, 0x6e, 0xcf, 0xdc,
8275 0xe9, 0xb2, 0xe6, 0x0a, 0xcf, 0x44, 0x71, 0x0a, 0x4e, 0x20, 0xaf, 0x7f, 0x0d, 0x4a, 0x9f, 0xb0,
8276 0x07, 0xe3, 0x3d, 0xdc, 0xf8, 0xd1, 0xcd, 0xd4, 0xc3, 0xfd, 0x25, 0x03, 0x4b, 0xc9, 0x0d, 0x57,
8277 0x6f, 0x1d, 0x6d, 0xea, 0x7c, 0x35, 0xcc, 0xca, 0xd9, 0xa9, 0x59, 0x59, 0x26, 0xbf, 0xf9, 0x17,
8278 0x49, 0x7e, 0xdb, 0x00, 0x46, 0xcf, 0x0e, 0xf3, 0x5e, 0x90, 0x47, 0x55, 0xe6, 0x8a, 0x26, 0x7e,
8279 0x38, 0x26, 0x25, 0x26, 0xa8, 0x9e, 0xeb, 0x53, 0xcf, 0x71, 0x08, 0x95, 0xc5, 0x34, 0x98, 0xa0,
8280 0x2a, 0x2a, 0x8e, 0x49, 0xa0, 0xeb, 0x80, 0x8e, 0x1c, 0xcf, 0x3c, 0x15, 0x5b, 0x10, 0xde, 0x73,
8281 0x91, 0x25, 0x0b, 0xc1, 0xe0, 0xaa, 0x39, 0xc1, 0xc5, 0x17, 0x68, 0xe8, 0x0b, 0x90, 0x6b, 0xf3,
8282 0xb6, 0x42, 0xbf, 0x0d, 0xc9, 0x99, 0x13, 0x7a, 0x27, 0xd8, 0x09, 0x4d, 0x0d, 0x85, 0x66, 0xdb,
8283 0x05, 0xfd, 0x0a, 0x14, 0xb1, 0xe7, 0xf9, 0x6d, 0xc3, 0x3f, 0x61, 0xa8, 0x06, 0xb9, 0x1e, 0xff,
8284 0x47, 0x8e, 0xfb, 0xc4, 0xac, 0x5a, 0x70, 0x70, 0x40, 0xd7, 0x7f, 0xa9, 0xc1, 0x2b, 0x53, 0xe7,
8285 0x8c, 0x7c, 0x47, 0x4d, 0xf5, 0x25, 0x5d, 0x52, 0x3b, 0x1a, 0xc9, 0xe1, 0x98, 0x14, 0xef, 0xc4,
8286 0x12, 0xc3, 0xc9, 0xf1, 0x4e, 0x2c, 0x61, 0x0d, 0x27, 0x65, 0xf5, 0x7f, 0x67, 0x20, 0x1f, 0x3c,
8287 0xcb, 0x3e, 0xe3, 0xe6, 0xfb, 0x75, 0xc8, 0x33, 0x61, 0x47, 0xba, 0xa7, 0xb2, 0x65, 0x60, 0x1d,
8288 0x4b, 0x2e, 0x6f, 0x62, 0xba, 0x84, 0x31, 0xa3, 0x13, 0x06, 0xaf, 0x6a, 0x62, 0x0e, 0x02, 0x32,
8289 0x0e, 0xf9, 0xe8, 0x6d, 0xfe, 0x0a, 0x35, 0x98, 0xea, 0x0b, 0xab, 0x21, 0x24, 0x16, 0xd4, 0xf3,
8290 0x61, 0x6d, 0x51, 0x82, 0x8b, 0x6f, 0x2c, 0xa5, 0xd1, 0x3d, 0x58, 0xb0, 0x88, 0x6f, 0xd8, 0x4e,
8291 0xd0, 0x0e, 0xa6, 0x9e, 0x5e, 0x06, 0x60, 0xad, 0x40, 0xb5, 0x59, 0xe2, 0x3e, 0xc9, 0x0f, 0x1c,
8292 0x02, 0xf2, 0x8b, 0x67, 0x7a, 0x56, 0xf0, 0x93, 0x42, 0x2e, 0xba, 0x78, 0xbb, 0x9e, 0x45, 0xb0,
8293 0xe0, 0xe8, 0x8f, 0x34, 0x28, 0x05, 0x48, 0xbb, 0x46, 0x9f, 0x11, 0xb4, 0xa5, 0x56, 0x11, 0x1c,
8294 0x77, 0x58, 0x93, 0xe7, 0xdf, 0x1b, 0xf4, 0xc8, 0xf9, 0xb0, 0x56, 0x14, 0x62, 0xfc, 0x43, 0x2d,
8295 0x20, 0xb6, 0x47, 0x99, 0x4b, 0xf6, 0xe8, 0x35, 0xc8, 0x89, 0xd6, 0x5b, 0x6e, 0xa6, 0x6a, 0xf4,
8296 0x44, 0x7b, 0x8e, 0x03, 0x9e, 0xfe, 0x71, 0x06, 0xca, 0x89, 0xc5, 0xa5, 0xe8, 0xea, 0xd4, 0xa8,
8297 0x24, 0x93, 0x62, 0xfc, 0x36, 0xfd, 0x87, 0xa0, 0xef, 0x42, 0xde, 0xe4, 0xeb, 0x0b, 0x7f, 0x89,
8298 0xdb, 0x9a, 0xe5, 0x28, 0xc4, 0xce, 0x44, 0x91, 0x24, 0x3e, 0x19, 0x96, 0x80, 0xe8, 0x06, 0xac,
8299 0x52, 0xe2, 0xd3, 0xc1, 0xce, 0xb1, 0x4f, 0x68, 0xbc, 0xff, 0xcf, 0x45, 0x7d, 0x0f, 0x1e, 0x17,
8300 0xc0, 0x93, 0x3a, 0x61, 0xaa, 0xcc, 0xbf, 0x40, 0xaa, 0xd4, 0x1d, 0x98, 0xff, 0x2f, 0xf6, 0xe8,
8301 0xdf, 0x83, 0x62, 0xd4, 0x45, 0x7d, 0xca, 0x26, 0xf5, 0x1f, 0x40, 0x81, 0x47, 0x63, 0xd8, 0xfd,
8302 0x5f, 0x52, 0x89, 0x92, 0x35, 0x22, 0x93, 0xa6, 0x46, 0xe8, 0x6f, 0x41, 0xf9, 0x4e, 0xcf, 0x9a,
8303 0xed, 0x57, 0x14, 0x7d, 0x1b, 0x82, 0x1f, 0x05, 0x79, 0x0a, 0x0e, 0x9e, 0xf9, 0xb1, 0x14, 0x1c,
8304 0x7f, 0xb3, 0x27, 0x7f, 0xaf, 0x01, 0xf1, 0xe6, 0xdc, 0x3b, 0x23, 0xae, 0xcf, 0x57, 0xc3, 0x8f,
8305 0x6d, 0x7c, 0x35, 0xe2, 0xee, 0x09, 0x0e, 0xba, 0x03, 0x79, 0x4f, 0xb4, 0x64, 0x72, 0xf0, 0x35,
8306 0xe3, 0x0c, 0x41, 0x85, 0x6a, 0xd0, 0xd7, 0x61, 0x09, 0xd6, 0xdc, 0x7c, 0xf2, 0xac, 0x3a, 0xf7,
8307 0xf4, 0x59, 0x75, 0xee, 0xa3, 0x67, 0xd5, 0xb9, 0x0f, 0x46, 0x55, 0xed, 0xc9, 0xa8, 0xaa, 0x3d,
8308 0x1d, 0x55, 0xb5, 0x8f, 0x46, 0x55, 0xed, 0xe3, 0x51, 0x55, 0x7b, 0xf4, 0x8f, 0xea, 0xdc, 0xbd,
8309 0xcc, 0xd9, 0xd6, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xab, 0xec, 0x02, 0x4a, 0x00, 0x21, 0x00,
8310 0x00,
8311}