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