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/api/extensions/v1beta1/generated.proto 19 20/* 21 Package v1beta1 is a generated protocol buffer package. 22 23 It is generated from these files: 24 k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto 25 26 It has these top-level messages: 27 AllowedCSIDriver 28 AllowedFlexVolume 29 AllowedHostPath 30 DaemonSet 31 DaemonSetCondition 32 DaemonSetList 33 DaemonSetSpec 34 DaemonSetStatus 35 DaemonSetUpdateStrategy 36 Deployment 37 DeploymentCondition 38 DeploymentList 39 DeploymentRollback 40 DeploymentSpec 41 DeploymentStatus 42 DeploymentStrategy 43 FSGroupStrategyOptions 44 HTTPIngressPath 45 HTTPIngressRuleValue 46 HostPortRange 47 IDRange 48 IPBlock 49 Ingress 50 IngressBackend 51 IngressList 52 IngressRule 53 IngressRuleValue 54 IngressSpec 55 IngressStatus 56 IngressTLS 57 NetworkPolicy 58 NetworkPolicyEgressRule 59 NetworkPolicyIngressRule 60 NetworkPolicyList 61 NetworkPolicyPeer 62 NetworkPolicyPort 63 NetworkPolicySpec 64 PodSecurityPolicy 65 PodSecurityPolicyList 66 PodSecurityPolicySpec 67 ReplicaSet 68 ReplicaSetCondition 69 ReplicaSetList 70 ReplicaSetSpec 71 ReplicaSetStatus 72 ReplicationControllerDummy 73 RollbackConfig 74 RollingUpdateDaemonSet 75 RollingUpdateDeployment 76 RunAsGroupStrategyOptions 77 RunAsUserStrategyOptions 78 SELinuxStrategyOptions 79 Scale 80 ScaleSpec 81 ScaleStatus 82 SupplementalGroupsStrategyOptions 83*/ 84package v1beta1 85 86import proto "github.com/gogo/protobuf/proto" 87import fmt "fmt" 88import math "math" 89 90import k8s_io_api_core_v1 "k8s.io/api/core/v1" 91import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" 92 93import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr" 94 95import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" 96 97import strings "strings" 98import reflect "reflect" 99 100import io "io" 101 102// Reference imports to suppress errors if they are not otherwise used. 103var _ = proto.Marshal 104var _ = fmt.Errorf 105var _ = math.Inf 106 107// This is a compile-time assertion to ensure that this generated file 108// is compatible with the proto package it is being compiled against. 109// A compilation error at this line likely means your copy of the 110// proto package needs to be updated. 111const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 112 113func (m *AllowedCSIDriver) Reset() { *m = AllowedCSIDriver{} } 114func (*AllowedCSIDriver) ProtoMessage() {} 115func (*AllowedCSIDriver) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} } 116 117func (m *AllowedFlexVolume) Reset() { *m = AllowedFlexVolume{} } 118func (*AllowedFlexVolume) ProtoMessage() {} 119func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} } 120 121func (m *AllowedHostPath) Reset() { *m = AllowedHostPath{} } 122func (*AllowedHostPath) ProtoMessage() {} 123func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} } 124 125func (m *DaemonSet) Reset() { *m = DaemonSet{} } 126func (*DaemonSet) ProtoMessage() {} 127func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} } 128 129func (m *DaemonSetCondition) Reset() { *m = DaemonSetCondition{} } 130func (*DaemonSetCondition) ProtoMessage() {} 131func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} } 132 133func (m *DaemonSetList) Reset() { *m = DaemonSetList{} } 134func (*DaemonSetList) ProtoMessage() {} 135func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} } 136 137func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} } 138func (*DaemonSetSpec) ProtoMessage() {} 139func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} } 140 141func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} } 142func (*DaemonSetStatus) ProtoMessage() {} 143func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} } 144 145func (m *DaemonSetUpdateStrategy) Reset() { *m = DaemonSetUpdateStrategy{} } 146func (*DaemonSetUpdateStrategy) ProtoMessage() {} 147func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} } 148 149func (m *Deployment) Reset() { *m = Deployment{} } 150func (*Deployment) ProtoMessage() {} 151func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} } 152 153func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} } 154func (*DeploymentCondition) ProtoMessage() {} 155func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} } 156 157func (m *DeploymentList) Reset() { *m = DeploymentList{} } 158func (*DeploymentList) ProtoMessage() {} 159func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} } 160 161func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} } 162func (*DeploymentRollback) ProtoMessage() {} 163func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} } 164 165func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} } 166func (*DeploymentSpec) ProtoMessage() {} 167func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} } 168 169func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} } 170func (*DeploymentStatus) ProtoMessage() {} 171func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} } 172 173func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} } 174func (*DeploymentStrategy) ProtoMessage() {} 175func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} } 176 177func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} } 178func (*FSGroupStrategyOptions) ProtoMessage() {} 179func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} } 180 181func (m *HTTPIngressPath) Reset() { *m = HTTPIngressPath{} } 182func (*HTTPIngressPath) ProtoMessage() {} 183func (*HTTPIngressPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} } 184 185func (m *HTTPIngressRuleValue) Reset() { *m = HTTPIngressRuleValue{} } 186func (*HTTPIngressRuleValue) ProtoMessage() {} 187func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} } 188 189func (m *HostPortRange) Reset() { *m = HostPortRange{} } 190func (*HostPortRange) ProtoMessage() {} 191func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} } 192 193func (m *IDRange) Reset() { *m = IDRange{} } 194func (*IDRange) ProtoMessage() {} 195func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} } 196 197func (m *IPBlock) Reset() { *m = IPBlock{} } 198func (*IPBlock) ProtoMessage() {} 199func (*IPBlock) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} } 200 201func (m *Ingress) Reset() { *m = Ingress{} } 202func (*Ingress) ProtoMessage() {} 203func (*Ingress) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} } 204 205func (m *IngressBackend) Reset() { *m = IngressBackend{} } 206func (*IngressBackend) ProtoMessage() {} 207func (*IngressBackend) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} } 208 209func (m *IngressList) Reset() { *m = IngressList{} } 210func (*IngressList) ProtoMessage() {} 211func (*IngressList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} } 212 213func (m *IngressRule) Reset() { *m = IngressRule{} } 214func (*IngressRule) ProtoMessage() {} 215func (*IngressRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} } 216 217func (m *IngressRuleValue) Reset() { *m = IngressRuleValue{} } 218func (*IngressRuleValue) ProtoMessage() {} 219func (*IngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} } 220 221func (m *IngressSpec) Reset() { *m = IngressSpec{} } 222func (*IngressSpec) ProtoMessage() {} 223func (*IngressSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} } 224 225func (m *IngressStatus) Reset() { *m = IngressStatus{} } 226func (*IngressStatus) ProtoMessage() {} 227func (*IngressStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} } 228 229func (m *IngressTLS) Reset() { *m = IngressTLS{} } 230func (*IngressTLS) ProtoMessage() {} 231func (*IngressTLS) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} } 232 233func (m *NetworkPolicy) Reset() { *m = NetworkPolicy{} } 234func (*NetworkPolicy) ProtoMessage() {} 235func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} } 236 237func (m *NetworkPolicyEgressRule) Reset() { *m = NetworkPolicyEgressRule{} } 238func (*NetworkPolicyEgressRule) ProtoMessage() {} 239func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) { 240 return fileDescriptorGenerated, []int{31} 241} 242 243func (m *NetworkPolicyIngressRule) Reset() { *m = NetworkPolicyIngressRule{} } 244func (*NetworkPolicyIngressRule) ProtoMessage() {} 245func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) { 246 return fileDescriptorGenerated, []int{32} 247} 248 249func (m *NetworkPolicyList) Reset() { *m = NetworkPolicyList{} } 250func (*NetworkPolicyList) ProtoMessage() {} 251func (*NetworkPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} } 252 253func (m *NetworkPolicyPeer) Reset() { *m = NetworkPolicyPeer{} } 254func (*NetworkPolicyPeer) ProtoMessage() {} 255func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} } 256 257func (m *NetworkPolicyPort) Reset() { *m = NetworkPolicyPort{} } 258func (*NetworkPolicyPort) ProtoMessage() {} 259func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} } 260 261func (m *NetworkPolicySpec) Reset() { *m = NetworkPolicySpec{} } 262func (*NetworkPolicySpec) ProtoMessage() {} 263func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} } 264 265func (m *PodSecurityPolicy) Reset() { *m = PodSecurityPolicy{} } 266func (*PodSecurityPolicy) ProtoMessage() {} 267func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} } 268 269func (m *PodSecurityPolicyList) Reset() { *m = PodSecurityPolicyList{} } 270func (*PodSecurityPolicyList) ProtoMessage() {} 271func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} } 272 273func (m *PodSecurityPolicySpec) Reset() { *m = PodSecurityPolicySpec{} } 274func (*PodSecurityPolicySpec) ProtoMessage() {} 275func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} } 276 277func (m *ReplicaSet) Reset() { *m = ReplicaSet{} } 278func (*ReplicaSet) ProtoMessage() {} 279func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} } 280 281func (m *ReplicaSetCondition) Reset() { *m = ReplicaSetCondition{} } 282func (*ReplicaSetCondition) ProtoMessage() {} 283func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} } 284 285func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} } 286func (*ReplicaSetList) ProtoMessage() {} 287func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} } 288 289func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} } 290func (*ReplicaSetSpec) ProtoMessage() {} 291func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} } 292 293func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} } 294func (*ReplicaSetStatus) ProtoMessage() {} 295func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{44} } 296 297func (m *ReplicationControllerDummy) Reset() { *m = ReplicationControllerDummy{} } 298func (*ReplicationControllerDummy) ProtoMessage() {} 299func (*ReplicationControllerDummy) Descriptor() ([]byte, []int) { 300 return fileDescriptorGenerated, []int{45} 301} 302 303func (m *RollbackConfig) Reset() { *m = RollbackConfig{} } 304func (*RollbackConfig) ProtoMessage() {} 305func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{46} } 306 307func (m *RollingUpdateDaemonSet) Reset() { *m = RollingUpdateDaemonSet{} } 308func (*RollingUpdateDaemonSet) ProtoMessage() {} 309func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{47} } 310 311func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} } 312func (*RollingUpdateDeployment) ProtoMessage() {} 313func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) { 314 return fileDescriptorGenerated, []int{48} 315} 316 317func (m *RunAsGroupStrategyOptions) Reset() { *m = RunAsGroupStrategyOptions{} } 318func (*RunAsGroupStrategyOptions) ProtoMessage() {} 319func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) { 320 return fileDescriptorGenerated, []int{49} 321} 322 323func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} } 324func (*RunAsUserStrategyOptions) ProtoMessage() {} 325func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) { 326 return fileDescriptorGenerated, []int{50} 327} 328 329func (m *SELinuxStrategyOptions) Reset() { *m = SELinuxStrategyOptions{} } 330func (*SELinuxStrategyOptions) ProtoMessage() {} 331func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{51} } 332 333func (m *Scale) Reset() { *m = Scale{} } 334func (*Scale) ProtoMessage() {} 335func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{52} } 336 337func (m *ScaleSpec) Reset() { *m = ScaleSpec{} } 338func (*ScaleSpec) ProtoMessage() {} 339func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{53} } 340 341func (m *ScaleStatus) Reset() { *m = ScaleStatus{} } 342func (*ScaleStatus) ProtoMessage() {} 343func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{54} } 344 345func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} } 346func (*SupplementalGroupsStrategyOptions) ProtoMessage() {} 347func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) { 348 return fileDescriptorGenerated, []int{55} 349} 350 351func init() { 352 proto.RegisterType((*AllowedCSIDriver)(nil), "k8s.io.api.extensions.v1beta1.AllowedCSIDriver") 353 proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.extensions.v1beta1.AllowedFlexVolume") 354 proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.extensions.v1beta1.AllowedHostPath") 355 proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet") 356 proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition") 357 proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList") 358 proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec") 359 proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus") 360 proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy") 361 proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment") 362 proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition") 363 proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList") 364 proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback") 365 proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec") 366 proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus") 367 proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy") 368 proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.FSGroupStrategyOptions") 369 proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath") 370 proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue") 371 proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.extensions.v1beta1.HostPortRange") 372 proto.RegisterType((*IDRange)(nil), "k8s.io.api.extensions.v1beta1.IDRange") 373 proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock") 374 proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress") 375 proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend") 376 proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList") 377 proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule") 378 proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue") 379 proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec") 380 proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus") 381 proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS") 382 proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy") 383 proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule") 384 proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule") 385 proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList") 386 proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer") 387 proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort") 388 proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec") 389 proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicy") 390 proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicyList") 391 proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicySpec") 392 proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet") 393 proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition") 394 proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList") 395 proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec") 396 proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus") 397 proto.RegisterType((*ReplicationControllerDummy)(nil), "k8s.io.api.extensions.v1beta1.ReplicationControllerDummy") 398 proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig") 399 proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet") 400 proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment") 401 proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsGroupStrategyOptions") 402 proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsUserStrategyOptions") 403 proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SELinuxStrategyOptions") 404 proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale") 405 proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec") 406 proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus") 407 proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SupplementalGroupsStrategyOptions") 408} 409func (m *AllowedCSIDriver) Marshal() (dAtA []byte, err error) { 410 size := m.Size() 411 dAtA = make([]byte, size) 412 n, err := m.MarshalTo(dAtA) 413 if err != nil { 414 return nil, err 415 } 416 return dAtA[:n], nil 417} 418 419func (m *AllowedCSIDriver) MarshalTo(dAtA []byte) (int, error) { 420 var i int 421 _ = i 422 var l int 423 _ = l 424 dAtA[i] = 0xa 425 i++ 426 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) 427 i += copy(dAtA[i:], m.Name) 428 return i, nil 429} 430 431func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) { 432 size := m.Size() 433 dAtA = make([]byte, size) 434 n, err := m.MarshalTo(dAtA) 435 if err != nil { 436 return nil, err 437 } 438 return dAtA[:n], nil 439} 440 441func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) { 442 var i int 443 _ = i 444 var l int 445 _ = l 446 dAtA[i] = 0xa 447 i++ 448 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver))) 449 i += copy(dAtA[i:], m.Driver) 450 return i, nil 451} 452 453func (m *AllowedHostPath) Marshal() (dAtA []byte, err error) { 454 size := m.Size() 455 dAtA = make([]byte, size) 456 n, err := m.MarshalTo(dAtA) 457 if err != nil { 458 return nil, err 459 } 460 return dAtA[:n], nil 461} 462 463func (m *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) { 464 var i int 465 _ = i 466 var l int 467 _ = l 468 dAtA[i] = 0xa 469 i++ 470 i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix))) 471 i += copy(dAtA[i:], m.PathPrefix) 472 dAtA[i] = 0x10 473 i++ 474 if m.ReadOnly { 475 dAtA[i] = 1 476 } else { 477 dAtA[i] = 0 478 } 479 i++ 480 return i, nil 481} 482 483func (m *DaemonSet) Marshal() (dAtA []byte, err error) { 484 size := m.Size() 485 dAtA = make([]byte, size) 486 n, err := m.MarshalTo(dAtA) 487 if err != nil { 488 return nil, err 489 } 490 return dAtA[:n], nil 491} 492 493func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) { 494 var i int 495 _ = i 496 var l int 497 _ = l 498 dAtA[i] = 0xa 499 i++ 500 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 501 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 502 if err != nil { 503 return 0, err 504 } 505 i += n1 506 dAtA[i] = 0x12 507 i++ 508 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 509 n2, err := m.Spec.MarshalTo(dAtA[i:]) 510 if err != nil { 511 return 0, err 512 } 513 i += n2 514 dAtA[i] = 0x1a 515 i++ 516 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 517 n3, err := m.Status.MarshalTo(dAtA[i:]) 518 if err != nil { 519 return 0, err 520 } 521 i += n3 522 return i, nil 523} 524 525func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) { 526 size := m.Size() 527 dAtA = make([]byte, size) 528 n, err := m.MarshalTo(dAtA) 529 if err != nil { 530 return nil, err 531 } 532 return dAtA[:n], nil 533} 534 535func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) { 536 var i int 537 _ = i 538 var l int 539 _ = l 540 dAtA[i] = 0xa 541 i++ 542 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 543 i += copy(dAtA[i:], m.Type) 544 dAtA[i] = 0x12 545 i++ 546 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) 547 i += copy(dAtA[i:], m.Status) 548 dAtA[i] = 0x1a 549 i++ 550 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size())) 551 n4, err := m.LastTransitionTime.MarshalTo(dAtA[i:]) 552 if err != nil { 553 return 0, err 554 } 555 i += n4 556 dAtA[i] = 0x22 557 i++ 558 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) 559 i += copy(dAtA[i:], m.Reason) 560 dAtA[i] = 0x2a 561 i++ 562 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) 563 i += copy(dAtA[i:], m.Message) 564 return i, nil 565} 566 567func (m *DaemonSetList) Marshal() (dAtA []byte, err error) { 568 size := m.Size() 569 dAtA = make([]byte, size) 570 n, err := m.MarshalTo(dAtA) 571 if err != nil { 572 return nil, err 573 } 574 return dAtA[:n], nil 575} 576 577func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) { 578 var i int 579 _ = i 580 var l int 581 _ = l 582 dAtA[i] = 0xa 583 i++ 584 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 585 n5, err := m.ListMeta.MarshalTo(dAtA[i:]) 586 if err != nil { 587 return 0, err 588 } 589 i += n5 590 if len(m.Items) > 0 { 591 for _, msg := range m.Items { 592 dAtA[i] = 0x12 593 i++ 594 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 595 n, err := msg.MarshalTo(dAtA[i:]) 596 if err != nil { 597 return 0, err 598 } 599 i += n 600 } 601 } 602 return i, nil 603} 604 605func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) { 606 size := m.Size() 607 dAtA = make([]byte, size) 608 n, err := m.MarshalTo(dAtA) 609 if err != nil { 610 return nil, err 611 } 612 return dAtA[:n], nil 613} 614 615func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) { 616 var i int 617 _ = i 618 var l int 619 _ = l 620 if m.Selector != nil { 621 dAtA[i] = 0xa 622 i++ 623 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size())) 624 n6, err := m.Selector.MarshalTo(dAtA[i:]) 625 if err != nil { 626 return 0, err 627 } 628 i += n6 629 } 630 dAtA[i] = 0x12 631 i++ 632 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size())) 633 n7, err := m.Template.MarshalTo(dAtA[i:]) 634 if err != nil { 635 return 0, err 636 } 637 i += n7 638 dAtA[i] = 0x1a 639 i++ 640 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size())) 641 n8, err := m.UpdateStrategy.MarshalTo(dAtA[i:]) 642 if err != nil { 643 return 0, err 644 } 645 i += n8 646 dAtA[i] = 0x20 647 i++ 648 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) 649 dAtA[i] = 0x28 650 i++ 651 i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration)) 652 if m.RevisionHistoryLimit != nil { 653 dAtA[i] = 0x30 654 i++ 655 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) 656 } 657 return i, nil 658} 659 660func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) { 661 size := m.Size() 662 dAtA = make([]byte, size) 663 n, err := m.MarshalTo(dAtA) 664 if err != nil { 665 return nil, err 666 } 667 return dAtA[:n], nil 668} 669 670func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) { 671 var i int 672 _ = i 673 var l int 674 _ = l 675 dAtA[i] = 0x8 676 i++ 677 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled)) 678 dAtA[i] = 0x10 679 i++ 680 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled)) 681 dAtA[i] = 0x18 682 i++ 683 i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled)) 684 dAtA[i] = 0x20 685 i++ 686 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady)) 687 dAtA[i] = 0x28 688 i++ 689 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) 690 dAtA[i] = 0x30 691 i++ 692 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled)) 693 dAtA[i] = 0x38 694 i++ 695 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable)) 696 dAtA[i] = 0x40 697 i++ 698 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable)) 699 if m.CollisionCount != nil { 700 dAtA[i] = 0x48 701 i++ 702 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) 703 } 704 if len(m.Conditions) > 0 { 705 for _, msg := range m.Conditions { 706 dAtA[i] = 0x52 707 i++ 708 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 709 n, err := msg.MarshalTo(dAtA[i:]) 710 if err != nil { 711 return 0, err 712 } 713 i += n 714 } 715 } 716 return i, nil 717} 718 719func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) { 720 size := m.Size() 721 dAtA = make([]byte, size) 722 n, err := m.MarshalTo(dAtA) 723 if err != nil { 724 return nil, err 725 } 726 return dAtA[:n], nil 727} 728 729func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) { 730 var i int 731 _ = i 732 var l int 733 _ = l 734 dAtA[i] = 0xa 735 i++ 736 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 737 i += copy(dAtA[i:], m.Type) 738 if m.RollingUpdate != nil { 739 dAtA[i] = 0x12 740 i++ 741 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size())) 742 n9, err := m.RollingUpdate.MarshalTo(dAtA[i:]) 743 if err != nil { 744 return 0, err 745 } 746 i += n9 747 } 748 return i, nil 749} 750 751func (m *Deployment) Marshal() (dAtA []byte, err error) { 752 size := m.Size() 753 dAtA = make([]byte, size) 754 n, err := m.MarshalTo(dAtA) 755 if err != nil { 756 return nil, err 757 } 758 return dAtA[:n], nil 759} 760 761func (m *Deployment) MarshalTo(dAtA []byte) (int, error) { 762 var i int 763 _ = i 764 var l int 765 _ = l 766 dAtA[i] = 0xa 767 i++ 768 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 769 n10, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 770 if err != nil { 771 return 0, err 772 } 773 i += n10 774 dAtA[i] = 0x12 775 i++ 776 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 777 n11, err := m.Spec.MarshalTo(dAtA[i:]) 778 if err != nil { 779 return 0, err 780 } 781 i += n11 782 dAtA[i] = 0x1a 783 i++ 784 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 785 n12, err := m.Status.MarshalTo(dAtA[i:]) 786 if err != nil { 787 return 0, err 788 } 789 i += n12 790 return i, nil 791} 792 793func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) { 794 size := m.Size() 795 dAtA = make([]byte, size) 796 n, err := m.MarshalTo(dAtA) 797 if err != nil { 798 return nil, err 799 } 800 return dAtA[:n], nil 801} 802 803func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) { 804 var i int 805 _ = i 806 var l int 807 _ = l 808 dAtA[i] = 0xa 809 i++ 810 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 811 i += copy(dAtA[i:], m.Type) 812 dAtA[i] = 0x12 813 i++ 814 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) 815 i += copy(dAtA[i:], m.Status) 816 dAtA[i] = 0x22 817 i++ 818 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) 819 i += copy(dAtA[i:], m.Reason) 820 dAtA[i] = 0x2a 821 i++ 822 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) 823 i += copy(dAtA[i:], m.Message) 824 dAtA[i] = 0x32 825 i++ 826 i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size())) 827 n13, err := m.LastUpdateTime.MarshalTo(dAtA[i:]) 828 if err != nil { 829 return 0, err 830 } 831 i += n13 832 dAtA[i] = 0x3a 833 i++ 834 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size())) 835 n14, err := m.LastTransitionTime.MarshalTo(dAtA[i:]) 836 if err != nil { 837 return 0, err 838 } 839 i += n14 840 return i, nil 841} 842 843func (m *DeploymentList) Marshal() (dAtA []byte, err error) { 844 size := m.Size() 845 dAtA = make([]byte, size) 846 n, err := m.MarshalTo(dAtA) 847 if err != nil { 848 return nil, err 849 } 850 return dAtA[:n], nil 851} 852 853func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) { 854 var i int 855 _ = i 856 var l int 857 _ = l 858 dAtA[i] = 0xa 859 i++ 860 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 861 n15, err := m.ListMeta.MarshalTo(dAtA[i:]) 862 if err != nil { 863 return 0, err 864 } 865 i += n15 866 if len(m.Items) > 0 { 867 for _, msg := range m.Items { 868 dAtA[i] = 0x12 869 i++ 870 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 871 n, err := msg.MarshalTo(dAtA[i:]) 872 if err != nil { 873 return 0, err 874 } 875 i += n 876 } 877 } 878 return i, nil 879} 880 881func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) { 882 size := m.Size() 883 dAtA = make([]byte, size) 884 n, err := m.MarshalTo(dAtA) 885 if err != nil { 886 return nil, err 887 } 888 return dAtA[:n], nil 889} 890 891func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) { 892 var i int 893 _ = i 894 var l int 895 _ = l 896 dAtA[i] = 0xa 897 i++ 898 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) 899 i += copy(dAtA[i:], m.Name) 900 if len(m.UpdatedAnnotations) > 0 { 901 keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations)) 902 for k := range m.UpdatedAnnotations { 903 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k)) 904 } 905 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations) 906 for _, k := range keysForUpdatedAnnotations { 907 dAtA[i] = 0x12 908 i++ 909 v := m.UpdatedAnnotations[string(k)] 910 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 911 i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) 912 dAtA[i] = 0xa 913 i++ 914 i = encodeVarintGenerated(dAtA, i, uint64(len(k))) 915 i += copy(dAtA[i:], k) 916 dAtA[i] = 0x12 917 i++ 918 i = encodeVarintGenerated(dAtA, i, uint64(len(v))) 919 i += copy(dAtA[i:], v) 920 } 921 } 922 dAtA[i] = 0x1a 923 i++ 924 i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size())) 925 n16, err := m.RollbackTo.MarshalTo(dAtA[i:]) 926 if err != nil { 927 return 0, err 928 } 929 i += n16 930 return i, nil 931} 932 933func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) { 934 size := m.Size() 935 dAtA = make([]byte, size) 936 n, err := m.MarshalTo(dAtA) 937 if err != nil { 938 return nil, err 939 } 940 return dAtA[:n], nil 941} 942 943func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) { 944 var i int 945 _ = i 946 var l int 947 _ = l 948 if m.Replicas != nil { 949 dAtA[i] = 0x8 950 i++ 951 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) 952 } 953 if m.Selector != nil { 954 dAtA[i] = 0x12 955 i++ 956 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size())) 957 n17, err := m.Selector.MarshalTo(dAtA[i:]) 958 if err != nil { 959 return 0, err 960 } 961 i += n17 962 } 963 dAtA[i] = 0x1a 964 i++ 965 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size())) 966 n18, err := m.Template.MarshalTo(dAtA[i:]) 967 if err != nil { 968 return 0, err 969 } 970 i += n18 971 dAtA[i] = 0x22 972 i++ 973 i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size())) 974 n19, err := m.Strategy.MarshalTo(dAtA[i:]) 975 if err != nil { 976 return 0, err 977 } 978 i += n19 979 dAtA[i] = 0x28 980 i++ 981 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) 982 if m.RevisionHistoryLimit != nil { 983 dAtA[i] = 0x30 984 i++ 985 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) 986 } 987 dAtA[i] = 0x38 988 i++ 989 if m.Paused { 990 dAtA[i] = 1 991 } else { 992 dAtA[i] = 0 993 } 994 i++ 995 if m.RollbackTo != nil { 996 dAtA[i] = 0x42 997 i++ 998 i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size())) 999 n20, err := m.RollbackTo.MarshalTo(dAtA[i:]) 1000 if err != nil { 1001 return 0, err 1002 } 1003 i += n20 1004 } 1005 if m.ProgressDeadlineSeconds != nil { 1006 dAtA[i] = 0x48 1007 i++ 1008 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds)) 1009 } 1010 return i, nil 1011} 1012 1013func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) { 1014 size := m.Size() 1015 dAtA = make([]byte, size) 1016 n, err := m.MarshalTo(dAtA) 1017 if err != nil { 1018 return nil, err 1019 } 1020 return dAtA[:n], nil 1021} 1022 1023func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) { 1024 var i int 1025 _ = i 1026 var l int 1027 _ = l 1028 dAtA[i] = 0x8 1029 i++ 1030 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) 1031 dAtA[i] = 0x10 1032 i++ 1033 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 1034 dAtA[i] = 0x18 1035 i++ 1036 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas)) 1037 dAtA[i] = 0x20 1038 i++ 1039 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) 1040 dAtA[i] = 0x28 1041 i++ 1042 i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas)) 1043 if len(m.Conditions) > 0 { 1044 for _, msg := range m.Conditions { 1045 dAtA[i] = 0x32 1046 i++ 1047 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1048 n, err := msg.MarshalTo(dAtA[i:]) 1049 if err != nil { 1050 return 0, err 1051 } 1052 i += n 1053 } 1054 } 1055 dAtA[i] = 0x38 1056 i++ 1057 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) 1058 if m.CollisionCount != nil { 1059 dAtA[i] = 0x40 1060 i++ 1061 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) 1062 } 1063 return i, nil 1064} 1065 1066func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) { 1067 size := m.Size() 1068 dAtA = make([]byte, size) 1069 n, err := m.MarshalTo(dAtA) 1070 if err != nil { 1071 return nil, err 1072 } 1073 return dAtA[:n], nil 1074} 1075 1076func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) { 1077 var i int 1078 _ = i 1079 var l int 1080 _ = l 1081 dAtA[i] = 0xa 1082 i++ 1083 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 1084 i += copy(dAtA[i:], m.Type) 1085 if m.RollingUpdate != nil { 1086 dAtA[i] = 0x12 1087 i++ 1088 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size())) 1089 n21, err := m.RollingUpdate.MarshalTo(dAtA[i:]) 1090 if err != nil { 1091 return 0, err 1092 } 1093 i += n21 1094 } 1095 return i, nil 1096} 1097 1098func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) { 1099 size := m.Size() 1100 dAtA = make([]byte, size) 1101 n, err := m.MarshalTo(dAtA) 1102 if err != nil { 1103 return nil, err 1104 } 1105 return dAtA[:n], nil 1106} 1107 1108func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 1109 var i int 1110 _ = i 1111 var l int 1112 _ = l 1113 dAtA[i] = 0xa 1114 i++ 1115 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 1116 i += copy(dAtA[i:], m.Rule) 1117 if len(m.Ranges) > 0 { 1118 for _, msg := range m.Ranges { 1119 dAtA[i] = 0x12 1120 i++ 1121 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1122 n, err := msg.MarshalTo(dAtA[i:]) 1123 if err != nil { 1124 return 0, err 1125 } 1126 i += n 1127 } 1128 } 1129 return i, nil 1130} 1131 1132func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) { 1133 size := m.Size() 1134 dAtA = make([]byte, size) 1135 n, err := m.MarshalTo(dAtA) 1136 if err != nil { 1137 return nil, err 1138 } 1139 return dAtA[:n], nil 1140} 1141 1142func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) { 1143 var i int 1144 _ = i 1145 var l int 1146 _ = l 1147 dAtA[i] = 0xa 1148 i++ 1149 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path))) 1150 i += copy(dAtA[i:], m.Path) 1151 dAtA[i] = 0x12 1152 i++ 1153 i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size())) 1154 n22, err := m.Backend.MarshalTo(dAtA[i:]) 1155 if err != nil { 1156 return 0, err 1157 } 1158 i += n22 1159 return i, nil 1160} 1161 1162func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) { 1163 size := m.Size() 1164 dAtA = make([]byte, size) 1165 n, err := m.MarshalTo(dAtA) 1166 if err != nil { 1167 return nil, err 1168 } 1169 return dAtA[:n], nil 1170} 1171 1172func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) { 1173 var i int 1174 _ = i 1175 var l int 1176 _ = l 1177 if len(m.Paths) > 0 { 1178 for _, msg := range m.Paths { 1179 dAtA[i] = 0xa 1180 i++ 1181 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1182 n, err := msg.MarshalTo(dAtA[i:]) 1183 if err != nil { 1184 return 0, err 1185 } 1186 i += n 1187 } 1188 } 1189 return i, nil 1190} 1191 1192func (m *HostPortRange) Marshal() (dAtA []byte, err error) { 1193 size := m.Size() 1194 dAtA = make([]byte, size) 1195 n, err := m.MarshalTo(dAtA) 1196 if err != nil { 1197 return nil, err 1198 } 1199 return dAtA[:n], nil 1200} 1201 1202func (m *HostPortRange) MarshalTo(dAtA []byte) (int, error) { 1203 var i int 1204 _ = i 1205 var l int 1206 _ = l 1207 dAtA[i] = 0x8 1208 i++ 1209 i = encodeVarintGenerated(dAtA, i, uint64(m.Min)) 1210 dAtA[i] = 0x10 1211 i++ 1212 i = encodeVarintGenerated(dAtA, i, uint64(m.Max)) 1213 return i, nil 1214} 1215 1216func (m *IDRange) Marshal() (dAtA []byte, err error) { 1217 size := m.Size() 1218 dAtA = make([]byte, size) 1219 n, err := m.MarshalTo(dAtA) 1220 if err != nil { 1221 return nil, err 1222 } 1223 return dAtA[:n], nil 1224} 1225 1226func (m *IDRange) MarshalTo(dAtA []byte) (int, error) { 1227 var i int 1228 _ = i 1229 var l int 1230 _ = l 1231 dAtA[i] = 0x8 1232 i++ 1233 i = encodeVarintGenerated(dAtA, i, uint64(m.Min)) 1234 dAtA[i] = 0x10 1235 i++ 1236 i = encodeVarintGenerated(dAtA, i, uint64(m.Max)) 1237 return i, nil 1238} 1239 1240func (m *IPBlock) Marshal() (dAtA []byte, err error) { 1241 size := m.Size() 1242 dAtA = make([]byte, size) 1243 n, err := m.MarshalTo(dAtA) 1244 if err != nil { 1245 return nil, err 1246 } 1247 return dAtA[:n], nil 1248} 1249 1250func (m *IPBlock) MarshalTo(dAtA []byte) (int, error) { 1251 var i int 1252 _ = i 1253 var l int 1254 _ = l 1255 dAtA[i] = 0xa 1256 i++ 1257 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR))) 1258 i += copy(dAtA[i:], m.CIDR) 1259 if len(m.Except) > 0 { 1260 for _, s := range m.Except { 1261 dAtA[i] = 0x12 1262 i++ 1263 l = len(s) 1264 for l >= 1<<7 { 1265 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1266 l >>= 7 1267 i++ 1268 } 1269 dAtA[i] = uint8(l) 1270 i++ 1271 i += copy(dAtA[i:], s) 1272 } 1273 } 1274 return i, nil 1275} 1276 1277func (m *Ingress) Marshal() (dAtA []byte, err error) { 1278 size := m.Size() 1279 dAtA = make([]byte, size) 1280 n, err := m.MarshalTo(dAtA) 1281 if err != nil { 1282 return nil, err 1283 } 1284 return dAtA[:n], nil 1285} 1286 1287func (m *Ingress) MarshalTo(dAtA []byte) (int, error) { 1288 var i int 1289 _ = i 1290 var l int 1291 _ = l 1292 dAtA[i] = 0xa 1293 i++ 1294 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 1295 n23, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 1296 if err != nil { 1297 return 0, err 1298 } 1299 i += n23 1300 dAtA[i] = 0x12 1301 i++ 1302 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 1303 n24, err := m.Spec.MarshalTo(dAtA[i:]) 1304 if err != nil { 1305 return 0, err 1306 } 1307 i += n24 1308 dAtA[i] = 0x1a 1309 i++ 1310 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 1311 n25, err := m.Status.MarshalTo(dAtA[i:]) 1312 if err != nil { 1313 return 0, err 1314 } 1315 i += n25 1316 return i, nil 1317} 1318 1319func (m *IngressBackend) Marshal() (dAtA []byte, err error) { 1320 size := m.Size() 1321 dAtA = make([]byte, size) 1322 n, err := m.MarshalTo(dAtA) 1323 if err != nil { 1324 return nil, err 1325 } 1326 return dAtA[:n], nil 1327} 1328 1329func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) { 1330 var i int 1331 _ = i 1332 var l int 1333 _ = l 1334 dAtA[i] = 0xa 1335 i++ 1336 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName))) 1337 i += copy(dAtA[i:], m.ServiceName) 1338 dAtA[i] = 0x12 1339 i++ 1340 i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort.Size())) 1341 n26, err := m.ServicePort.MarshalTo(dAtA[i:]) 1342 if err != nil { 1343 return 0, err 1344 } 1345 i += n26 1346 return i, nil 1347} 1348 1349func (m *IngressList) Marshal() (dAtA []byte, err error) { 1350 size := m.Size() 1351 dAtA = make([]byte, size) 1352 n, err := m.MarshalTo(dAtA) 1353 if err != nil { 1354 return nil, err 1355 } 1356 return dAtA[:n], nil 1357} 1358 1359func (m *IngressList) MarshalTo(dAtA []byte) (int, error) { 1360 var i int 1361 _ = i 1362 var l int 1363 _ = l 1364 dAtA[i] = 0xa 1365 i++ 1366 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 1367 n27, err := m.ListMeta.MarshalTo(dAtA[i:]) 1368 if err != nil { 1369 return 0, err 1370 } 1371 i += n27 1372 if len(m.Items) > 0 { 1373 for _, msg := range m.Items { 1374 dAtA[i] = 0x12 1375 i++ 1376 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1377 n, err := msg.MarshalTo(dAtA[i:]) 1378 if err != nil { 1379 return 0, err 1380 } 1381 i += n 1382 } 1383 } 1384 return i, nil 1385} 1386 1387func (m *IngressRule) Marshal() (dAtA []byte, err error) { 1388 size := m.Size() 1389 dAtA = make([]byte, size) 1390 n, err := m.MarshalTo(dAtA) 1391 if err != nil { 1392 return nil, err 1393 } 1394 return dAtA[:n], nil 1395} 1396 1397func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) { 1398 var i int 1399 _ = i 1400 var l int 1401 _ = l 1402 dAtA[i] = 0xa 1403 i++ 1404 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host))) 1405 i += copy(dAtA[i:], m.Host) 1406 dAtA[i] = 0x12 1407 i++ 1408 i = encodeVarintGenerated(dAtA, i, uint64(m.IngressRuleValue.Size())) 1409 n28, err := m.IngressRuleValue.MarshalTo(dAtA[i:]) 1410 if err != nil { 1411 return 0, err 1412 } 1413 i += n28 1414 return i, nil 1415} 1416 1417func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) { 1418 size := m.Size() 1419 dAtA = make([]byte, size) 1420 n, err := m.MarshalTo(dAtA) 1421 if err != nil { 1422 return nil, err 1423 } 1424 return dAtA[:n], nil 1425} 1426 1427func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) { 1428 var i int 1429 _ = i 1430 var l int 1431 _ = l 1432 if m.HTTP != nil { 1433 dAtA[i] = 0xa 1434 i++ 1435 i = encodeVarintGenerated(dAtA, i, uint64(m.HTTP.Size())) 1436 n29, err := m.HTTP.MarshalTo(dAtA[i:]) 1437 if err != nil { 1438 return 0, err 1439 } 1440 i += n29 1441 } 1442 return i, nil 1443} 1444 1445func (m *IngressSpec) Marshal() (dAtA []byte, err error) { 1446 size := m.Size() 1447 dAtA = make([]byte, size) 1448 n, err := m.MarshalTo(dAtA) 1449 if err != nil { 1450 return nil, err 1451 } 1452 return dAtA[:n], nil 1453} 1454 1455func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) { 1456 var i int 1457 _ = i 1458 var l int 1459 _ = l 1460 if m.Backend != nil { 1461 dAtA[i] = 0xa 1462 i++ 1463 i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size())) 1464 n30, err := m.Backend.MarshalTo(dAtA[i:]) 1465 if err != nil { 1466 return 0, err 1467 } 1468 i += n30 1469 } 1470 if len(m.TLS) > 0 { 1471 for _, msg := range m.TLS { 1472 dAtA[i] = 0x12 1473 i++ 1474 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1475 n, err := msg.MarshalTo(dAtA[i:]) 1476 if err != nil { 1477 return 0, err 1478 } 1479 i += n 1480 } 1481 } 1482 if len(m.Rules) > 0 { 1483 for _, msg := range m.Rules { 1484 dAtA[i] = 0x1a 1485 i++ 1486 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1487 n, err := msg.MarshalTo(dAtA[i:]) 1488 if err != nil { 1489 return 0, err 1490 } 1491 i += n 1492 } 1493 } 1494 return i, nil 1495} 1496 1497func (m *IngressStatus) Marshal() (dAtA []byte, err error) { 1498 size := m.Size() 1499 dAtA = make([]byte, size) 1500 n, err := m.MarshalTo(dAtA) 1501 if err != nil { 1502 return nil, err 1503 } 1504 return dAtA[:n], nil 1505} 1506 1507func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) { 1508 var i int 1509 _ = i 1510 var l int 1511 _ = l 1512 dAtA[i] = 0xa 1513 i++ 1514 i = encodeVarintGenerated(dAtA, i, uint64(m.LoadBalancer.Size())) 1515 n31, err := m.LoadBalancer.MarshalTo(dAtA[i:]) 1516 if err != nil { 1517 return 0, err 1518 } 1519 i += n31 1520 return i, nil 1521} 1522 1523func (m *IngressTLS) Marshal() (dAtA []byte, err error) { 1524 size := m.Size() 1525 dAtA = make([]byte, size) 1526 n, err := m.MarshalTo(dAtA) 1527 if err != nil { 1528 return nil, err 1529 } 1530 return dAtA[:n], nil 1531} 1532 1533func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) { 1534 var i int 1535 _ = i 1536 var l int 1537 _ = l 1538 if len(m.Hosts) > 0 { 1539 for _, s := range m.Hosts { 1540 dAtA[i] = 0xa 1541 i++ 1542 l = len(s) 1543 for l >= 1<<7 { 1544 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1545 l >>= 7 1546 i++ 1547 } 1548 dAtA[i] = uint8(l) 1549 i++ 1550 i += copy(dAtA[i:], s) 1551 } 1552 } 1553 dAtA[i] = 0x12 1554 i++ 1555 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName))) 1556 i += copy(dAtA[i:], m.SecretName) 1557 return i, nil 1558} 1559 1560func (m *NetworkPolicy) Marshal() (dAtA []byte, err error) { 1561 size := m.Size() 1562 dAtA = make([]byte, size) 1563 n, err := m.MarshalTo(dAtA) 1564 if err != nil { 1565 return nil, err 1566 } 1567 return dAtA[:n], nil 1568} 1569 1570func (m *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) { 1571 var i int 1572 _ = i 1573 var l int 1574 _ = l 1575 dAtA[i] = 0xa 1576 i++ 1577 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 1578 n32, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 1579 if err != nil { 1580 return 0, err 1581 } 1582 i += n32 1583 dAtA[i] = 0x12 1584 i++ 1585 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 1586 n33, err := m.Spec.MarshalTo(dAtA[i:]) 1587 if err != nil { 1588 return 0, err 1589 } 1590 i += n33 1591 return i, nil 1592} 1593 1594func (m *NetworkPolicyEgressRule) Marshal() (dAtA []byte, err error) { 1595 size := m.Size() 1596 dAtA = make([]byte, size) 1597 n, err := m.MarshalTo(dAtA) 1598 if err != nil { 1599 return nil, err 1600 } 1601 return dAtA[:n], nil 1602} 1603 1604func (m *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) { 1605 var i int 1606 _ = i 1607 var l int 1608 _ = l 1609 if len(m.Ports) > 0 { 1610 for _, msg := range m.Ports { 1611 dAtA[i] = 0xa 1612 i++ 1613 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1614 n, err := msg.MarshalTo(dAtA[i:]) 1615 if err != nil { 1616 return 0, err 1617 } 1618 i += n 1619 } 1620 } 1621 if len(m.To) > 0 { 1622 for _, msg := range m.To { 1623 dAtA[i] = 0x12 1624 i++ 1625 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1626 n, err := msg.MarshalTo(dAtA[i:]) 1627 if err != nil { 1628 return 0, err 1629 } 1630 i += n 1631 } 1632 } 1633 return i, nil 1634} 1635 1636func (m *NetworkPolicyIngressRule) 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 *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) { 1647 var i int 1648 _ = i 1649 var l int 1650 _ = l 1651 if len(m.Ports) > 0 { 1652 for _, msg := range m.Ports { 1653 dAtA[i] = 0xa 1654 i++ 1655 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1656 n, err := msg.MarshalTo(dAtA[i:]) 1657 if err != nil { 1658 return 0, err 1659 } 1660 i += n 1661 } 1662 } 1663 if len(m.From) > 0 { 1664 for _, msg := range m.From { 1665 dAtA[i] = 0x12 1666 i++ 1667 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1668 n, err := msg.MarshalTo(dAtA[i:]) 1669 if err != nil { 1670 return 0, err 1671 } 1672 i += n 1673 } 1674 } 1675 return i, nil 1676} 1677 1678func (m *NetworkPolicyList) Marshal() (dAtA []byte, err error) { 1679 size := m.Size() 1680 dAtA = make([]byte, size) 1681 n, err := m.MarshalTo(dAtA) 1682 if err != nil { 1683 return nil, err 1684 } 1685 return dAtA[:n], nil 1686} 1687 1688func (m *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) { 1689 var i int 1690 _ = i 1691 var l int 1692 _ = l 1693 dAtA[i] = 0xa 1694 i++ 1695 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 1696 n34, err := m.ListMeta.MarshalTo(dAtA[i:]) 1697 if err != nil { 1698 return 0, err 1699 } 1700 i += n34 1701 if len(m.Items) > 0 { 1702 for _, msg := range m.Items { 1703 dAtA[i] = 0x12 1704 i++ 1705 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1706 n, err := msg.MarshalTo(dAtA[i:]) 1707 if err != nil { 1708 return 0, err 1709 } 1710 i += n 1711 } 1712 } 1713 return i, nil 1714} 1715 1716func (m *NetworkPolicyPeer) Marshal() (dAtA []byte, err error) { 1717 size := m.Size() 1718 dAtA = make([]byte, size) 1719 n, err := m.MarshalTo(dAtA) 1720 if err != nil { 1721 return nil, err 1722 } 1723 return dAtA[:n], nil 1724} 1725 1726func (m *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) { 1727 var i int 1728 _ = i 1729 var l int 1730 _ = l 1731 if m.PodSelector != nil { 1732 dAtA[i] = 0xa 1733 i++ 1734 i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size())) 1735 n35, err := m.PodSelector.MarshalTo(dAtA[i:]) 1736 if err != nil { 1737 return 0, err 1738 } 1739 i += n35 1740 } 1741 if m.NamespaceSelector != nil { 1742 dAtA[i] = 0x12 1743 i++ 1744 i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size())) 1745 n36, err := m.NamespaceSelector.MarshalTo(dAtA[i:]) 1746 if err != nil { 1747 return 0, err 1748 } 1749 i += n36 1750 } 1751 if m.IPBlock != nil { 1752 dAtA[i] = 0x1a 1753 i++ 1754 i = encodeVarintGenerated(dAtA, i, uint64(m.IPBlock.Size())) 1755 n37, err := m.IPBlock.MarshalTo(dAtA[i:]) 1756 if err != nil { 1757 return 0, err 1758 } 1759 i += n37 1760 } 1761 return i, nil 1762} 1763 1764func (m *NetworkPolicyPort) Marshal() (dAtA []byte, err error) { 1765 size := m.Size() 1766 dAtA = make([]byte, size) 1767 n, err := m.MarshalTo(dAtA) 1768 if err != nil { 1769 return nil, err 1770 } 1771 return dAtA[:n], nil 1772} 1773 1774func (m *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) { 1775 var i int 1776 _ = i 1777 var l int 1778 _ = l 1779 if m.Protocol != nil { 1780 dAtA[i] = 0xa 1781 i++ 1782 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol))) 1783 i += copy(dAtA[i:], *m.Protocol) 1784 } 1785 if m.Port != nil { 1786 dAtA[i] = 0x12 1787 i++ 1788 i = encodeVarintGenerated(dAtA, i, uint64(m.Port.Size())) 1789 n38, err := m.Port.MarshalTo(dAtA[i:]) 1790 if err != nil { 1791 return 0, err 1792 } 1793 i += n38 1794 } 1795 return i, nil 1796} 1797 1798func (m *NetworkPolicySpec) Marshal() (dAtA []byte, err error) { 1799 size := m.Size() 1800 dAtA = make([]byte, size) 1801 n, err := m.MarshalTo(dAtA) 1802 if err != nil { 1803 return nil, err 1804 } 1805 return dAtA[:n], nil 1806} 1807 1808func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) { 1809 var i int 1810 _ = i 1811 var l int 1812 _ = l 1813 dAtA[i] = 0xa 1814 i++ 1815 i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size())) 1816 n39, err := m.PodSelector.MarshalTo(dAtA[i:]) 1817 if err != nil { 1818 return 0, err 1819 } 1820 i += n39 1821 if len(m.Ingress) > 0 { 1822 for _, msg := range m.Ingress { 1823 dAtA[i] = 0x12 1824 i++ 1825 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1826 n, err := msg.MarshalTo(dAtA[i:]) 1827 if err != nil { 1828 return 0, err 1829 } 1830 i += n 1831 } 1832 } 1833 if len(m.Egress) > 0 { 1834 for _, msg := range m.Egress { 1835 dAtA[i] = 0x1a 1836 i++ 1837 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1838 n, err := msg.MarshalTo(dAtA[i:]) 1839 if err != nil { 1840 return 0, err 1841 } 1842 i += n 1843 } 1844 } 1845 if len(m.PolicyTypes) > 0 { 1846 for _, s := range m.PolicyTypes { 1847 dAtA[i] = 0x22 1848 i++ 1849 l = len(s) 1850 for l >= 1<<7 { 1851 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1852 l >>= 7 1853 i++ 1854 } 1855 dAtA[i] = uint8(l) 1856 i++ 1857 i += copy(dAtA[i:], s) 1858 } 1859 } 1860 return i, nil 1861} 1862 1863func (m *PodSecurityPolicy) Marshal() (dAtA []byte, err error) { 1864 size := m.Size() 1865 dAtA = make([]byte, size) 1866 n, err := m.MarshalTo(dAtA) 1867 if err != nil { 1868 return nil, err 1869 } 1870 return dAtA[:n], nil 1871} 1872 1873func (m *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) { 1874 var i int 1875 _ = i 1876 var l int 1877 _ = l 1878 dAtA[i] = 0xa 1879 i++ 1880 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 1881 n40, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 1882 if err != nil { 1883 return 0, err 1884 } 1885 i += n40 1886 dAtA[i] = 0x12 1887 i++ 1888 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 1889 n41, err := m.Spec.MarshalTo(dAtA[i:]) 1890 if err != nil { 1891 return 0, err 1892 } 1893 i += n41 1894 return i, nil 1895} 1896 1897func (m *PodSecurityPolicyList) Marshal() (dAtA []byte, err error) { 1898 size := m.Size() 1899 dAtA = make([]byte, size) 1900 n, err := m.MarshalTo(dAtA) 1901 if err != nil { 1902 return nil, err 1903 } 1904 return dAtA[:n], nil 1905} 1906 1907func (m *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) { 1908 var i int 1909 _ = i 1910 var l int 1911 _ = l 1912 dAtA[i] = 0xa 1913 i++ 1914 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 1915 n42, err := m.ListMeta.MarshalTo(dAtA[i:]) 1916 if err != nil { 1917 return 0, err 1918 } 1919 i += n42 1920 if len(m.Items) > 0 { 1921 for _, msg := range m.Items { 1922 dAtA[i] = 0x12 1923 i++ 1924 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1925 n, err := msg.MarshalTo(dAtA[i:]) 1926 if err != nil { 1927 return 0, err 1928 } 1929 i += n 1930 } 1931 } 1932 return i, nil 1933} 1934 1935func (m *PodSecurityPolicySpec) Marshal() (dAtA []byte, err error) { 1936 size := m.Size() 1937 dAtA = make([]byte, size) 1938 n, err := m.MarshalTo(dAtA) 1939 if err != nil { 1940 return nil, err 1941 } 1942 return dAtA[:n], nil 1943} 1944 1945func (m *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) { 1946 var i int 1947 _ = i 1948 var l int 1949 _ = l 1950 dAtA[i] = 0x8 1951 i++ 1952 if m.Privileged { 1953 dAtA[i] = 1 1954 } else { 1955 dAtA[i] = 0 1956 } 1957 i++ 1958 if len(m.DefaultAddCapabilities) > 0 { 1959 for _, s := range m.DefaultAddCapabilities { 1960 dAtA[i] = 0x12 1961 i++ 1962 l = len(s) 1963 for l >= 1<<7 { 1964 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1965 l >>= 7 1966 i++ 1967 } 1968 dAtA[i] = uint8(l) 1969 i++ 1970 i += copy(dAtA[i:], s) 1971 } 1972 } 1973 if len(m.RequiredDropCapabilities) > 0 { 1974 for _, s := range m.RequiredDropCapabilities { 1975 dAtA[i] = 0x1a 1976 i++ 1977 l = len(s) 1978 for l >= 1<<7 { 1979 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1980 l >>= 7 1981 i++ 1982 } 1983 dAtA[i] = uint8(l) 1984 i++ 1985 i += copy(dAtA[i:], s) 1986 } 1987 } 1988 if len(m.AllowedCapabilities) > 0 { 1989 for _, s := range m.AllowedCapabilities { 1990 dAtA[i] = 0x22 1991 i++ 1992 l = len(s) 1993 for l >= 1<<7 { 1994 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1995 l >>= 7 1996 i++ 1997 } 1998 dAtA[i] = uint8(l) 1999 i++ 2000 i += copy(dAtA[i:], s) 2001 } 2002 } 2003 if len(m.Volumes) > 0 { 2004 for _, s := range m.Volumes { 2005 dAtA[i] = 0x2a 2006 i++ 2007 l = len(s) 2008 for l >= 1<<7 { 2009 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2010 l >>= 7 2011 i++ 2012 } 2013 dAtA[i] = uint8(l) 2014 i++ 2015 i += copy(dAtA[i:], s) 2016 } 2017 } 2018 dAtA[i] = 0x30 2019 i++ 2020 if m.HostNetwork { 2021 dAtA[i] = 1 2022 } else { 2023 dAtA[i] = 0 2024 } 2025 i++ 2026 if len(m.HostPorts) > 0 { 2027 for _, msg := range m.HostPorts { 2028 dAtA[i] = 0x3a 2029 i++ 2030 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2031 n, err := msg.MarshalTo(dAtA[i:]) 2032 if err != nil { 2033 return 0, err 2034 } 2035 i += n 2036 } 2037 } 2038 dAtA[i] = 0x40 2039 i++ 2040 if m.HostPID { 2041 dAtA[i] = 1 2042 } else { 2043 dAtA[i] = 0 2044 } 2045 i++ 2046 dAtA[i] = 0x48 2047 i++ 2048 if m.HostIPC { 2049 dAtA[i] = 1 2050 } else { 2051 dAtA[i] = 0 2052 } 2053 i++ 2054 dAtA[i] = 0x52 2055 i++ 2056 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinux.Size())) 2057 n43, err := m.SELinux.MarshalTo(dAtA[i:]) 2058 if err != nil { 2059 return 0, err 2060 } 2061 i += n43 2062 dAtA[i] = 0x5a 2063 i++ 2064 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsUser.Size())) 2065 n44, err := m.RunAsUser.MarshalTo(dAtA[i:]) 2066 if err != nil { 2067 return 0, err 2068 } 2069 i += n44 2070 dAtA[i] = 0x62 2071 i++ 2072 i = encodeVarintGenerated(dAtA, i, uint64(m.SupplementalGroups.Size())) 2073 n45, err := m.SupplementalGroups.MarshalTo(dAtA[i:]) 2074 if err != nil { 2075 return 0, err 2076 } 2077 i += n45 2078 dAtA[i] = 0x6a 2079 i++ 2080 i = encodeVarintGenerated(dAtA, i, uint64(m.FSGroup.Size())) 2081 n46, err := m.FSGroup.MarshalTo(dAtA[i:]) 2082 if err != nil { 2083 return 0, err 2084 } 2085 i += n46 2086 dAtA[i] = 0x70 2087 i++ 2088 if m.ReadOnlyRootFilesystem { 2089 dAtA[i] = 1 2090 } else { 2091 dAtA[i] = 0 2092 } 2093 i++ 2094 if m.DefaultAllowPrivilegeEscalation != nil { 2095 dAtA[i] = 0x78 2096 i++ 2097 if *m.DefaultAllowPrivilegeEscalation { 2098 dAtA[i] = 1 2099 } else { 2100 dAtA[i] = 0 2101 } 2102 i++ 2103 } 2104 if m.AllowPrivilegeEscalation != nil { 2105 dAtA[i] = 0x80 2106 i++ 2107 dAtA[i] = 0x1 2108 i++ 2109 if *m.AllowPrivilegeEscalation { 2110 dAtA[i] = 1 2111 } else { 2112 dAtA[i] = 0 2113 } 2114 i++ 2115 } 2116 if len(m.AllowedHostPaths) > 0 { 2117 for _, msg := range m.AllowedHostPaths { 2118 dAtA[i] = 0x8a 2119 i++ 2120 dAtA[i] = 0x1 2121 i++ 2122 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2123 n, err := msg.MarshalTo(dAtA[i:]) 2124 if err != nil { 2125 return 0, err 2126 } 2127 i += n 2128 } 2129 } 2130 if len(m.AllowedFlexVolumes) > 0 { 2131 for _, msg := range m.AllowedFlexVolumes { 2132 dAtA[i] = 0x92 2133 i++ 2134 dAtA[i] = 0x1 2135 i++ 2136 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2137 n, err := msg.MarshalTo(dAtA[i:]) 2138 if err != nil { 2139 return 0, err 2140 } 2141 i += n 2142 } 2143 } 2144 if len(m.AllowedUnsafeSysctls) > 0 { 2145 for _, s := range m.AllowedUnsafeSysctls { 2146 dAtA[i] = 0x9a 2147 i++ 2148 dAtA[i] = 0x1 2149 i++ 2150 l = len(s) 2151 for l >= 1<<7 { 2152 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2153 l >>= 7 2154 i++ 2155 } 2156 dAtA[i] = uint8(l) 2157 i++ 2158 i += copy(dAtA[i:], s) 2159 } 2160 } 2161 if len(m.ForbiddenSysctls) > 0 { 2162 for _, s := range m.ForbiddenSysctls { 2163 dAtA[i] = 0xa2 2164 i++ 2165 dAtA[i] = 0x1 2166 i++ 2167 l = len(s) 2168 for l >= 1<<7 { 2169 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2170 l >>= 7 2171 i++ 2172 } 2173 dAtA[i] = uint8(l) 2174 i++ 2175 i += copy(dAtA[i:], s) 2176 } 2177 } 2178 if len(m.AllowedProcMountTypes) > 0 { 2179 for _, s := range m.AllowedProcMountTypes { 2180 dAtA[i] = 0xaa 2181 i++ 2182 dAtA[i] = 0x1 2183 i++ 2184 l = len(s) 2185 for l >= 1<<7 { 2186 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2187 l >>= 7 2188 i++ 2189 } 2190 dAtA[i] = uint8(l) 2191 i++ 2192 i += copy(dAtA[i:], s) 2193 } 2194 } 2195 if m.RunAsGroup != nil { 2196 dAtA[i] = 0xb2 2197 i++ 2198 dAtA[i] = 0x1 2199 i++ 2200 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsGroup.Size())) 2201 n47, err := m.RunAsGroup.MarshalTo(dAtA[i:]) 2202 if err != nil { 2203 return 0, err 2204 } 2205 i += n47 2206 } 2207 if len(m.AllowedCSIDrivers) > 0 { 2208 for _, msg := range m.AllowedCSIDrivers { 2209 dAtA[i] = 0xba 2210 i++ 2211 dAtA[i] = 0x1 2212 i++ 2213 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2214 n, err := msg.MarshalTo(dAtA[i:]) 2215 if err != nil { 2216 return 0, err 2217 } 2218 i += n 2219 } 2220 } 2221 return i, nil 2222} 2223 2224func (m *ReplicaSet) Marshal() (dAtA []byte, err error) { 2225 size := m.Size() 2226 dAtA = make([]byte, size) 2227 n, err := m.MarshalTo(dAtA) 2228 if err != nil { 2229 return nil, err 2230 } 2231 return dAtA[:n], nil 2232} 2233 2234func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) { 2235 var i int 2236 _ = i 2237 var l int 2238 _ = l 2239 dAtA[i] = 0xa 2240 i++ 2241 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 2242 n48, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 2243 if err != nil { 2244 return 0, err 2245 } 2246 i += n48 2247 dAtA[i] = 0x12 2248 i++ 2249 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 2250 n49, err := m.Spec.MarshalTo(dAtA[i:]) 2251 if err != nil { 2252 return 0, err 2253 } 2254 i += n49 2255 dAtA[i] = 0x1a 2256 i++ 2257 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 2258 n50, err := m.Status.MarshalTo(dAtA[i:]) 2259 if err != nil { 2260 return 0, err 2261 } 2262 i += n50 2263 return i, nil 2264} 2265 2266func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) { 2267 size := m.Size() 2268 dAtA = make([]byte, size) 2269 n, err := m.MarshalTo(dAtA) 2270 if err != nil { 2271 return nil, err 2272 } 2273 return dAtA[:n], nil 2274} 2275 2276func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) { 2277 var i int 2278 _ = i 2279 var l int 2280 _ = l 2281 dAtA[i] = 0xa 2282 i++ 2283 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 2284 i += copy(dAtA[i:], m.Type) 2285 dAtA[i] = 0x12 2286 i++ 2287 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) 2288 i += copy(dAtA[i:], m.Status) 2289 dAtA[i] = 0x1a 2290 i++ 2291 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size())) 2292 n51, err := m.LastTransitionTime.MarshalTo(dAtA[i:]) 2293 if err != nil { 2294 return 0, err 2295 } 2296 i += n51 2297 dAtA[i] = 0x22 2298 i++ 2299 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) 2300 i += copy(dAtA[i:], m.Reason) 2301 dAtA[i] = 0x2a 2302 i++ 2303 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) 2304 i += copy(dAtA[i:], m.Message) 2305 return i, nil 2306} 2307 2308func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) { 2309 size := m.Size() 2310 dAtA = make([]byte, size) 2311 n, err := m.MarshalTo(dAtA) 2312 if err != nil { 2313 return nil, err 2314 } 2315 return dAtA[:n], nil 2316} 2317 2318func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) { 2319 var i int 2320 _ = i 2321 var l int 2322 _ = l 2323 dAtA[i] = 0xa 2324 i++ 2325 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 2326 n52, err := m.ListMeta.MarshalTo(dAtA[i:]) 2327 if err != nil { 2328 return 0, err 2329 } 2330 i += n52 2331 if len(m.Items) > 0 { 2332 for _, msg := range m.Items { 2333 dAtA[i] = 0x12 2334 i++ 2335 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2336 n, err := msg.MarshalTo(dAtA[i:]) 2337 if err != nil { 2338 return 0, err 2339 } 2340 i += n 2341 } 2342 } 2343 return i, nil 2344} 2345 2346func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) { 2347 size := m.Size() 2348 dAtA = make([]byte, size) 2349 n, err := m.MarshalTo(dAtA) 2350 if err != nil { 2351 return nil, err 2352 } 2353 return dAtA[:n], nil 2354} 2355 2356func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) { 2357 var i int 2358 _ = i 2359 var l int 2360 _ = l 2361 if m.Replicas != nil { 2362 dAtA[i] = 0x8 2363 i++ 2364 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) 2365 } 2366 if m.Selector != nil { 2367 dAtA[i] = 0x12 2368 i++ 2369 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size())) 2370 n53, err := m.Selector.MarshalTo(dAtA[i:]) 2371 if err != nil { 2372 return 0, err 2373 } 2374 i += n53 2375 } 2376 dAtA[i] = 0x1a 2377 i++ 2378 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size())) 2379 n54, err := m.Template.MarshalTo(dAtA[i:]) 2380 if err != nil { 2381 return 0, err 2382 } 2383 i += n54 2384 dAtA[i] = 0x20 2385 i++ 2386 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) 2387 return i, nil 2388} 2389 2390func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) { 2391 size := m.Size() 2392 dAtA = make([]byte, size) 2393 n, err := m.MarshalTo(dAtA) 2394 if err != nil { 2395 return nil, err 2396 } 2397 return dAtA[:n], nil 2398} 2399 2400func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) { 2401 var i int 2402 _ = i 2403 var l int 2404 _ = l 2405 dAtA[i] = 0x8 2406 i++ 2407 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 2408 dAtA[i] = 0x10 2409 i++ 2410 i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas)) 2411 dAtA[i] = 0x18 2412 i++ 2413 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) 2414 dAtA[i] = 0x20 2415 i++ 2416 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) 2417 dAtA[i] = 0x28 2418 i++ 2419 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) 2420 if len(m.Conditions) > 0 { 2421 for _, msg := range m.Conditions { 2422 dAtA[i] = 0x32 2423 i++ 2424 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2425 n, err := msg.MarshalTo(dAtA[i:]) 2426 if err != nil { 2427 return 0, err 2428 } 2429 i += n 2430 } 2431 } 2432 return i, nil 2433} 2434 2435func (m *ReplicationControllerDummy) Marshal() (dAtA []byte, err error) { 2436 size := m.Size() 2437 dAtA = make([]byte, size) 2438 n, err := m.MarshalTo(dAtA) 2439 if err != nil { 2440 return nil, err 2441 } 2442 return dAtA[:n], nil 2443} 2444 2445func (m *ReplicationControllerDummy) MarshalTo(dAtA []byte) (int, error) { 2446 var i int 2447 _ = i 2448 var l int 2449 _ = l 2450 return i, nil 2451} 2452 2453func (m *RollbackConfig) Marshal() (dAtA []byte, err error) { 2454 size := m.Size() 2455 dAtA = make([]byte, size) 2456 n, err := m.MarshalTo(dAtA) 2457 if err != nil { 2458 return nil, err 2459 } 2460 return dAtA[:n], nil 2461} 2462 2463func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) { 2464 var i int 2465 _ = i 2466 var l int 2467 _ = l 2468 dAtA[i] = 0x8 2469 i++ 2470 i = encodeVarintGenerated(dAtA, i, uint64(m.Revision)) 2471 return i, nil 2472} 2473 2474func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) { 2475 size := m.Size() 2476 dAtA = make([]byte, size) 2477 n, err := m.MarshalTo(dAtA) 2478 if err != nil { 2479 return nil, err 2480 } 2481 return dAtA[:n], nil 2482} 2483 2484func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) { 2485 var i int 2486 _ = i 2487 var l int 2488 _ = l 2489 if m.MaxUnavailable != nil { 2490 dAtA[i] = 0xa 2491 i++ 2492 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size())) 2493 n55, err := m.MaxUnavailable.MarshalTo(dAtA[i:]) 2494 if err != nil { 2495 return 0, err 2496 } 2497 i += n55 2498 } 2499 return i, nil 2500} 2501 2502func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) { 2503 size := m.Size() 2504 dAtA = make([]byte, size) 2505 n, err := m.MarshalTo(dAtA) 2506 if err != nil { 2507 return nil, err 2508 } 2509 return dAtA[:n], nil 2510} 2511 2512func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) { 2513 var i int 2514 _ = i 2515 var l int 2516 _ = l 2517 if m.MaxUnavailable != nil { 2518 dAtA[i] = 0xa 2519 i++ 2520 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size())) 2521 n56, err := m.MaxUnavailable.MarshalTo(dAtA[i:]) 2522 if err != nil { 2523 return 0, err 2524 } 2525 i += n56 2526 } 2527 if m.MaxSurge != nil { 2528 dAtA[i] = 0x12 2529 i++ 2530 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size())) 2531 n57, err := m.MaxSurge.MarshalTo(dAtA[i:]) 2532 if err != nil { 2533 return 0, err 2534 } 2535 i += n57 2536 } 2537 return i, nil 2538} 2539 2540func (m *RunAsGroupStrategyOptions) Marshal() (dAtA []byte, err error) { 2541 size := m.Size() 2542 dAtA = make([]byte, size) 2543 n, err := m.MarshalTo(dAtA) 2544 if err != nil { 2545 return nil, err 2546 } 2547 return dAtA[:n], nil 2548} 2549 2550func (m *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2551 var i int 2552 _ = i 2553 var l int 2554 _ = l 2555 dAtA[i] = 0xa 2556 i++ 2557 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2558 i += copy(dAtA[i:], m.Rule) 2559 if len(m.Ranges) > 0 { 2560 for _, msg := range m.Ranges { 2561 dAtA[i] = 0x12 2562 i++ 2563 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2564 n, err := msg.MarshalTo(dAtA[i:]) 2565 if err != nil { 2566 return 0, err 2567 } 2568 i += n 2569 } 2570 } 2571 return i, nil 2572} 2573 2574func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) { 2575 size := m.Size() 2576 dAtA = make([]byte, size) 2577 n, err := m.MarshalTo(dAtA) 2578 if err != nil { 2579 return nil, err 2580 } 2581 return dAtA[:n], nil 2582} 2583 2584func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2585 var i int 2586 _ = i 2587 var l int 2588 _ = l 2589 dAtA[i] = 0xa 2590 i++ 2591 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2592 i += copy(dAtA[i:], m.Rule) 2593 if len(m.Ranges) > 0 { 2594 for _, msg := range m.Ranges { 2595 dAtA[i] = 0x12 2596 i++ 2597 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2598 n, err := msg.MarshalTo(dAtA[i:]) 2599 if err != nil { 2600 return 0, err 2601 } 2602 i += n 2603 } 2604 } 2605 return i, nil 2606} 2607 2608func (m *SELinuxStrategyOptions) Marshal() (dAtA []byte, err error) { 2609 size := m.Size() 2610 dAtA = make([]byte, size) 2611 n, err := m.MarshalTo(dAtA) 2612 if err != nil { 2613 return nil, err 2614 } 2615 return dAtA[:n], nil 2616} 2617 2618func (m *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2619 var i int 2620 _ = i 2621 var l int 2622 _ = l 2623 dAtA[i] = 0xa 2624 i++ 2625 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2626 i += copy(dAtA[i:], m.Rule) 2627 if m.SELinuxOptions != nil { 2628 dAtA[i] = 0x12 2629 i++ 2630 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinuxOptions.Size())) 2631 n58, err := m.SELinuxOptions.MarshalTo(dAtA[i:]) 2632 if err != nil { 2633 return 0, err 2634 } 2635 i += n58 2636 } 2637 return i, nil 2638} 2639 2640func (m *Scale) Marshal() (dAtA []byte, err error) { 2641 size := m.Size() 2642 dAtA = make([]byte, size) 2643 n, err := m.MarshalTo(dAtA) 2644 if err != nil { 2645 return nil, err 2646 } 2647 return dAtA[:n], nil 2648} 2649 2650func (m *Scale) MarshalTo(dAtA []byte) (int, error) { 2651 var i int 2652 _ = i 2653 var l int 2654 _ = l 2655 dAtA[i] = 0xa 2656 i++ 2657 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 2658 n59, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 2659 if err != nil { 2660 return 0, err 2661 } 2662 i += n59 2663 dAtA[i] = 0x12 2664 i++ 2665 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 2666 n60, err := m.Spec.MarshalTo(dAtA[i:]) 2667 if err != nil { 2668 return 0, err 2669 } 2670 i += n60 2671 dAtA[i] = 0x1a 2672 i++ 2673 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 2674 n61, err := m.Status.MarshalTo(dAtA[i:]) 2675 if err != nil { 2676 return 0, err 2677 } 2678 i += n61 2679 return i, nil 2680} 2681 2682func (m *ScaleSpec) Marshal() (dAtA []byte, err error) { 2683 size := m.Size() 2684 dAtA = make([]byte, size) 2685 n, err := m.MarshalTo(dAtA) 2686 if err != nil { 2687 return nil, err 2688 } 2689 return dAtA[:n], nil 2690} 2691 2692func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) { 2693 var i int 2694 _ = i 2695 var l int 2696 _ = l 2697 dAtA[i] = 0x8 2698 i++ 2699 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 2700 return i, nil 2701} 2702 2703func (m *ScaleStatus) Marshal() (dAtA []byte, err error) { 2704 size := m.Size() 2705 dAtA = make([]byte, size) 2706 n, err := m.MarshalTo(dAtA) 2707 if err != nil { 2708 return nil, err 2709 } 2710 return dAtA[:n], nil 2711} 2712 2713func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) { 2714 var i int 2715 _ = i 2716 var l int 2717 _ = l 2718 dAtA[i] = 0x8 2719 i++ 2720 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 2721 if len(m.Selector) > 0 { 2722 keysForSelector := make([]string, 0, len(m.Selector)) 2723 for k := range m.Selector { 2724 keysForSelector = append(keysForSelector, string(k)) 2725 } 2726 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector) 2727 for _, k := range keysForSelector { 2728 dAtA[i] = 0x12 2729 i++ 2730 v := m.Selector[string(k)] 2731 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 2732 i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) 2733 dAtA[i] = 0xa 2734 i++ 2735 i = encodeVarintGenerated(dAtA, i, uint64(len(k))) 2736 i += copy(dAtA[i:], k) 2737 dAtA[i] = 0x12 2738 i++ 2739 i = encodeVarintGenerated(dAtA, i, uint64(len(v))) 2740 i += copy(dAtA[i:], v) 2741 } 2742 } 2743 dAtA[i] = 0x1a 2744 i++ 2745 i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector))) 2746 i += copy(dAtA[i:], m.TargetSelector) 2747 return i, nil 2748} 2749 2750func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) { 2751 size := m.Size() 2752 dAtA = make([]byte, size) 2753 n, err := m.MarshalTo(dAtA) 2754 if err != nil { 2755 return nil, err 2756 } 2757 return dAtA[:n], nil 2758} 2759 2760func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2761 var i int 2762 _ = i 2763 var l int 2764 _ = l 2765 dAtA[i] = 0xa 2766 i++ 2767 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2768 i += copy(dAtA[i:], m.Rule) 2769 if len(m.Ranges) > 0 { 2770 for _, msg := range m.Ranges { 2771 dAtA[i] = 0x12 2772 i++ 2773 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2774 n, err := msg.MarshalTo(dAtA[i:]) 2775 if err != nil { 2776 return 0, err 2777 } 2778 i += n 2779 } 2780 } 2781 return i, nil 2782} 2783 2784func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { 2785 for v >= 1<<7 { 2786 dAtA[offset] = uint8(v&0x7f | 0x80) 2787 v >>= 7 2788 offset++ 2789 } 2790 dAtA[offset] = uint8(v) 2791 return offset + 1 2792} 2793func (m *AllowedCSIDriver) Size() (n int) { 2794 var l int 2795 _ = l 2796 l = len(m.Name) 2797 n += 1 + l + sovGenerated(uint64(l)) 2798 return n 2799} 2800 2801func (m *AllowedFlexVolume) Size() (n int) { 2802 var l int 2803 _ = l 2804 l = len(m.Driver) 2805 n += 1 + l + sovGenerated(uint64(l)) 2806 return n 2807} 2808 2809func (m *AllowedHostPath) Size() (n int) { 2810 var l int 2811 _ = l 2812 l = len(m.PathPrefix) 2813 n += 1 + l + sovGenerated(uint64(l)) 2814 n += 2 2815 return n 2816} 2817 2818func (m *DaemonSet) Size() (n int) { 2819 var l int 2820 _ = l 2821 l = m.ObjectMeta.Size() 2822 n += 1 + l + sovGenerated(uint64(l)) 2823 l = m.Spec.Size() 2824 n += 1 + l + sovGenerated(uint64(l)) 2825 l = m.Status.Size() 2826 n += 1 + l + sovGenerated(uint64(l)) 2827 return n 2828} 2829 2830func (m *DaemonSetCondition) Size() (n int) { 2831 var l int 2832 _ = l 2833 l = len(m.Type) 2834 n += 1 + l + sovGenerated(uint64(l)) 2835 l = len(m.Status) 2836 n += 1 + l + sovGenerated(uint64(l)) 2837 l = m.LastTransitionTime.Size() 2838 n += 1 + l + sovGenerated(uint64(l)) 2839 l = len(m.Reason) 2840 n += 1 + l + sovGenerated(uint64(l)) 2841 l = len(m.Message) 2842 n += 1 + l + sovGenerated(uint64(l)) 2843 return n 2844} 2845 2846func (m *DaemonSetList) Size() (n int) { 2847 var l int 2848 _ = l 2849 l = m.ListMeta.Size() 2850 n += 1 + l + sovGenerated(uint64(l)) 2851 if len(m.Items) > 0 { 2852 for _, e := range m.Items { 2853 l = e.Size() 2854 n += 1 + l + sovGenerated(uint64(l)) 2855 } 2856 } 2857 return n 2858} 2859 2860func (m *DaemonSetSpec) Size() (n int) { 2861 var l int 2862 _ = l 2863 if m.Selector != nil { 2864 l = m.Selector.Size() 2865 n += 1 + l + sovGenerated(uint64(l)) 2866 } 2867 l = m.Template.Size() 2868 n += 1 + l + sovGenerated(uint64(l)) 2869 l = m.UpdateStrategy.Size() 2870 n += 1 + l + sovGenerated(uint64(l)) 2871 n += 1 + sovGenerated(uint64(m.MinReadySeconds)) 2872 n += 1 + sovGenerated(uint64(m.TemplateGeneration)) 2873 if m.RevisionHistoryLimit != nil { 2874 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) 2875 } 2876 return n 2877} 2878 2879func (m *DaemonSetStatus) Size() (n int) { 2880 var l int 2881 _ = l 2882 n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled)) 2883 n += 1 + sovGenerated(uint64(m.NumberMisscheduled)) 2884 n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled)) 2885 n += 1 + sovGenerated(uint64(m.NumberReady)) 2886 n += 1 + sovGenerated(uint64(m.ObservedGeneration)) 2887 n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled)) 2888 n += 1 + sovGenerated(uint64(m.NumberAvailable)) 2889 n += 1 + sovGenerated(uint64(m.NumberUnavailable)) 2890 if m.CollisionCount != nil { 2891 n += 1 + sovGenerated(uint64(*m.CollisionCount)) 2892 } 2893 if len(m.Conditions) > 0 { 2894 for _, e := range m.Conditions { 2895 l = e.Size() 2896 n += 1 + l + sovGenerated(uint64(l)) 2897 } 2898 } 2899 return n 2900} 2901 2902func (m *DaemonSetUpdateStrategy) Size() (n int) { 2903 var l int 2904 _ = l 2905 l = len(m.Type) 2906 n += 1 + l + sovGenerated(uint64(l)) 2907 if m.RollingUpdate != nil { 2908 l = m.RollingUpdate.Size() 2909 n += 1 + l + sovGenerated(uint64(l)) 2910 } 2911 return n 2912} 2913 2914func (m *Deployment) Size() (n int) { 2915 var l int 2916 _ = l 2917 l = m.ObjectMeta.Size() 2918 n += 1 + l + sovGenerated(uint64(l)) 2919 l = m.Spec.Size() 2920 n += 1 + l + sovGenerated(uint64(l)) 2921 l = m.Status.Size() 2922 n += 1 + l + sovGenerated(uint64(l)) 2923 return n 2924} 2925 2926func (m *DeploymentCondition) Size() (n int) { 2927 var l int 2928 _ = l 2929 l = len(m.Type) 2930 n += 1 + l + sovGenerated(uint64(l)) 2931 l = len(m.Status) 2932 n += 1 + l + sovGenerated(uint64(l)) 2933 l = len(m.Reason) 2934 n += 1 + l + sovGenerated(uint64(l)) 2935 l = len(m.Message) 2936 n += 1 + l + sovGenerated(uint64(l)) 2937 l = m.LastUpdateTime.Size() 2938 n += 1 + l + sovGenerated(uint64(l)) 2939 l = m.LastTransitionTime.Size() 2940 n += 1 + l + sovGenerated(uint64(l)) 2941 return n 2942} 2943 2944func (m *DeploymentList) Size() (n int) { 2945 var l int 2946 _ = l 2947 l = m.ListMeta.Size() 2948 n += 1 + l + sovGenerated(uint64(l)) 2949 if len(m.Items) > 0 { 2950 for _, e := range m.Items { 2951 l = e.Size() 2952 n += 1 + l + sovGenerated(uint64(l)) 2953 } 2954 } 2955 return n 2956} 2957 2958func (m *DeploymentRollback) Size() (n int) { 2959 var l int 2960 _ = l 2961 l = len(m.Name) 2962 n += 1 + l + sovGenerated(uint64(l)) 2963 if len(m.UpdatedAnnotations) > 0 { 2964 for k, v := range m.UpdatedAnnotations { 2965 _ = k 2966 _ = v 2967 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 2968 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) 2969 } 2970 } 2971 l = m.RollbackTo.Size() 2972 n += 1 + l + sovGenerated(uint64(l)) 2973 return n 2974} 2975 2976func (m *DeploymentSpec) Size() (n int) { 2977 var l int 2978 _ = l 2979 if m.Replicas != nil { 2980 n += 1 + sovGenerated(uint64(*m.Replicas)) 2981 } 2982 if m.Selector != nil { 2983 l = m.Selector.Size() 2984 n += 1 + l + sovGenerated(uint64(l)) 2985 } 2986 l = m.Template.Size() 2987 n += 1 + l + sovGenerated(uint64(l)) 2988 l = m.Strategy.Size() 2989 n += 1 + l + sovGenerated(uint64(l)) 2990 n += 1 + sovGenerated(uint64(m.MinReadySeconds)) 2991 if m.RevisionHistoryLimit != nil { 2992 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) 2993 } 2994 n += 2 2995 if m.RollbackTo != nil { 2996 l = m.RollbackTo.Size() 2997 n += 1 + l + sovGenerated(uint64(l)) 2998 } 2999 if m.ProgressDeadlineSeconds != nil { 3000 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds)) 3001 } 3002 return n 3003} 3004 3005func (m *DeploymentStatus) Size() (n int) { 3006 var l int 3007 _ = l 3008 n += 1 + sovGenerated(uint64(m.ObservedGeneration)) 3009 n += 1 + sovGenerated(uint64(m.Replicas)) 3010 n += 1 + sovGenerated(uint64(m.UpdatedReplicas)) 3011 n += 1 + sovGenerated(uint64(m.AvailableReplicas)) 3012 n += 1 + sovGenerated(uint64(m.UnavailableReplicas)) 3013 if len(m.Conditions) > 0 { 3014 for _, e := range m.Conditions { 3015 l = e.Size() 3016 n += 1 + l + sovGenerated(uint64(l)) 3017 } 3018 } 3019 n += 1 + sovGenerated(uint64(m.ReadyReplicas)) 3020 if m.CollisionCount != nil { 3021 n += 1 + sovGenerated(uint64(*m.CollisionCount)) 3022 } 3023 return n 3024} 3025 3026func (m *DeploymentStrategy) Size() (n int) { 3027 var l int 3028 _ = l 3029 l = len(m.Type) 3030 n += 1 + l + sovGenerated(uint64(l)) 3031 if m.RollingUpdate != nil { 3032 l = m.RollingUpdate.Size() 3033 n += 1 + l + sovGenerated(uint64(l)) 3034 } 3035 return n 3036} 3037 3038func (m *FSGroupStrategyOptions) Size() (n int) { 3039 var l int 3040 _ = l 3041 l = len(m.Rule) 3042 n += 1 + l + sovGenerated(uint64(l)) 3043 if len(m.Ranges) > 0 { 3044 for _, e := range m.Ranges { 3045 l = e.Size() 3046 n += 1 + l + sovGenerated(uint64(l)) 3047 } 3048 } 3049 return n 3050} 3051 3052func (m *HTTPIngressPath) Size() (n int) { 3053 var l int 3054 _ = l 3055 l = len(m.Path) 3056 n += 1 + l + sovGenerated(uint64(l)) 3057 l = m.Backend.Size() 3058 n += 1 + l + sovGenerated(uint64(l)) 3059 return n 3060} 3061 3062func (m *HTTPIngressRuleValue) Size() (n int) { 3063 var l int 3064 _ = l 3065 if len(m.Paths) > 0 { 3066 for _, e := range m.Paths { 3067 l = e.Size() 3068 n += 1 + l + sovGenerated(uint64(l)) 3069 } 3070 } 3071 return n 3072} 3073 3074func (m *HostPortRange) Size() (n int) { 3075 var l int 3076 _ = l 3077 n += 1 + sovGenerated(uint64(m.Min)) 3078 n += 1 + sovGenerated(uint64(m.Max)) 3079 return n 3080} 3081 3082func (m *IDRange) Size() (n int) { 3083 var l int 3084 _ = l 3085 n += 1 + sovGenerated(uint64(m.Min)) 3086 n += 1 + sovGenerated(uint64(m.Max)) 3087 return n 3088} 3089 3090func (m *IPBlock) Size() (n int) { 3091 var l int 3092 _ = l 3093 l = len(m.CIDR) 3094 n += 1 + l + sovGenerated(uint64(l)) 3095 if len(m.Except) > 0 { 3096 for _, s := range m.Except { 3097 l = len(s) 3098 n += 1 + l + sovGenerated(uint64(l)) 3099 } 3100 } 3101 return n 3102} 3103 3104func (m *Ingress) Size() (n int) { 3105 var l int 3106 _ = l 3107 l = m.ObjectMeta.Size() 3108 n += 1 + l + sovGenerated(uint64(l)) 3109 l = m.Spec.Size() 3110 n += 1 + l + sovGenerated(uint64(l)) 3111 l = m.Status.Size() 3112 n += 1 + l + sovGenerated(uint64(l)) 3113 return n 3114} 3115 3116func (m *IngressBackend) Size() (n int) { 3117 var l int 3118 _ = l 3119 l = len(m.ServiceName) 3120 n += 1 + l + sovGenerated(uint64(l)) 3121 l = m.ServicePort.Size() 3122 n += 1 + l + sovGenerated(uint64(l)) 3123 return n 3124} 3125 3126func (m *IngressList) Size() (n int) { 3127 var l int 3128 _ = l 3129 l = m.ListMeta.Size() 3130 n += 1 + l + sovGenerated(uint64(l)) 3131 if len(m.Items) > 0 { 3132 for _, e := range m.Items { 3133 l = e.Size() 3134 n += 1 + l + sovGenerated(uint64(l)) 3135 } 3136 } 3137 return n 3138} 3139 3140func (m *IngressRule) Size() (n int) { 3141 var l int 3142 _ = l 3143 l = len(m.Host) 3144 n += 1 + l + sovGenerated(uint64(l)) 3145 l = m.IngressRuleValue.Size() 3146 n += 1 + l + sovGenerated(uint64(l)) 3147 return n 3148} 3149 3150func (m *IngressRuleValue) Size() (n int) { 3151 var l int 3152 _ = l 3153 if m.HTTP != nil { 3154 l = m.HTTP.Size() 3155 n += 1 + l + sovGenerated(uint64(l)) 3156 } 3157 return n 3158} 3159 3160func (m *IngressSpec) Size() (n int) { 3161 var l int 3162 _ = l 3163 if m.Backend != nil { 3164 l = m.Backend.Size() 3165 n += 1 + l + sovGenerated(uint64(l)) 3166 } 3167 if len(m.TLS) > 0 { 3168 for _, e := range m.TLS { 3169 l = e.Size() 3170 n += 1 + l + sovGenerated(uint64(l)) 3171 } 3172 } 3173 if len(m.Rules) > 0 { 3174 for _, e := range m.Rules { 3175 l = e.Size() 3176 n += 1 + l + sovGenerated(uint64(l)) 3177 } 3178 } 3179 return n 3180} 3181 3182func (m *IngressStatus) Size() (n int) { 3183 var l int 3184 _ = l 3185 l = m.LoadBalancer.Size() 3186 n += 1 + l + sovGenerated(uint64(l)) 3187 return n 3188} 3189 3190func (m *IngressTLS) Size() (n int) { 3191 var l int 3192 _ = l 3193 if len(m.Hosts) > 0 { 3194 for _, s := range m.Hosts { 3195 l = len(s) 3196 n += 1 + l + sovGenerated(uint64(l)) 3197 } 3198 } 3199 l = len(m.SecretName) 3200 n += 1 + l + sovGenerated(uint64(l)) 3201 return n 3202} 3203 3204func (m *NetworkPolicy) Size() (n int) { 3205 var l int 3206 _ = l 3207 l = m.ObjectMeta.Size() 3208 n += 1 + l + sovGenerated(uint64(l)) 3209 l = m.Spec.Size() 3210 n += 1 + l + sovGenerated(uint64(l)) 3211 return n 3212} 3213 3214func (m *NetworkPolicyEgressRule) Size() (n int) { 3215 var l int 3216 _ = l 3217 if len(m.Ports) > 0 { 3218 for _, e := range m.Ports { 3219 l = e.Size() 3220 n += 1 + l + sovGenerated(uint64(l)) 3221 } 3222 } 3223 if len(m.To) > 0 { 3224 for _, e := range m.To { 3225 l = e.Size() 3226 n += 1 + l + sovGenerated(uint64(l)) 3227 } 3228 } 3229 return n 3230} 3231 3232func (m *NetworkPolicyIngressRule) Size() (n int) { 3233 var l int 3234 _ = l 3235 if len(m.Ports) > 0 { 3236 for _, e := range m.Ports { 3237 l = e.Size() 3238 n += 1 + l + sovGenerated(uint64(l)) 3239 } 3240 } 3241 if len(m.From) > 0 { 3242 for _, e := range m.From { 3243 l = e.Size() 3244 n += 1 + l + sovGenerated(uint64(l)) 3245 } 3246 } 3247 return n 3248} 3249 3250func (m *NetworkPolicyList) Size() (n int) { 3251 var l int 3252 _ = l 3253 l = m.ListMeta.Size() 3254 n += 1 + l + sovGenerated(uint64(l)) 3255 if len(m.Items) > 0 { 3256 for _, e := range m.Items { 3257 l = e.Size() 3258 n += 1 + l + sovGenerated(uint64(l)) 3259 } 3260 } 3261 return n 3262} 3263 3264func (m *NetworkPolicyPeer) Size() (n int) { 3265 var l int 3266 _ = l 3267 if m.PodSelector != nil { 3268 l = m.PodSelector.Size() 3269 n += 1 + l + sovGenerated(uint64(l)) 3270 } 3271 if m.NamespaceSelector != nil { 3272 l = m.NamespaceSelector.Size() 3273 n += 1 + l + sovGenerated(uint64(l)) 3274 } 3275 if m.IPBlock != nil { 3276 l = m.IPBlock.Size() 3277 n += 1 + l + sovGenerated(uint64(l)) 3278 } 3279 return n 3280} 3281 3282func (m *NetworkPolicyPort) Size() (n int) { 3283 var l int 3284 _ = l 3285 if m.Protocol != nil { 3286 l = len(*m.Protocol) 3287 n += 1 + l + sovGenerated(uint64(l)) 3288 } 3289 if m.Port != nil { 3290 l = m.Port.Size() 3291 n += 1 + l + sovGenerated(uint64(l)) 3292 } 3293 return n 3294} 3295 3296func (m *NetworkPolicySpec) Size() (n int) { 3297 var l int 3298 _ = l 3299 l = m.PodSelector.Size() 3300 n += 1 + l + sovGenerated(uint64(l)) 3301 if len(m.Ingress) > 0 { 3302 for _, e := range m.Ingress { 3303 l = e.Size() 3304 n += 1 + l + sovGenerated(uint64(l)) 3305 } 3306 } 3307 if len(m.Egress) > 0 { 3308 for _, e := range m.Egress { 3309 l = e.Size() 3310 n += 1 + l + sovGenerated(uint64(l)) 3311 } 3312 } 3313 if len(m.PolicyTypes) > 0 { 3314 for _, s := range m.PolicyTypes { 3315 l = len(s) 3316 n += 1 + l + sovGenerated(uint64(l)) 3317 } 3318 } 3319 return n 3320} 3321 3322func (m *PodSecurityPolicy) Size() (n int) { 3323 var l int 3324 _ = l 3325 l = m.ObjectMeta.Size() 3326 n += 1 + l + sovGenerated(uint64(l)) 3327 l = m.Spec.Size() 3328 n += 1 + l + sovGenerated(uint64(l)) 3329 return n 3330} 3331 3332func (m *PodSecurityPolicyList) Size() (n int) { 3333 var l int 3334 _ = l 3335 l = m.ListMeta.Size() 3336 n += 1 + l + sovGenerated(uint64(l)) 3337 if len(m.Items) > 0 { 3338 for _, e := range m.Items { 3339 l = e.Size() 3340 n += 1 + l + sovGenerated(uint64(l)) 3341 } 3342 } 3343 return n 3344} 3345 3346func (m *PodSecurityPolicySpec) Size() (n int) { 3347 var l int 3348 _ = l 3349 n += 2 3350 if len(m.DefaultAddCapabilities) > 0 { 3351 for _, s := range m.DefaultAddCapabilities { 3352 l = len(s) 3353 n += 1 + l + sovGenerated(uint64(l)) 3354 } 3355 } 3356 if len(m.RequiredDropCapabilities) > 0 { 3357 for _, s := range m.RequiredDropCapabilities { 3358 l = len(s) 3359 n += 1 + l + sovGenerated(uint64(l)) 3360 } 3361 } 3362 if len(m.AllowedCapabilities) > 0 { 3363 for _, s := range m.AllowedCapabilities { 3364 l = len(s) 3365 n += 1 + l + sovGenerated(uint64(l)) 3366 } 3367 } 3368 if len(m.Volumes) > 0 { 3369 for _, s := range m.Volumes { 3370 l = len(s) 3371 n += 1 + l + sovGenerated(uint64(l)) 3372 } 3373 } 3374 n += 2 3375 if len(m.HostPorts) > 0 { 3376 for _, e := range m.HostPorts { 3377 l = e.Size() 3378 n += 1 + l + sovGenerated(uint64(l)) 3379 } 3380 } 3381 n += 2 3382 n += 2 3383 l = m.SELinux.Size() 3384 n += 1 + l + sovGenerated(uint64(l)) 3385 l = m.RunAsUser.Size() 3386 n += 1 + l + sovGenerated(uint64(l)) 3387 l = m.SupplementalGroups.Size() 3388 n += 1 + l + sovGenerated(uint64(l)) 3389 l = m.FSGroup.Size() 3390 n += 1 + l + sovGenerated(uint64(l)) 3391 n += 2 3392 if m.DefaultAllowPrivilegeEscalation != nil { 3393 n += 2 3394 } 3395 if m.AllowPrivilegeEscalation != nil { 3396 n += 3 3397 } 3398 if len(m.AllowedHostPaths) > 0 { 3399 for _, e := range m.AllowedHostPaths { 3400 l = e.Size() 3401 n += 2 + l + sovGenerated(uint64(l)) 3402 } 3403 } 3404 if len(m.AllowedFlexVolumes) > 0 { 3405 for _, e := range m.AllowedFlexVolumes { 3406 l = e.Size() 3407 n += 2 + l + sovGenerated(uint64(l)) 3408 } 3409 } 3410 if len(m.AllowedUnsafeSysctls) > 0 { 3411 for _, s := range m.AllowedUnsafeSysctls { 3412 l = len(s) 3413 n += 2 + l + sovGenerated(uint64(l)) 3414 } 3415 } 3416 if len(m.ForbiddenSysctls) > 0 { 3417 for _, s := range m.ForbiddenSysctls { 3418 l = len(s) 3419 n += 2 + l + sovGenerated(uint64(l)) 3420 } 3421 } 3422 if len(m.AllowedProcMountTypes) > 0 { 3423 for _, s := range m.AllowedProcMountTypes { 3424 l = len(s) 3425 n += 2 + l + sovGenerated(uint64(l)) 3426 } 3427 } 3428 if m.RunAsGroup != nil { 3429 l = m.RunAsGroup.Size() 3430 n += 2 + l + sovGenerated(uint64(l)) 3431 } 3432 if len(m.AllowedCSIDrivers) > 0 { 3433 for _, e := range m.AllowedCSIDrivers { 3434 l = e.Size() 3435 n += 2 + l + sovGenerated(uint64(l)) 3436 } 3437 } 3438 return n 3439} 3440 3441func (m *ReplicaSet) Size() (n int) { 3442 var l int 3443 _ = l 3444 l = m.ObjectMeta.Size() 3445 n += 1 + l + sovGenerated(uint64(l)) 3446 l = m.Spec.Size() 3447 n += 1 + l + sovGenerated(uint64(l)) 3448 l = m.Status.Size() 3449 n += 1 + l + sovGenerated(uint64(l)) 3450 return n 3451} 3452 3453func (m *ReplicaSetCondition) Size() (n int) { 3454 var l int 3455 _ = l 3456 l = len(m.Type) 3457 n += 1 + l + sovGenerated(uint64(l)) 3458 l = len(m.Status) 3459 n += 1 + l + sovGenerated(uint64(l)) 3460 l = m.LastTransitionTime.Size() 3461 n += 1 + l + sovGenerated(uint64(l)) 3462 l = len(m.Reason) 3463 n += 1 + l + sovGenerated(uint64(l)) 3464 l = len(m.Message) 3465 n += 1 + l + sovGenerated(uint64(l)) 3466 return n 3467} 3468 3469func (m *ReplicaSetList) Size() (n int) { 3470 var l int 3471 _ = l 3472 l = m.ListMeta.Size() 3473 n += 1 + l + sovGenerated(uint64(l)) 3474 if len(m.Items) > 0 { 3475 for _, e := range m.Items { 3476 l = e.Size() 3477 n += 1 + l + sovGenerated(uint64(l)) 3478 } 3479 } 3480 return n 3481} 3482 3483func (m *ReplicaSetSpec) Size() (n int) { 3484 var l int 3485 _ = l 3486 if m.Replicas != nil { 3487 n += 1 + sovGenerated(uint64(*m.Replicas)) 3488 } 3489 if m.Selector != nil { 3490 l = m.Selector.Size() 3491 n += 1 + l + sovGenerated(uint64(l)) 3492 } 3493 l = m.Template.Size() 3494 n += 1 + l + sovGenerated(uint64(l)) 3495 n += 1 + sovGenerated(uint64(m.MinReadySeconds)) 3496 return n 3497} 3498 3499func (m *ReplicaSetStatus) Size() (n int) { 3500 var l int 3501 _ = l 3502 n += 1 + sovGenerated(uint64(m.Replicas)) 3503 n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas)) 3504 n += 1 + sovGenerated(uint64(m.ObservedGeneration)) 3505 n += 1 + sovGenerated(uint64(m.ReadyReplicas)) 3506 n += 1 + sovGenerated(uint64(m.AvailableReplicas)) 3507 if len(m.Conditions) > 0 { 3508 for _, e := range m.Conditions { 3509 l = e.Size() 3510 n += 1 + l + sovGenerated(uint64(l)) 3511 } 3512 } 3513 return n 3514} 3515 3516func (m *ReplicationControllerDummy) Size() (n int) { 3517 var l int 3518 _ = l 3519 return n 3520} 3521 3522func (m *RollbackConfig) Size() (n int) { 3523 var l int 3524 _ = l 3525 n += 1 + sovGenerated(uint64(m.Revision)) 3526 return n 3527} 3528 3529func (m *RollingUpdateDaemonSet) Size() (n int) { 3530 var l int 3531 _ = l 3532 if m.MaxUnavailable != nil { 3533 l = m.MaxUnavailable.Size() 3534 n += 1 + l + sovGenerated(uint64(l)) 3535 } 3536 return n 3537} 3538 3539func (m *RollingUpdateDeployment) Size() (n int) { 3540 var l int 3541 _ = l 3542 if m.MaxUnavailable != nil { 3543 l = m.MaxUnavailable.Size() 3544 n += 1 + l + sovGenerated(uint64(l)) 3545 } 3546 if m.MaxSurge != nil { 3547 l = m.MaxSurge.Size() 3548 n += 1 + l + sovGenerated(uint64(l)) 3549 } 3550 return n 3551} 3552 3553func (m *RunAsGroupStrategyOptions) Size() (n int) { 3554 var l int 3555 _ = l 3556 l = len(m.Rule) 3557 n += 1 + l + sovGenerated(uint64(l)) 3558 if len(m.Ranges) > 0 { 3559 for _, e := range m.Ranges { 3560 l = e.Size() 3561 n += 1 + l + sovGenerated(uint64(l)) 3562 } 3563 } 3564 return n 3565} 3566 3567func (m *RunAsUserStrategyOptions) Size() (n int) { 3568 var l int 3569 _ = l 3570 l = len(m.Rule) 3571 n += 1 + l + sovGenerated(uint64(l)) 3572 if len(m.Ranges) > 0 { 3573 for _, e := range m.Ranges { 3574 l = e.Size() 3575 n += 1 + l + sovGenerated(uint64(l)) 3576 } 3577 } 3578 return n 3579} 3580 3581func (m *SELinuxStrategyOptions) Size() (n int) { 3582 var l int 3583 _ = l 3584 l = len(m.Rule) 3585 n += 1 + l + sovGenerated(uint64(l)) 3586 if m.SELinuxOptions != nil { 3587 l = m.SELinuxOptions.Size() 3588 n += 1 + l + sovGenerated(uint64(l)) 3589 } 3590 return n 3591} 3592 3593func (m *Scale) Size() (n int) { 3594 var l int 3595 _ = l 3596 l = m.ObjectMeta.Size() 3597 n += 1 + l + sovGenerated(uint64(l)) 3598 l = m.Spec.Size() 3599 n += 1 + l + sovGenerated(uint64(l)) 3600 l = m.Status.Size() 3601 n += 1 + l + sovGenerated(uint64(l)) 3602 return n 3603} 3604 3605func (m *ScaleSpec) Size() (n int) { 3606 var l int 3607 _ = l 3608 n += 1 + sovGenerated(uint64(m.Replicas)) 3609 return n 3610} 3611 3612func (m *ScaleStatus) Size() (n int) { 3613 var l int 3614 _ = l 3615 n += 1 + sovGenerated(uint64(m.Replicas)) 3616 if len(m.Selector) > 0 { 3617 for k, v := range m.Selector { 3618 _ = k 3619 _ = v 3620 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 3621 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) 3622 } 3623 } 3624 l = len(m.TargetSelector) 3625 n += 1 + l + sovGenerated(uint64(l)) 3626 return n 3627} 3628 3629func (m *SupplementalGroupsStrategyOptions) Size() (n int) { 3630 var l int 3631 _ = l 3632 l = len(m.Rule) 3633 n += 1 + l + sovGenerated(uint64(l)) 3634 if len(m.Ranges) > 0 { 3635 for _, e := range m.Ranges { 3636 l = e.Size() 3637 n += 1 + l + sovGenerated(uint64(l)) 3638 } 3639 } 3640 return n 3641} 3642 3643func sovGenerated(x uint64) (n int) { 3644 for { 3645 n++ 3646 x >>= 7 3647 if x == 0 { 3648 break 3649 } 3650 } 3651 return n 3652} 3653func sozGenerated(x uint64) (n int) { 3654 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 3655} 3656func (this *AllowedCSIDriver) String() string { 3657 if this == nil { 3658 return "nil" 3659 } 3660 s := strings.Join([]string{`&AllowedCSIDriver{`, 3661 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 3662 `}`, 3663 }, "") 3664 return s 3665} 3666func (this *AllowedFlexVolume) String() string { 3667 if this == nil { 3668 return "nil" 3669 } 3670 s := strings.Join([]string{`&AllowedFlexVolume{`, 3671 `Driver:` + fmt.Sprintf("%v", this.Driver) + `,`, 3672 `}`, 3673 }, "") 3674 return s 3675} 3676func (this *AllowedHostPath) String() string { 3677 if this == nil { 3678 return "nil" 3679 } 3680 s := strings.Join([]string{`&AllowedHostPath{`, 3681 `PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`, 3682 `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`, 3683 `}`, 3684 }, "") 3685 return s 3686} 3687func (this *DaemonSet) String() string { 3688 if this == nil { 3689 return "nil" 3690 } 3691 s := strings.Join([]string{`&DaemonSet{`, 3692 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 3693 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`, 3694 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`, 3695 `}`, 3696 }, "") 3697 return s 3698} 3699func (this *DaemonSetCondition) String() string { 3700 if this == nil { 3701 return "nil" 3702 } 3703 s := strings.Join([]string{`&DaemonSetCondition{`, 3704 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3705 `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 3706 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 3707 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, 3708 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 3709 `}`, 3710 }, "") 3711 return s 3712} 3713func (this *DaemonSetList) String() string { 3714 if this == nil { 3715 return "nil" 3716 } 3717 s := strings.Join([]string{`&DaemonSetList{`, 3718 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 3719 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + `,`, 3720 `}`, 3721 }, "") 3722 return s 3723} 3724func (this *DaemonSetSpec) String() string { 3725 if this == nil { 3726 return "nil" 3727 } 3728 s := strings.Join([]string{`&DaemonSetSpec{`, 3729 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 3730 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`, 3731 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`, 3732 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, 3733 `TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`, 3734 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, 3735 `}`, 3736 }, "") 3737 return s 3738} 3739func (this *DaemonSetStatus) String() string { 3740 if this == nil { 3741 return "nil" 3742 } 3743 s := strings.Join([]string{`&DaemonSetStatus{`, 3744 `CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`, 3745 `NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`, 3746 `DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`, 3747 `NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`, 3748 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, 3749 `UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`, 3750 `NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`, 3751 `NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`, 3752 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, 3753 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + `,`, 3754 `}`, 3755 }, "") 3756 return s 3757} 3758func (this *DaemonSetUpdateStrategy) String() string { 3759 if this == nil { 3760 return "nil" 3761 } 3762 s := strings.Join([]string{`&DaemonSetUpdateStrategy{`, 3763 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3764 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`, 3765 `}`, 3766 }, "") 3767 return s 3768} 3769func (this *Deployment) String() string { 3770 if this == nil { 3771 return "nil" 3772 } 3773 s := strings.Join([]string{`&Deployment{`, 3774 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 3775 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`, 3776 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`, 3777 `}`, 3778 }, "") 3779 return s 3780} 3781func (this *DeploymentCondition) String() string { 3782 if this == nil { 3783 return "nil" 3784 } 3785 s := strings.Join([]string{`&DeploymentCondition{`, 3786 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3787 `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 3788 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, 3789 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 3790 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 3791 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 3792 `}`, 3793 }, "") 3794 return s 3795} 3796func (this *DeploymentList) String() string { 3797 if this == nil { 3798 return "nil" 3799 } 3800 s := strings.Join([]string{`&DeploymentList{`, 3801 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 3802 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`, 3803 `}`, 3804 }, "") 3805 return s 3806} 3807func (this *DeploymentRollback) String() string { 3808 if this == nil { 3809 return "nil" 3810 } 3811 keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations)) 3812 for k := range this.UpdatedAnnotations { 3813 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k) 3814 } 3815 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations) 3816 mapStringForUpdatedAnnotations := "map[string]string{" 3817 for _, k := range keysForUpdatedAnnotations { 3818 mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k]) 3819 } 3820 mapStringForUpdatedAnnotations += "}" 3821 s := strings.Join([]string{`&DeploymentRollback{`, 3822 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 3823 `UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`, 3824 `RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`, 3825 `}`, 3826 }, "") 3827 return s 3828} 3829func (this *DeploymentSpec) String() string { 3830 if this == nil { 3831 return "nil" 3832 } 3833 s := strings.Join([]string{`&DeploymentSpec{`, 3834 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, 3835 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 3836 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`, 3837 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`, 3838 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, 3839 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, 3840 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`, 3841 `RollbackTo:` + strings.Replace(fmt.Sprintf("%v", this.RollbackTo), "RollbackConfig", "RollbackConfig", 1) + `,`, 3842 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`, 3843 `}`, 3844 }, "") 3845 return s 3846} 3847func (this *DeploymentStatus) String() string { 3848 if this == nil { 3849 return "nil" 3850 } 3851 s := strings.Join([]string{`&DeploymentStatus{`, 3852 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, 3853 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 3854 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`, 3855 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, 3856 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`, 3857 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`, 3858 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, 3859 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, 3860 `}`, 3861 }, "") 3862 return s 3863} 3864func (this *DeploymentStrategy) String() string { 3865 if this == nil { 3866 return "nil" 3867 } 3868 s := strings.Join([]string{`&DeploymentStrategy{`, 3869 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3870 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`, 3871 `}`, 3872 }, "") 3873 return s 3874} 3875func (this *FSGroupStrategyOptions) String() string { 3876 if this == nil { 3877 return "nil" 3878 } 3879 s := strings.Join([]string{`&FSGroupStrategyOptions{`, 3880 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 3881 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 3882 `}`, 3883 }, "") 3884 return s 3885} 3886func (this *HTTPIngressPath) String() string { 3887 if this == nil { 3888 return "nil" 3889 } 3890 s := strings.Join([]string{`&HTTPIngressPath{`, 3891 `Path:` + fmt.Sprintf("%v", this.Path) + `,`, 3892 `Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`, 3893 `}`, 3894 }, "") 3895 return s 3896} 3897func (this *HTTPIngressRuleValue) String() string { 3898 if this == nil { 3899 return "nil" 3900 } 3901 s := strings.Join([]string{`&HTTPIngressRuleValue{`, 3902 `Paths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Paths), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + `,`, 3903 `}`, 3904 }, "") 3905 return s 3906} 3907func (this *HostPortRange) String() string { 3908 if this == nil { 3909 return "nil" 3910 } 3911 s := strings.Join([]string{`&HostPortRange{`, 3912 `Min:` + fmt.Sprintf("%v", this.Min) + `,`, 3913 `Max:` + fmt.Sprintf("%v", this.Max) + `,`, 3914 `}`, 3915 }, "") 3916 return s 3917} 3918func (this *IDRange) String() string { 3919 if this == nil { 3920 return "nil" 3921 } 3922 s := strings.Join([]string{`&IDRange{`, 3923 `Min:` + fmt.Sprintf("%v", this.Min) + `,`, 3924 `Max:` + fmt.Sprintf("%v", this.Max) + `,`, 3925 `}`, 3926 }, "") 3927 return s 3928} 3929func (this *IPBlock) String() string { 3930 if this == nil { 3931 return "nil" 3932 } 3933 s := strings.Join([]string{`&IPBlock{`, 3934 `CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`, 3935 `Except:` + fmt.Sprintf("%v", this.Except) + `,`, 3936 `}`, 3937 }, "") 3938 return s 3939} 3940func (this *Ingress) String() string { 3941 if this == nil { 3942 return "nil" 3943 } 3944 s := strings.Join([]string{`&Ingress{`, 3945 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 3946 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`, 3947 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`, 3948 `}`, 3949 }, "") 3950 return s 3951} 3952func (this *IngressBackend) String() string { 3953 if this == nil { 3954 return "nil" 3955 } 3956 s := strings.Join([]string{`&IngressBackend{`, 3957 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`, 3958 `ServicePort:` + strings.Replace(strings.Replace(this.ServicePort.String(), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1), `&`, ``, 1) + `,`, 3959 `}`, 3960 }, "") 3961 return s 3962} 3963func (this *IngressList) String() string { 3964 if this == nil { 3965 return "nil" 3966 } 3967 s := strings.Join([]string{`&IngressList{`, 3968 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 3969 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Ingress", "Ingress", 1), `&`, ``, 1) + `,`, 3970 `}`, 3971 }, "") 3972 return s 3973} 3974func (this *IngressRule) String() string { 3975 if this == nil { 3976 return "nil" 3977 } 3978 s := strings.Join([]string{`&IngressRule{`, 3979 `Host:` + fmt.Sprintf("%v", this.Host) + `,`, 3980 `IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`, 3981 `}`, 3982 }, "") 3983 return s 3984} 3985func (this *IngressRuleValue) String() string { 3986 if this == nil { 3987 return "nil" 3988 } 3989 s := strings.Join([]string{`&IngressRuleValue{`, 3990 `HTTP:` + strings.Replace(fmt.Sprintf("%v", this.HTTP), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`, 3991 `}`, 3992 }, "") 3993 return s 3994} 3995func (this *IngressSpec) String() string { 3996 if this == nil { 3997 return "nil" 3998 } 3999 s := strings.Join([]string{`&IngressSpec{`, 4000 `Backend:` + strings.Replace(fmt.Sprintf("%v", this.Backend), "IngressBackend", "IngressBackend", 1) + `,`, 4001 `TLS:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TLS), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + `,`, 4002 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "IngressRule", "IngressRule", 1), `&`, ``, 1) + `,`, 4003 `}`, 4004 }, "") 4005 return s 4006} 4007func (this *IngressStatus) String() string { 4008 if this == nil { 4009 return "nil" 4010 } 4011 s := strings.Join([]string{`&IngressStatus{`, 4012 `LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "LoadBalancerStatus", "k8s_io_api_core_v1.LoadBalancerStatus", 1), `&`, ``, 1) + `,`, 4013 `}`, 4014 }, "") 4015 return s 4016} 4017func (this *IngressTLS) String() string { 4018 if this == nil { 4019 return "nil" 4020 } 4021 s := strings.Join([]string{`&IngressTLS{`, 4022 `Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`, 4023 `SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`, 4024 `}`, 4025 }, "") 4026 return s 4027} 4028func (this *NetworkPolicy) String() string { 4029 if this == nil { 4030 return "nil" 4031 } 4032 s := strings.Join([]string{`&NetworkPolicy{`, 4033 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4034 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`, 4035 `}`, 4036 }, "") 4037 return s 4038} 4039func (this *NetworkPolicyEgressRule) String() string { 4040 if this == nil { 4041 return "nil" 4042 } 4043 s := strings.Join([]string{`&NetworkPolicyEgressRule{`, 4044 `Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`, 4045 `To:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.To), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`, 4046 `}`, 4047 }, "") 4048 return s 4049} 4050func (this *NetworkPolicyIngressRule) String() string { 4051 if this == nil { 4052 return "nil" 4053 } 4054 s := strings.Join([]string{`&NetworkPolicyIngressRule{`, 4055 `Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`, 4056 `From:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.From), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`, 4057 `}`, 4058 }, "") 4059 return s 4060} 4061func (this *NetworkPolicyList) String() string { 4062 if this == nil { 4063 return "nil" 4064 } 4065 s := strings.Join([]string{`&NetworkPolicyList{`, 4066 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4067 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + `,`, 4068 `}`, 4069 }, "") 4070 return s 4071} 4072func (this *NetworkPolicyPeer) String() string { 4073 if this == nil { 4074 return "nil" 4075 } 4076 s := strings.Join([]string{`&NetworkPolicyPeer{`, 4077 `PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 4078 `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 4079 `IPBlock:` + strings.Replace(fmt.Sprintf("%v", this.IPBlock), "IPBlock", "IPBlock", 1) + `,`, 4080 `}`, 4081 }, "") 4082 return s 4083} 4084func (this *NetworkPolicyPort) String() string { 4085 if this == nil { 4086 return "nil" 4087 } 4088 s := strings.Join([]string{`&NetworkPolicyPort{`, 4089 `Protocol:` + valueToStringGenerated(this.Protocol) + `,`, 4090 `Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4091 `}`, 4092 }, "") 4093 return s 4094} 4095func (this *NetworkPolicySpec) String() string { 4096 if this == nil { 4097 return "nil" 4098 } 4099 s := strings.Join([]string{`&NetworkPolicySpec{`, 4100 `PodSelector:` + strings.Replace(strings.Replace(this.PodSelector.String(), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`, 4101 `Ingress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ingress), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + `,`, 4102 `Egress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Egress), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + `,`, 4103 `PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`, 4104 `}`, 4105 }, "") 4106 return s 4107} 4108func (this *PodSecurityPolicy) String() string { 4109 if this == nil { 4110 return "nil" 4111 } 4112 s := strings.Join([]string{`&PodSecurityPolicy{`, 4113 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4114 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`, 4115 `}`, 4116 }, "") 4117 return s 4118} 4119func (this *PodSecurityPolicyList) String() string { 4120 if this == nil { 4121 return "nil" 4122 } 4123 s := strings.Join([]string{`&PodSecurityPolicyList{`, 4124 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4125 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + `,`, 4126 `}`, 4127 }, "") 4128 return s 4129} 4130func (this *PodSecurityPolicySpec) String() string { 4131 if this == nil { 4132 return "nil" 4133 } 4134 s := strings.Join([]string{`&PodSecurityPolicySpec{`, 4135 `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`, 4136 `DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`, 4137 `RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`, 4138 `AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`, 4139 `Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`, 4140 `HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`, 4141 `HostPorts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.HostPorts), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + `,`, 4142 `HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`, 4143 `HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`, 4144 `SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`, 4145 `RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`, 4146 `SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`, 4147 `FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`, 4148 `ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`, 4149 `DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`, 4150 `AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`, 4151 `AllowedHostPaths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedHostPaths), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + `,`, 4152 `AllowedFlexVolumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedFlexVolumes), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + `,`, 4153 `AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`, 4154 `ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`, 4155 `AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`, 4156 `RunAsGroup:` + strings.Replace(fmt.Sprintf("%v", this.RunAsGroup), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`, 4157 `AllowedCSIDrivers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedCSIDrivers), "AllowedCSIDriver", "AllowedCSIDriver", 1), `&`, ``, 1) + `,`, 4158 `}`, 4159 }, "") 4160 return s 4161} 4162func (this *ReplicaSet) String() string { 4163 if this == nil { 4164 return "nil" 4165 } 4166 s := strings.Join([]string{`&ReplicaSet{`, 4167 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4168 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`, 4169 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`, 4170 `}`, 4171 }, "") 4172 return s 4173} 4174func (this *ReplicaSetCondition) String() string { 4175 if this == nil { 4176 return "nil" 4177 } 4178 s := strings.Join([]string{`&ReplicaSetCondition{`, 4179 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 4180 `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 4181 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 4182 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, 4183 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 4184 `}`, 4185 }, "") 4186 return s 4187} 4188func (this *ReplicaSetList) String() string { 4189 if this == nil { 4190 return "nil" 4191 } 4192 s := strings.Join([]string{`&ReplicaSetList{`, 4193 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4194 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + `,`, 4195 `}`, 4196 }, "") 4197 return s 4198} 4199func (this *ReplicaSetSpec) String() string { 4200 if this == nil { 4201 return "nil" 4202 } 4203 s := strings.Join([]string{`&ReplicaSetSpec{`, 4204 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, 4205 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 4206 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`, 4207 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, 4208 `}`, 4209 }, "") 4210 return s 4211} 4212func (this *ReplicaSetStatus) String() string { 4213 if this == nil { 4214 return "nil" 4215 } 4216 s := strings.Join([]string{`&ReplicaSetStatus{`, 4217 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 4218 `FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`, 4219 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, 4220 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, 4221 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, 4222 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + `,`, 4223 `}`, 4224 }, "") 4225 return s 4226} 4227func (this *ReplicationControllerDummy) String() string { 4228 if this == nil { 4229 return "nil" 4230 } 4231 s := strings.Join([]string{`&ReplicationControllerDummy{`, 4232 `}`, 4233 }, "") 4234 return s 4235} 4236func (this *RollbackConfig) String() string { 4237 if this == nil { 4238 return "nil" 4239 } 4240 s := strings.Join([]string{`&RollbackConfig{`, 4241 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, 4242 `}`, 4243 }, "") 4244 return s 4245} 4246func (this *RollingUpdateDaemonSet) String() string { 4247 if this == nil { 4248 return "nil" 4249 } 4250 s := strings.Join([]string{`&RollingUpdateDaemonSet{`, 4251 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4252 `}`, 4253 }, "") 4254 return s 4255} 4256func (this *RollingUpdateDeployment) String() string { 4257 if this == nil { 4258 return "nil" 4259 } 4260 s := strings.Join([]string{`&RollingUpdateDeployment{`, 4261 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4262 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4263 `}`, 4264 }, "") 4265 return s 4266} 4267func (this *RunAsGroupStrategyOptions) String() string { 4268 if this == nil { 4269 return "nil" 4270 } 4271 s := strings.Join([]string{`&RunAsGroupStrategyOptions{`, 4272 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4273 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 4274 `}`, 4275 }, "") 4276 return s 4277} 4278func (this *RunAsUserStrategyOptions) String() string { 4279 if this == nil { 4280 return "nil" 4281 } 4282 s := strings.Join([]string{`&RunAsUserStrategyOptions{`, 4283 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4284 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 4285 `}`, 4286 }, "") 4287 return s 4288} 4289func (this *SELinuxStrategyOptions) String() string { 4290 if this == nil { 4291 return "nil" 4292 } 4293 s := strings.Join([]string{`&SELinuxStrategyOptions{`, 4294 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4295 `SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "k8s_io_api_core_v1.SELinuxOptions", 1) + `,`, 4296 `}`, 4297 }, "") 4298 return s 4299} 4300func (this *Scale) String() string { 4301 if this == nil { 4302 return "nil" 4303 } 4304 s := strings.Join([]string{`&Scale{`, 4305 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4306 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`, 4307 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`, 4308 `}`, 4309 }, "") 4310 return s 4311} 4312func (this *ScaleSpec) String() string { 4313 if this == nil { 4314 return "nil" 4315 } 4316 s := strings.Join([]string{`&ScaleSpec{`, 4317 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 4318 `}`, 4319 }, "") 4320 return s 4321} 4322func (this *ScaleStatus) String() string { 4323 if this == nil { 4324 return "nil" 4325 } 4326 keysForSelector := make([]string, 0, len(this.Selector)) 4327 for k := range this.Selector { 4328 keysForSelector = append(keysForSelector, k) 4329 } 4330 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector) 4331 mapStringForSelector := "map[string]string{" 4332 for _, k := range keysForSelector { 4333 mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k]) 4334 } 4335 mapStringForSelector += "}" 4336 s := strings.Join([]string{`&ScaleStatus{`, 4337 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 4338 `Selector:` + mapStringForSelector + `,`, 4339 `TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`, 4340 `}`, 4341 }, "") 4342 return s 4343} 4344func (this *SupplementalGroupsStrategyOptions) String() string { 4345 if this == nil { 4346 return "nil" 4347 } 4348 s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`, 4349 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4350 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 4351 `}`, 4352 }, "") 4353 return s 4354} 4355func valueToStringGenerated(v interface{}) string { 4356 rv := reflect.ValueOf(v) 4357 if rv.IsNil() { 4358 return "nil" 4359 } 4360 pv := reflect.Indirect(rv).Interface() 4361 return fmt.Sprintf("*%v", pv) 4362} 4363func (m *AllowedCSIDriver) Unmarshal(dAtA []byte) error { 4364 l := len(dAtA) 4365 iNdEx := 0 4366 for iNdEx < l { 4367 preIndex := iNdEx 4368 var wire uint64 4369 for shift := uint(0); ; shift += 7 { 4370 if shift >= 64 { 4371 return ErrIntOverflowGenerated 4372 } 4373 if iNdEx >= l { 4374 return io.ErrUnexpectedEOF 4375 } 4376 b := dAtA[iNdEx] 4377 iNdEx++ 4378 wire |= (uint64(b) & 0x7F) << shift 4379 if b < 0x80 { 4380 break 4381 } 4382 } 4383 fieldNum := int32(wire >> 3) 4384 wireType := int(wire & 0x7) 4385 if wireType == 4 { 4386 return fmt.Errorf("proto: AllowedCSIDriver: wiretype end group for non-group") 4387 } 4388 if fieldNum <= 0 { 4389 return fmt.Errorf("proto: AllowedCSIDriver: illegal tag %d (wire type %d)", fieldNum, wire) 4390 } 4391 switch fieldNum { 4392 case 1: 4393 if wireType != 2 { 4394 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 4395 } 4396 var stringLen uint64 4397 for shift := uint(0); ; shift += 7 { 4398 if shift >= 64 { 4399 return ErrIntOverflowGenerated 4400 } 4401 if iNdEx >= l { 4402 return io.ErrUnexpectedEOF 4403 } 4404 b := dAtA[iNdEx] 4405 iNdEx++ 4406 stringLen |= (uint64(b) & 0x7F) << shift 4407 if b < 0x80 { 4408 break 4409 } 4410 } 4411 intStringLen := int(stringLen) 4412 if intStringLen < 0 { 4413 return ErrInvalidLengthGenerated 4414 } 4415 postIndex := iNdEx + intStringLen 4416 if postIndex > l { 4417 return io.ErrUnexpectedEOF 4418 } 4419 m.Name = string(dAtA[iNdEx:postIndex]) 4420 iNdEx = postIndex 4421 default: 4422 iNdEx = preIndex 4423 skippy, err := skipGenerated(dAtA[iNdEx:]) 4424 if err != nil { 4425 return err 4426 } 4427 if skippy < 0 { 4428 return ErrInvalidLengthGenerated 4429 } 4430 if (iNdEx + skippy) > l { 4431 return io.ErrUnexpectedEOF 4432 } 4433 iNdEx += skippy 4434 } 4435 } 4436 4437 if iNdEx > l { 4438 return io.ErrUnexpectedEOF 4439 } 4440 return nil 4441} 4442func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error { 4443 l := len(dAtA) 4444 iNdEx := 0 4445 for iNdEx < l { 4446 preIndex := iNdEx 4447 var wire uint64 4448 for shift := uint(0); ; shift += 7 { 4449 if shift >= 64 { 4450 return ErrIntOverflowGenerated 4451 } 4452 if iNdEx >= l { 4453 return io.ErrUnexpectedEOF 4454 } 4455 b := dAtA[iNdEx] 4456 iNdEx++ 4457 wire |= (uint64(b) & 0x7F) << shift 4458 if b < 0x80 { 4459 break 4460 } 4461 } 4462 fieldNum := int32(wire >> 3) 4463 wireType := int(wire & 0x7) 4464 if wireType == 4 { 4465 return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group") 4466 } 4467 if fieldNum <= 0 { 4468 return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire) 4469 } 4470 switch fieldNum { 4471 case 1: 4472 if wireType != 2 { 4473 return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType) 4474 } 4475 var stringLen 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 stringLen |= (uint64(b) & 0x7F) << shift 4486 if b < 0x80 { 4487 break 4488 } 4489 } 4490 intStringLen := int(stringLen) 4491 if intStringLen < 0 { 4492 return ErrInvalidLengthGenerated 4493 } 4494 postIndex := iNdEx + intStringLen 4495 if postIndex > l { 4496 return io.ErrUnexpectedEOF 4497 } 4498 m.Driver = string(dAtA[iNdEx:postIndex]) 4499 iNdEx = postIndex 4500 default: 4501 iNdEx = preIndex 4502 skippy, err := skipGenerated(dAtA[iNdEx:]) 4503 if err != nil { 4504 return err 4505 } 4506 if skippy < 0 { 4507 return ErrInvalidLengthGenerated 4508 } 4509 if (iNdEx + skippy) > l { 4510 return io.ErrUnexpectedEOF 4511 } 4512 iNdEx += skippy 4513 } 4514 } 4515 4516 if iNdEx > l { 4517 return io.ErrUnexpectedEOF 4518 } 4519 return nil 4520} 4521func (m *AllowedHostPath) Unmarshal(dAtA []byte) error { 4522 l := len(dAtA) 4523 iNdEx := 0 4524 for iNdEx < l { 4525 preIndex := iNdEx 4526 var wire uint64 4527 for shift := uint(0); ; shift += 7 { 4528 if shift >= 64 { 4529 return ErrIntOverflowGenerated 4530 } 4531 if iNdEx >= l { 4532 return io.ErrUnexpectedEOF 4533 } 4534 b := dAtA[iNdEx] 4535 iNdEx++ 4536 wire |= (uint64(b) & 0x7F) << shift 4537 if b < 0x80 { 4538 break 4539 } 4540 } 4541 fieldNum := int32(wire >> 3) 4542 wireType := int(wire & 0x7) 4543 if wireType == 4 { 4544 return fmt.Errorf("proto: AllowedHostPath: wiretype end group for non-group") 4545 } 4546 if fieldNum <= 0 { 4547 return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire) 4548 } 4549 switch fieldNum { 4550 case 1: 4551 if wireType != 2 { 4552 return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType) 4553 } 4554 var stringLen 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 stringLen |= (uint64(b) & 0x7F) << shift 4565 if b < 0x80 { 4566 break 4567 } 4568 } 4569 intStringLen := int(stringLen) 4570 if intStringLen < 0 { 4571 return ErrInvalidLengthGenerated 4572 } 4573 postIndex := iNdEx + intStringLen 4574 if postIndex > l { 4575 return io.ErrUnexpectedEOF 4576 } 4577 m.PathPrefix = string(dAtA[iNdEx:postIndex]) 4578 iNdEx = postIndex 4579 case 2: 4580 if wireType != 0 { 4581 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType) 4582 } 4583 var v int 4584 for shift := uint(0); ; shift += 7 { 4585 if shift >= 64 { 4586 return ErrIntOverflowGenerated 4587 } 4588 if iNdEx >= l { 4589 return io.ErrUnexpectedEOF 4590 } 4591 b := dAtA[iNdEx] 4592 iNdEx++ 4593 v |= (int(b) & 0x7F) << shift 4594 if b < 0x80 { 4595 break 4596 } 4597 } 4598 m.ReadOnly = bool(v != 0) 4599 default: 4600 iNdEx = preIndex 4601 skippy, err := skipGenerated(dAtA[iNdEx:]) 4602 if err != nil { 4603 return err 4604 } 4605 if skippy < 0 { 4606 return ErrInvalidLengthGenerated 4607 } 4608 if (iNdEx + skippy) > l { 4609 return io.ErrUnexpectedEOF 4610 } 4611 iNdEx += skippy 4612 } 4613 } 4614 4615 if iNdEx > l { 4616 return io.ErrUnexpectedEOF 4617 } 4618 return nil 4619} 4620func (m *DaemonSet) Unmarshal(dAtA []byte) error { 4621 l := len(dAtA) 4622 iNdEx := 0 4623 for iNdEx < l { 4624 preIndex := iNdEx 4625 var wire uint64 4626 for shift := uint(0); ; shift += 7 { 4627 if shift >= 64 { 4628 return ErrIntOverflowGenerated 4629 } 4630 if iNdEx >= l { 4631 return io.ErrUnexpectedEOF 4632 } 4633 b := dAtA[iNdEx] 4634 iNdEx++ 4635 wire |= (uint64(b) & 0x7F) << shift 4636 if b < 0x80 { 4637 break 4638 } 4639 } 4640 fieldNum := int32(wire >> 3) 4641 wireType := int(wire & 0x7) 4642 if wireType == 4 { 4643 return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group") 4644 } 4645 if fieldNum <= 0 { 4646 return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire) 4647 } 4648 switch fieldNum { 4649 case 1: 4650 if wireType != 2 { 4651 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 4652 } 4653 var msglen int 4654 for shift := uint(0); ; shift += 7 { 4655 if shift >= 64 { 4656 return ErrIntOverflowGenerated 4657 } 4658 if iNdEx >= l { 4659 return io.ErrUnexpectedEOF 4660 } 4661 b := dAtA[iNdEx] 4662 iNdEx++ 4663 msglen |= (int(b) & 0x7F) << shift 4664 if b < 0x80 { 4665 break 4666 } 4667 } 4668 if msglen < 0 { 4669 return ErrInvalidLengthGenerated 4670 } 4671 postIndex := iNdEx + msglen 4672 if postIndex > l { 4673 return io.ErrUnexpectedEOF 4674 } 4675 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4676 return err 4677 } 4678 iNdEx = postIndex 4679 case 2: 4680 if wireType != 2 { 4681 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 4682 } 4683 var msglen int 4684 for shift := uint(0); ; shift += 7 { 4685 if shift >= 64 { 4686 return ErrIntOverflowGenerated 4687 } 4688 if iNdEx >= l { 4689 return io.ErrUnexpectedEOF 4690 } 4691 b := dAtA[iNdEx] 4692 iNdEx++ 4693 msglen |= (int(b) & 0x7F) << shift 4694 if b < 0x80 { 4695 break 4696 } 4697 } 4698 if msglen < 0 { 4699 return ErrInvalidLengthGenerated 4700 } 4701 postIndex := iNdEx + msglen 4702 if postIndex > l { 4703 return io.ErrUnexpectedEOF 4704 } 4705 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4706 return err 4707 } 4708 iNdEx = postIndex 4709 case 3: 4710 if wireType != 2 { 4711 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 4712 } 4713 var msglen int 4714 for shift := uint(0); ; shift += 7 { 4715 if shift >= 64 { 4716 return ErrIntOverflowGenerated 4717 } 4718 if iNdEx >= l { 4719 return io.ErrUnexpectedEOF 4720 } 4721 b := dAtA[iNdEx] 4722 iNdEx++ 4723 msglen |= (int(b) & 0x7F) << shift 4724 if b < 0x80 { 4725 break 4726 } 4727 } 4728 if msglen < 0 { 4729 return ErrInvalidLengthGenerated 4730 } 4731 postIndex := iNdEx + msglen 4732 if postIndex > l { 4733 return io.ErrUnexpectedEOF 4734 } 4735 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4736 return err 4737 } 4738 iNdEx = postIndex 4739 default: 4740 iNdEx = preIndex 4741 skippy, err := skipGenerated(dAtA[iNdEx:]) 4742 if err != nil { 4743 return err 4744 } 4745 if skippy < 0 { 4746 return ErrInvalidLengthGenerated 4747 } 4748 if (iNdEx + skippy) > l { 4749 return io.ErrUnexpectedEOF 4750 } 4751 iNdEx += skippy 4752 } 4753 } 4754 4755 if iNdEx > l { 4756 return io.ErrUnexpectedEOF 4757 } 4758 return nil 4759} 4760func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error { 4761 l := len(dAtA) 4762 iNdEx := 0 4763 for iNdEx < l { 4764 preIndex := iNdEx 4765 var wire uint64 4766 for shift := uint(0); ; shift += 7 { 4767 if shift >= 64 { 4768 return ErrIntOverflowGenerated 4769 } 4770 if iNdEx >= l { 4771 return io.ErrUnexpectedEOF 4772 } 4773 b := dAtA[iNdEx] 4774 iNdEx++ 4775 wire |= (uint64(b) & 0x7F) << shift 4776 if b < 0x80 { 4777 break 4778 } 4779 } 4780 fieldNum := int32(wire >> 3) 4781 wireType := int(wire & 0x7) 4782 if wireType == 4 { 4783 return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group") 4784 } 4785 if fieldNum <= 0 { 4786 return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) 4787 } 4788 switch fieldNum { 4789 case 1: 4790 if wireType != 2 { 4791 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 4792 } 4793 var stringLen uint64 4794 for shift := uint(0); ; shift += 7 { 4795 if shift >= 64 { 4796 return ErrIntOverflowGenerated 4797 } 4798 if iNdEx >= l { 4799 return io.ErrUnexpectedEOF 4800 } 4801 b := dAtA[iNdEx] 4802 iNdEx++ 4803 stringLen |= (uint64(b) & 0x7F) << shift 4804 if b < 0x80 { 4805 break 4806 } 4807 } 4808 intStringLen := int(stringLen) 4809 if intStringLen < 0 { 4810 return ErrInvalidLengthGenerated 4811 } 4812 postIndex := iNdEx + intStringLen 4813 if postIndex > l { 4814 return io.ErrUnexpectedEOF 4815 } 4816 m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex]) 4817 iNdEx = postIndex 4818 case 2: 4819 if wireType != 2 { 4820 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 4821 } 4822 var stringLen uint64 4823 for shift := uint(0); ; shift += 7 { 4824 if shift >= 64 { 4825 return ErrIntOverflowGenerated 4826 } 4827 if iNdEx >= l { 4828 return io.ErrUnexpectedEOF 4829 } 4830 b := dAtA[iNdEx] 4831 iNdEx++ 4832 stringLen |= (uint64(b) & 0x7F) << shift 4833 if b < 0x80 { 4834 break 4835 } 4836 } 4837 intStringLen := int(stringLen) 4838 if intStringLen < 0 { 4839 return ErrInvalidLengthGenerated 4840 } 4841 postIndex := iNdEx + intStringLen 4842 if postIndex > l { 4843 return io.ErrUnexpectedEOF 4844 } 4845 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) 4846 iNdEx = postIndex 4847 case 3: 4848 if wireType != 2 { 4849 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) 4850 } 4851 var msglen int 4852 for shift := uint(0); ; shift += 7 { 4853 if shift >= 64 { 4854 return ErrIntOverflowGenerated 4855 } 4856 if iNdEx >= l { 4857 return io.ErrUnexpectedEOF 4858 } 4859 b := dAtA[iNdEx] 4860 iNdEx++ 4861 msglen |= (int(b) & 0x7F) << shift 4862 if b < 0x80 { 4863 break 4864 } 4865 } 4866 if msglen < 0 { 4867 return ErrInvalidLengthGenerated 4868 } 4869 postIndex := iNdEx + msglen 4870 if postIndex > l { 4871 return io.ErrUnexpectedEOF 4872 } 4873 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4874 return err 4875 } 4876 iNdEx = postIndex 4877 case 4: 4878 if wireType != 2 { 4879 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) 4880 } 4881 var stringLen uint64 4882 for shift := uint(0); ; shift += 7 { 4883 if shift >= 64 { 4884 return ErrIntOverflowGenerated 4885 } 4886 if iNdEx >= l { 4887 return io.ErrUnexpectedEOF 4888 } 4889 b := dAtA[iNdEx] 4890 iNdEx++ 4891 stringLen |= (uint64(b) & 0x7F) << shift 4892 if b < 0x80 { 4893 break 4894 } 4895 } 4896 intStringLen := int(stringLen) 4897 if intStringLen < 0 { 4898 return ErrInvalidLengthGenerated 4899 } 4900 postIndex := iNdEx + intStringLen 4901 if postIndex > l { 4902 return io.ErrUnexpectedEOF 4903 } 4904 m.Reason = string(dAtA[iNdEx:postIndex]) 4905 iNdEx = postIndex 4906 case 5: 4907 if wireType != 2 { 4908 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 4909 } 4910 var stringLen uint64 4911 for shift := uint(0); ; shift += 7 { 4912 if shift >= 64 { 4913 return ErrIntOverflowGenerated 4914 } 4915 if iNdEx >= l { 4916 return io.ErrUnexpectedEOF 4917 } 4918 b := dAtA[iNdEx] 4919 iNdEx++ 4920 stringLen |= (uint64(b) & 0x7F) << shift 4921 if b < 0x80 { 4922 break 4923 } 4924 } 4925 intStringLen := int(stringLen) 4926 if intStringLen < 0 { 4927 return ErrInvalidLengthGenerated 4928 } 4929 postIndex := iNdEx + intStringLen 4930 if postIndex > l { 4931 return io.ErrUnexpectedEOF 4932 } 4933 m.Message = string(dAtA[iNdEx:postIndex]) 4934 iNdEx = postIndex 4935 default: 4936 iNdEx = preIndex 4937 skippy, err := skipGenerated(dAtA[iNdEx:]) 4938 if err != nil { 4939 return err 4940 } 4941 if skippy < 0 { 4942 return ErrInvalidLengthGenerated 4943 } 4944 if (iNdEx + skippy) > l { 4945 return io.ErrUnexpectedEOF 4946 } 4947 iNdEx += skippy 4948 } 4949 } 4950 4951 if iNdEx > l { 4952 return io.ErrUnexpectedEOF 4953 } 4954 return nil 4955} 4956func (m *DaemonSetList) Unmarshal(dAtA []byte) error { 4957 l := len(dAtA) 4958 iNdEx := 0 4959 for iNdEx < l { 4960 preIndex := iNdEx 4961 var wire uint64 4962 for shift := uint(0); ; shift += 7 { 4963 if shift >= 64 { 4964 return ErrIntOverflowGenerated 4965 } 4966 if iNdEx >= l { 4967 return io.ErrUnexpectedEOF 4968 } 4969 b := dAtA[iNdEx] 4970 iNdEx++ 4971 wire |= (uint64(b) & 0x7F) << shift 4972 if b < 0x80 { 4973 break 4974 } 4975 } 4976 fieldNum := int32(wire >> 3) 4977 wireType := int(wire & 0x7) 4978 if wireType == 4 { 4979 return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group") 4980 } 4981 if fieldNum <= 0 { 4982 return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire) 4983 } 4984 switch fieldNum { 4985 case 1: 4986 if wireType != 2 { 4987 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 4988 } 4989 var msglen int 4990 for shift := uint(0); ; shift += 7 { 4991 if shift >= 64 { 4992 return ErrIntOverflowGenerated 4993 } 4994 if iNdEx >= l { 4995 return io.ErrUnexpectedEOF 4996 } 4997 b := dAtA[iNdEx] 4998 iNdEx++ 4999 msglen |= (int(b) & 0x7F) << shift 5000 if b < 0x80 { 5001 break 5002 } 5003 } 5004 if msglen < 0 { 5005 return ErrInvalidLengthGenerated 5006 } 5007 postIndex := iNdEx + msglen 5008 if postIndex > l { 5009 return io.ErrUnexpectedEOF 5010 } 5011 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5012 return err 5013 } 5014 iNdEx = postIndex 5015 case 2: 5016 if wireType != 2 { 5017 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 5018 } 5019 var msglen int 5020 for shift := uint(0); ; shift += 7 { 5021 if shift >= 64 { 5022 return ErrIntOverflowGenerated 5023 } 5024 if iNdEx >= l { 5025 return io.ErrUnexpectedEOF 5026 } 5027 b := dAtA[iNdEx] 5028 iNdEx++ 5029 msglen |= (int(b) & 0x7F) << shift 5030 if b < 0x80 { 5031 break 5032 } 5033 } 5034 if msglen < 0 { 5035 return ErrInvalidLengthGenerated 5036 } 5037 postIndex := iNdEx + msglen 5038 if postIndex > l { 5039 return io.ErrUnexpectedEOF 5040 } 5041 m.Items = append(m.Items, DaemonSet{}) 5042 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5043 return err 5044 } 5045 iNdEx = postIndex 5046 default: 5047 iNdEx = preIndex 5048 skippy, err := skipGenerated(dAtA[iNdEx:]) 5049 if err != nil { 5050 return err 5051 } 5052 if skippy < 0 { 5053 return ErrInvalidLengthGenerated 5054 } 5055 if (iNdEx + skippy) > l { 5056 return io.ErrUnexpectedEOF 5057 } 5058 iNdEx += skippy 5059 } 5060 } 5061 5062 if iNdEx > l { 5063 return io.ErrUnexpectedEOF 5064 } 5065 return nil 5066} 5067func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error { 5068 l := len(dAtA) 5069 iNdEx := 0 5070 for iNdEx < l { 5071 preIndex := iNdEx 5072 var wire 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 wire |= (uint64(b) & 0x7F) << shift 5083 if b < 0x80 { 5084 break 5085 } 5086 } 5087 fieldNum := int32(wire >> 3) 5088 wireType := int(wire & 0x7) 5089 if wireType == 4 { 5090 return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group") 5091 } 5092 if fieldNum <= 0 { 5093 return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) 5094 } 5095 switch fieldNum { 5096 case 1: 5097 if wireType != 2 { 5098 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 5099 } 5100 var msglen int 5101 for shift := uint(0); ; shift += 7 { 5102 if shift >= 64 { 5103 return ErrIntOverflowGenerated 5104 } 5105 if iNdEx >= l { 5106 return io.ErrUnexpectedEOF 5107 } 5108 b := dAtA[iNdEx] 5109 iNdEx++ 5110 msglen |= (int(b) & 0x7F) << shift 5111 if b < 0x80 { 5112 break 5113 } 5114 } 5115 if msglen < 0 { 5116 return ErrInvalidLengthGenerated 5117 } 5118 postIndex := iNdEx + msglen 5119 if postIndex > l { 5120 return io.ErrUnexpectedEOF 5121 } 5122 if m.Selector == nil { 5123 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 5124 } 5125 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5126 return err 5127 } 5128 iNdEx = postIndex 5129 case 2: 5130 if wireType != 2 { 5131 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) 5132 } 5133 var msglen int 5134 for shift := uint(0); ; shift += 7 { 5135 if shift >= 64 { 5136 return ErrIntOverflowGenerated 5137 } 5138 if iNdEx >= l { 5139 return io.ErrUnexpectedEOF 5140 } 5141 b := dAtA[iNdEx] 5142 iNdEx++ 5143 msglen |= (int(b) & 0x7F) << shift 5144 if b < 0x80 { 5145 break 5146 } 5147 } 5148 if msglen < 0 { 5149 return ErrInvalidLengthGenerated 5150 } 5151 postIndex := iNdEx + msglen 5152 if postIndex > l { 5153 return io.ErrUnexpectedEOF 5154 } 5155 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5156 return err 5157 } 5158 iNdEx = postIndex 5159 case 3: 5160 if wireType != 2 { 5161 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType) 5162 } 5163 var msglen int 5164 for shift := uint(0); ; shift += 7 { 5165 if shift >= 64 { 5166 return ErrIntOverflowGenerated 5167 } 5168 if iNdEx >= l { 5169 return io.ErrUnexpectedEOF 5170 } 5171 b := dAtA[iNdEx] 5172 iNdEx++ 5173 msglen |= (int(b) & 0x7F) << shift 5174 if b < 0x80 { 5175 break 5176 } 5177 } 5178 if msglen < 0 { 5179 return ErrInvalidLengthGenerated 5180 } 5181 postIndex := iNdEx + msglen 5182 if postIndex > l { 5183 return io.ErrUnexpectedEOF 5184 } 5185 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5186 return err 5187 } 5188 iNdEx = postIndex 5189 case 4: 5190 if wireType != 0 { 5191 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) 5192 } 5193 m.MinReadySeconds = 0 5194 for shift := uint(0); ; shift += 7 { 5195 if shift >= 64 { 5196 return ErrIntOverflowGenerated 5197 } 5198 if iNdEx >= l { 5199 return io.ErrUnexpectedEOF 5200 } 5201 b := dAtA[iNdEx] 5202 iNdEx++ 5203 m.MinReadySeconds |= (int32(b) & 0x7F) << shift 5204 if b < 0x80 { 5205 break 5206 } 5207 } 5208 case 5: 5209 if wireType != 0 { 5210 return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType) 5211 } 5212 m.TemplateGeneration = 0 5213 for shift := uint(0); ; shift += 7 { 5214 if shift >= 64 { 5215 return ErrIntOverflowGenerated 5216 } 5217 if iNdEx >= l { 5218 return io.ErrUnexpectedEOF 5219 } 5220 b := dAtA[iNdEx] 5221 iNdEx++ 5222 m.TemplateGeneration |= (int64(b) & 0x7F) << shift 5223 if b < 0x80 { 5224 break 5225 } 5226 } 5227 case 6: 5228 if wireType != 0 { 5229 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType) 5230 } 5231 var v int32 5232 for shift := uint(0); ; shift += 7 { 5233 if shift >= 64 { 5234 return ErrIntOverflowGenerated 5235 } 5236 if iNdEx >= l { 5237 return io.ErrUnexpectedEOF 5238 } 5239 b := dAtA[iNdEx] 5240 iNdEx++ 5241 v |= (int32(b) & 0x7F) << shift 5242 if b < 0x80 { 5243 break 5244 } 5245 } 5246 m.RevisionHistoryLimit = &v 5247 default: 5248 iNdEx = preIndex 5249 skippy, err := skipGenerated(dAtA[iNdEx:]) 5250 if err != nil { 5251 return err 5252 } 5253 if skippy < 0 { 5254 return ErrInvalidLengthGenerated 5255 } 5256 if (iNdEx + skippy) > l { 5257 return io.ErrUnexpectedEOF 5258 } 5259 iNdEx += skippy 5260 } 5261 } 5262 5263 if iNdEx > l { 5264 return io.ErrUnexpectedEOF 5265 } 5266 return nil 5267} 5268func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error { 5269 l := len(dAtA) 5270 iNdEx := 0 5271 for iNdEx < l { 5272 preIndex := iNdEx 5273 var wire uint64 5274 for shift := uint(0); ; shift += 7 { 5275 if shift >= 64 { 5276 return ErrIntOverflowGenerated 5277 } 5278 if iNdEx >= l { 5279 return io.ErrUnexpectedEOF 5280 } 5281 b := dAtA[iNdEx] 5282 iNdEx++ 5283 wire |= (uint64(b) & 0x7F) << shift 5284 if b < 0x80 { 5285 break 5286 } 5287 } 5288 fieldNum := int32(wire >> 3) 5289 wireType := int(wire & 0x7) 5290 if wireType == 4 { 5291 return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group") 5292 } 5293 if fieldNum <= 0 { 5294 return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) 5295 } 5296 switch fieldNum { 5297 case 1: 5298 if wireType != 0 { 5299 return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType) 5300 } 5301 m.CurrentNumberScheduled = 0 5302 for shift := uint(0); ; shift += 7 { 5303 if shift >= 64 { 5304 return ErrIntOverflowGenerated 5305 } 5306 if iNdEx >= l { 5307 return io.ErrUnexpectedEOF 5308 } 5309 b := dAtA[iNdEx] 5310 iNdEx++ 5311 m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift 5312 if b < 0x80 { 5313 break 5314 } 5315 } 5316 case 2: 5317 if wireType != 0 { 5318 return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType) 5319 } 5320 m.NumberMisscheduled = 0 5321 for shift := uint(0); ; shift += 7 { 5322 if shift >= 64 { 5323 return ErrIntOverflowGenerated 5324 } 5325 if iNdEx >= l { 5326 return io.ErrUnexpectedEOF 5327 } 5328 b := dAtA[iNdEx] 5329 iNdEx++ 5330 m.NumberMisscheduled |= (int32(b) & 0x7F) << shift 5331 if b < 0x80 { 5332 break 5333 } 5334 } 5335 case 3: 5336 if wireType != 0 { 5337 return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType) 5338 } 5339 m.DesiredNumberScheduled = 0 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 m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift 5350 if b < 0x80 { 5351 break 5352 } 5353 } 5354 case 4: 5355 if wireType != 0 { 5356 return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType) 5357 } 5358 m.NumberReady = 0 5359 for shift := uint(0); ; shift += 7 { 5360 if shift >= 64 { 5361 return ErrIntOverflowGenerated 5362 } 5363 if iNdEx >= l { 5364 return io.ErrUnexpectedEOF 5365 } 5366 b := dAtA[iNdEx] 5367 iNdEx++ 5368 m.NumberReady |= (int32(b) & 0x7F) << shift 5369 if b < 0x80 { 5370 break 5371 } 5372 } 5373 case 5: 5374 if wireType != 0 { 5375 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) 5376 } 5377 m.ObservedGeneration = 0 5378 for shift := uint(0); ; shift += 7 { 5379 if shift >= 64 { 5380 return ErrIntOverflowGenerated 5381 } 5382 if iNdEx >= l { 5383 return io.ErrUnexpectedEOF 5384 } 5385 b := dAtA[iNdEx] 5386 iNdEx++ 5387 m.ObservedGeneration |= (int64(b) & 0x7F) << shift 5388 if b < 0x80 { 5389 break 5390 } 5391 } 5392 case 6: 5393 if wireType != 0 { 5394 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType) 5395 } 5396 m.UpdatedNumberScheduled = 0 5397 for shift := uint(0); ; shift += 7 { 5398 if shift >= 64 { 5399 return ErrIntOverflowGenerated 5400 } 5401 if iNdEx >= l { 5402 return io.ErrUnexpectedEOF 5403 } 5404 b := dAtA[iNdEx] 5405 iNdEx++ 5406 m.UpdatedNumberScheduled |= (int32(b) & 0x7F) << shift 5407 if b < 0x80 { 5408 break 5409 } 5410 } 5411 case 7: 5412 if wireType != 0 { 5413 return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType) 5414 } 5415 m.NumberAvailable = 0 5416 for shift := uint(0); ; shift += 7 { 5417 if shift >= 64 { 5418 return ErrIntOverflowGenerated 5419 } 5420 if iNdEx >= l { 5421 return io.ErrUnexpectedEOF 5422 } 5423 b := dAtA[iNdEx] 5424 iNdEx++ 5425 m.NumberAvailable |= (int32(b) & 0x7F) << shift 5426 if b < 0x80 { 5427 break 5428 } 5429 } 5430 case 8: 5431 if wireType != 0 { 5432 return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType) 5433 } 5434 m.NumberUnavailable = 0 5435 for shift := uint(0); ; shift += 7 { 5436 if shift >= 64 { 5437 return ErrIntOverflowGenerated 5438 } 5439 if iNdEx >= l { 5440 return io.ErrUnexpectedEOF 5441 } 5442 b := dAtA[iNdEx] 5443 iNdEx++ 5444 m.NumberUnavailable |= (int32(b) & 0x7F) << shift 5445 if b < 0x80 { 5446 break 5447 } 5448 } 5449 case 9: 5450 if wireType != 0 { 5451 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType) 5452 } 5453 var v int32 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 v |= (int32(b) & 0x7F) << shift 5464 if b < 0x80 { 5465 break 5466 } 5467 } 5468 m.CollisionCount = &v 5469 case 10: 5470 if wireType != 2 { 5471 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 5472 } 5473 var msglen int 5474 for shift := uint(0); ; shift += 7 { 5475 if shift >= 64 { 5476 return ErrIntOverflowGenerated 5477 } 5478 if iNdEx >= l { 5479 return io.ErrUnexpectedEOF 5480 } 5481 b := dAtA[iNdEx] 5482 iNdEx++ 5483 msglen |= (int(b) & 0x7F) << shift 5484 if b < 0x80 { 5485 break 5486 } 5487 } 5488 if msglen < 0 { 5489 return ErrInvalidLengthGenerated 5490 } 5491 postIndex := iNdEx + msglen 5492 if postIndex > l { 5493 return io.ErrUnexpectedEOF 5494 } 5495 m.Conditions = append(m.Conditions, DaemonSetCondition{}) 5496 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5497 return err 5498 } 5499 iNdEx = postIndex 5500 default: 5501 iNdEx = preIndex 5502 skippy, err := skipGenerated(dAtA[iNdEx:]) 5503 if err != nil { 5504 return err 5505 } 5506 if skippy < 0 { 5507 return ErrInvalidLengthGenerated 5508 } 5509 if (iNdEx + skippy) > l { 5510 return io.ErrUnexpectedEOF 5511 } 5512 iNdEx += skippy 5513 } 5514 } 5515 5516 if iNdEx > l { 5517 return io.ErrUnexpectedEOF 5518 } 5519 return nil 5520} 5521func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error { 5522 l := len(dAtA) 5523 iNdEx := 0 5524 for iNdEx < l { 5525 preIndex := iNdEx 5526 var wire uint64 5527 for shift := uint(0); ; shift += 7 { 5528 if shift >= 64 { 5529 return ErrIntOverflowGenerated 5530 } 5531 if iNdEx >= l { 5532 return io.ErrUnexpectedEOF 5533 } 5534 b := dAtA[iNdEx] 5535 iNdEx++ 5536 wire |= (uint64(b) & 0x7F) << shift 5537 if b < 0x80 { 5538 break 5539 } 5540 } 5541 fieldNum := int32(wire >> 3) 5542 wireType := int(wire & 0x7) 5543 if wireType == 4 { 5544 return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group") 5545 } 5546 if fieldNum <= 0 { 5547 return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire) 5548 } 5549 switch fieldNum { 5550 case 1: 5551 if wireType != 2 { 5552 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 5553 } 5554 var stringLen uint64 5555 for shift := uint(0); ; shift += 7 { 5556 if shift >= 64 { 5557 return ErrIntOverflowGenerated 5558 } 5559 if iNdEx >= l { 5560 return io.ErrUnexpectedEOF 5561 } 5562 b := dAtA[iNdEx] 5563 iNdEx++ 5564 stringLen |= (uint64(b) & 0x7F) << shift 5565 if b < 0x80 { 5566 break 5567 } 5568 } 5569 intStringLen := int(stringLen) 5570 if intStringLen < 0 { 5571 return ErrInvalidLengthGenerated 5572 } 5573 postIndex := iNdEx + intStringLen 5574 if postIndex > l { 5575 return io.ErrUnexpectedEOF 5576 } 5577 m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex]) 5578 iNdEx = postIndex 5579 case 2: 5580 if wireType != 2 { 5581 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType) 5582 } 5583 var msglen int 5584 for shift := uint(0); ; shift += 7 { 5585 if shift >= 64 { 5586 return ErrIntOverflowGenerated 5587 } 5588 if iNdEx >= l { 5589 return io.ErrUnexpectedEOF 5590 } 5591 b := dAtA[iNdEx] 5592 iNdEx++ 5593 msglen |= (int(b) & 0x7F) << shift 5594 if b < 0x80 { 5595 break 5596 } 5597 } 5598 if msglen < 0 { 5599 return ErrInvalidLengthGenerated 5600 } 5601 postIndex := iNdEx + msglen 5602 if postIndex > l { 5603 return io.ErrUnexpectedEOF 5604 } 5605 if m.RollingUpdate == nil { 5606 m.RollingUpdate = &RollingUpdateDaemonSet{} 5607 } 5608 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5609 return err 5610 } 5611 iNdEx = postIndex 5612 default: 5613 iNdEx = preIndex 5614 skippy, err := skipGenerated(dAtA[iNdEx:]) 5615 if err != nil { 5616 return err 5617 } 5618 if skippy < 0 { 5619 return ErrInvalidLengthGenerated 5620 } 5621 if (iNdEx + skippy) > l { 5622 return io.ErrUnexpectedEOF 5623 } 5624 iNdEx += skippy 5625 } 5626 } 5627 5628 if iNdEx > l { 5629 return io.ErrUnexpectedEOF 5630 } 5631 return nil 5632} 5633func (m *Deployment) Unmarshal(dAtA []byte) error { 5634 l := len(dAtA) 5635 iNdEx := 0 5636 for iNdEx < l { 5637 preIndex := iNdEx 5638 var wire uint64 5639 for shift := uint(0); ; shift += 7 { 5640 if shift >= 64 { 5641 return ErrIntOverflowGenerated 5642 } 5643 if iNdEx >= l { 5644 return io.ErrUnexpectedEOF 5645 } 5646 b := dAtA[iNdEx] 5647 iNdEx++ 5648 wire |= (uint64(b) & 0x7F) << shift 5649 if b < 0x80 { 5650 break 5651 } 5652 } 5653 fieldNum := int32(wire >> 3) 5654 wireType := int(wire & 0x7) 5655 if wireType == 4 { 5656 return fmt.Errorf("proto: Deployment: wiretype end group for non-group") 5657 } 5658 if fieldNum <= 0 { 5659 return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire) 5660 } 5661 switch fieldNum { 5662 case 1: 5663 if wireType != 2 { 5664 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 5665 } 5666 var msglen int 5667 for shift := uint(0); ; shift += 7 { 5668 if shift >= 64 { 5669 return ErrIntOverflowGenerated 5670 } 5671 if iNdEx >= l { 5672 return io.ErrUnexpectedEOF 5673 } 5674 b := dAtA[iNdEx] 5675 iNdEx++ 5676 msglen |= (int(b) & 0x7F) << shift 5677 if b < 0x80 { 5678 break 5679 } 5680 } 5681 if msglen < 0 { 5682 return ErrInvalidLengthGenerated 5683 } 5684 postIndex := iNdEx + msglen 5685 if postIndex > l { 5686 return io.ErrUnexpectedEOF 5687 } 5688 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5689 return err 5690 } 5691 iNdEx = postIndex 5692 case 2: 5693 if wireType != 2 { 5694 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 5695 } 5696 var msglen int 5697 for shift := uint(0); ; shift += 7 { 5698 if shift >= 64 { 5699 return ErrIntOverflowGenerated 5700 } 5701 if iNdEx >= l { 5702 return io.ErrUnexpectedEOF 5703 } 5704 b := dAtA[iNdEx] 5705 iNdEx++ 5706 msglen |= (int(b) & 0x7F) << shift 5707 if b < 0x80 { 5708 break 5709 } 5710 } 5711 if msglen < 0 { 5712 return ErrInvalidLengthGenerated 5713 } 5714 postIndex := iNdEx + msglen 5715 if postIndex > l { 5716 return io.ErrUnexpectedEOF 5717 } 5718 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5719 return err 5720 } 5721 iNdEx = postIndex 5722 case 3: 5723 if wireType != 2 { 5724 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 5725 } 5726 var msglen int 5727 for shift := uint(0); ; shift += 7 { 5728 if shift >= 64 { 5729 return ErrIntOverflowGenerated 5730 } 5731 if iNdEx >= l { 5732 return io.ErrUnexpectedEOF 5733 } 5734 b := dAtA[iNdEx] 5735 iNdEx++ 5736 msglen |= (int(b) & 0x7F) << shift 5737 if b < 0x80 { 5738 break 5739 } 5740 } 5741 if msglen < 0 { 5742 return ErrInvalidLengthGenerated 5743 } 5744 postIndex := iNdEx + msglen 5745 if postIndex > l { 5746 return io.ErrUnexpectedEOF 5747 } 5748 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5749 return err 5750 } 5751 iNdEx = postIndex 5752 default: 5753 iNdEx = preIndex 5754 skippy, err := skipGenerated(dAtA[iNdEx:]) 5755 if err != nil { 5756 return err 5757 } 5758 if skippy < 0 { 5759 return ErrInvalidLengthGenerated 5760 } 5761 if (iNdEx + skippy) > l { 5762 return io.ErrUnexpectedEOF 5763 } 5764 iNdEx += skippy 5765 } 5766 } 5767 5768 if iNdEx > l { 5769 return io.ErrUnexpectedEOF 5770 } 5771 return nil 5772} 5773func (m *DeploymentCondition) Unmarshal(dAtA []byte) error { 5774 l := len(dAtA) 5775 iNdEx := 0 5776 for iNdEx < l { 5777 preIndex := iNdEx 5778 var wire uint64 5779 for shift := uint(0); ; shift += 7 { 5780 if shift >= 64 { 5781 return ErrIntOverflowGenerated 5782 } 5783 if iNdEx >= l { 5784 return io.ErrUnexpectedEOF 5785 } 5786 b := dAtA[iNdEx] 5787 iNdEx++ 5788 wire |= (uint64(b) & 0x7F) << shift 5789 if b < 0x80 { 5790 break 5791 } 5792 } 5793 fieldNum := int32(wire >> 3) 5794 wireType := int(wire & 0x7) 5795 if wireType == 4 { 5796 return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group") 5797 } 5798 if fieldNum <= 0 { 5799 return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire) 5800 } 5801 switch fieldNum { 5802 case 1: 5803 if wireType != 2 { 5804 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 5805 } 5806 var stringLen uint64 5807 for shift := uint(0); ; shift += 7 { 5808 if shift >= 64 { 5809 return ErrIntOverflowGenerated 5810 } 5811 if iNdEx >= l { 5812 return io.ErrUnexpectedEOF 5813 } 5814 b := dAtA[iNdEx] 5815 iNdEx++ 5816 stringLen |= (uint64(b) & 0x7F) << shift 5817 if b < 0x80 { 5818 break 5819 } 5820 } 5821 intStringLen := int(stringLen) 5822 if intStringLen < 0 { 5823 return ErrInvalidLengthGenerated 5824 } 5825 postIndex := iNdEx + intStringLen 5826 if postIndex > l { 5827 return io.ErrUnexpectedEOF 5828 } 5829 m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex]) 5830 iNdEx = postIndex 5831 case 2: 5832 if wireType != 2 { 5833 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 5834 } 5835 var stringLen uint64 5836 for shift := uint(0); ; shift += 7 { 5837 if shift >= 64 { 5838 return ErrIntOverflowGenerated 5839 } 5840 if iNdEx >= l { 5841 return io.ErrUnexpectedEOF 5842 } 5843 b := dAtA[iNdEx] 5844 iNdEx++ 5845 stringLen |= (uint64(b) & 0x7F) << shift 5846 if b < 0x80 { 5847 break 5848 } 5849 } 5850 intStringLen := int(stringLen) 5851 if intStringLen < 0 { 5852 return ErrInvalidLengthGenerated 5853 } 5854 postIndex := iNdEx + intStringLen 5855 if postIndex > l { 5856 return io.ErrUnexpectedEOF 5857 } 5858 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) 5859 iNdEx = postIndex 5860 case 4: 5861 if wireType != 2 { 5862 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) 5863 } 5864 var stringLen uint64 5865 for shift := uint(0); ; shift += 7 { 5866 if shift >= 64 { 5867 return ErrIntOverflowGenerated 5868 } 5869 if iNdEx >= l { 5870 return io.ErrUnexpectedEOF 5871 } 5872 b := dAtA[iNdEx] 5873 iNdEx++ 5874 stringLen |= (uint64(b) & 0x7F) << shift 5875 if b < 0x80 { 5876 break 5877 } 5878 } 5879 intStringLen := int(stringLen) 5880 if intStringLen < 0 { 5881 return ErrInvalidLengthGenerated 5882 } 5883 postIndex := iNdEx + intStringLen 5884 if postIndex > l { 5885 return io.ErrUnexpectedEOF 5886 } 5887 m.Reason = string(dAtA[iNdEx:postIndex]) 5888 iNdEx = postIndex 5889 case 5: 5890 if wireType != 2 { 5891 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 5892 } 5893 var stringLen uint64 5894 for shift := uint(0); ; shift += 7 { 5895 if shift >= 64 { 5896 return ErrIntOverflowGenerated 5897 } 5898 if iNdEx >= l { 5899 return io.ErrUnexpectedEOF 5900 } 5901 b := dAtA[iNdEx] 5902 iNdEx++ 5903 stringLen |= (uint64(b) & 0x7F) << shift 5904 if b < 0x80 { 5905 break 5906 } 5907 } 5908 intStringLen := int(stringLen) 5909 if intStringLen < 0 { 5910 return ErrInvalidLengthGenerated 5911 } 5912 postIndex := iNdEx + intStringLen 5913 if postIndex > l { 5914 return io.ErrUnexpectedEOF 5915 } 5916 m.Message = string(dAtA[iNdEx:postIndex]) 5917 iNdEx = postIndex 5918 case 6: 5919 if wireType != 2 { 5920 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType) 5921 } 5922 var msglen int 5923 for shift := uint(0); ; shift += 7 { 5924 if shift >= 64 { 5925 return ErrIntOverflowGenerated 5926 } 5927 if iNdEx >= l { 5928 return io.ErrUnexpectedEOF 5929 } 5930 b := dAtA[iNdEx] 5931 iNdEx++ 5932 msglen |= (int(b) & 0x7F) << shift 5933 if b < 0x80 { 5934 break 5935 } 5936 } 5937 if msglen < 0 { 5938 return ErrInvalidLengthGenerated 5939 } 5940 postIndex := iNdEx + msglen 5941 if postIndex > l { 5942 return io.ErrUnexpectedEOF 5943 } 5944 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5945 return err 5946 } 5947 iNdEx = postIndex 5948 case 7: 5949 if wireType != 2 { 5950 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) 5951 } 5952 var msglen int 5953 for shift := uint(0); ; shift += 7 { 5954 if shift >= 64 { 5955 return ErrIntOverflowGenerated 5956 } 5957 if iNdEx >= l { 5958 return io.ErrUnexpectedEOF 5959 } 5960 b := dAtA[iNdEx] 5961 iNdEx++ 5962 msglen |= (int(b) & 0x7F) << shift 5963 if b < 0x80 { 5964 break 5965 } 5966 } 5967 if msglen < 0 { 5968 return ErrInvalidLengthGenerated 5969 } 5970 postIndex := iNdEx + msglen 5971 if postIndex > l { 5972 return io.ErrUnexpectedEOF 5973 } 5974 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5975 return err 5976 } 5977 iNdEx = postIndex 5978 default: 5979 iNdEx = preIndex 5980 skippy, err := skipGenerated(dAtA[iNdEx:]) 5981 if err != nil { 5982 return err 5983 } 5984 if skippy < 0 { 5985 return ErrInvalidLengthGenerated 5986 } 5987 if (iNdEx + skippy) > l { 5988 return io.ErrUnexpectedEOF 5989 } 5990 iNdEx += skippy 5991 } 5992 } 5993 5994 if iNdEx > l { 5995 return io.ErrUnexpectedEOF 5996 } 5997 return nil 5998} 5999func (m *DeploymentList) Unmarshal(dAtA []byte) error { 6000 l := len(dAtA) 6001 iNdEx := 0 6002 for iNdEx < l { 6003 preIndex := iNdEx 6004 var wire uint64 6005 for shift := uint(0); ; shift += 7 { 6006 if shift >= 64 { 6007 return ErrIntOverflowGenerated 6008 } 6009 if iNdEx >= l { 6010 return io.ErrUnexpectedEOF 6011 } 6012 b := dAtA[iNdEx] 6013 iNdEx++ 6014 wire |= (uint64(b) & 0x7F) << shift 6015 if b < 0x80 { 6016 break 6017 } 6018 } 6019 fieldNum := int32(wire >> 3) 6020 wireType := int(wire & 0x7) 6021 if wireType == 4 { 6022 return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group") 6023 } 6024 if fieldNum <= 0 { 6025 return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire) 6026 } 6027 switch fieldNum { 6028 case 1: 6029 if wireType != 2 { 6030 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 6031 } 6032 var msglen int 6033 for shift := uint(0); ; shift += 7 { 6034 if shift >= 64 { 6035 return ErrIntOverflowGenerated 6036 } 6037 if iNdEx >= l { 6038 return io.ErrUnexpectedEOF 6039 } 6040 b := dAtA[iNdEx] 6041 iNdEx++ 6042 msglen |= (int(b) & 0x7F) << shift 6043 if b < 0x80 { 6044 break 6045 } 6046 } 6047 if msglen < 0 { 6048 return ErrInvalidLengthGenerated 6049 } 6050 postIndex := iNdEx + msglen 6051 if postIndex > l { 6052 return io.ErrUnexpectedEOF 6053 } 6054 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6055 return err 6056 } 6057 iNdEx = postIndex 6058 case 2: 6059 if wireType != 2 { 6060 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 6061 } 6062 var msglen int 6063 for shift := uint(0); ; shift += 7 { 6064 if shift >= 64 { 6065 return ErrIntOverflowGenerated 6066 } 6067 if iNdEx >= l { 6068 return io.ErrUnexpectedEOF 6069 } 6070 b := dAtA[iNdEx] 6071 iNdEx++ 6072 msglen |= (int(b) & 0x7F) << shift 6073 if b < 0x80 { 6074 break 6075 } 6076 } 6077 if msglen < 0 { 6078 return ErrInvalidLengthGenerated 6079 } 6080 postIndex := iNdEx + msglen 6081 if postIndex > l { 6082 return io.ErrUnexpectedEOF 6083 } 6084 m.Items = append(m.Items, Deployment{}) 6085 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6086 return err 6087 } 6088 iNdEx = postIndex 6089 default: 6090 iNdEx = preIndex 6091 skippy, err := skipGenerated(dAtA[iNdEx:]) 6092 if err != nil { 6093 return err 6094 } 6095 if skippy < 0 { 6096 return ErrInvalidLengthGenerated 6097 } 6098 if (iNdEx + skippy) > l { 6099 return io.ErrUnexpectedEOF 6100 } 6101 iNdEx += skippy 6102 } 6103 } 6104 6105 if iNdEx > l { 6106 return io.ErrUnexpectedEOF 6107 } 6108 return nil 6109} 6110func (m *DeploymentRollback) Unmarshal(dAtA []byte) error { 6111 l := len(dAtA) 6112 iNdEx := 0 6113 for iNdEx < l { 6114 preIndex := iNdEx 6115 var wire uint64 6116 for shift := uint(0); ; shift += 7 { 6117 if shift >= 64 { 6118 return ErrIntOverflowGenerated 6119 } 6120 if iNdEx >= l { 6121 return io.ErrUnexpectedEOF 6122 } 6123 b := dAtA[iNdEx] 6124 iNdEx++ 6125 wire |= (uint64(b) & 0x7F) << shift 6126 if b < 0x80 { 6127 break 6128 } 6129 } 6130 fieldNum := int32(wire >> 3) 6131 wireType := int(wire & 0x7) 6132 if wireType == 4 { 6133 return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group") 6134 } 6135 if fieldNum <= 0 { 6136 return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire) 6137 } 6138 switch fieldNum { 6139 case 1: 6140 if wireType != 2 { 6141 return fmt.Errorf("proto: wrong wireType = %d for field Name", 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.Name = string(dAtA[iNdEx:postIndex]) 6167 iNdEx = postIndex 6168 case 2: 6169 if wireType != 2 { 6170 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType) 6171 } 6172 var msglen int 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 msglen |= (int(b) & 0x7F) << shift 6183 if b < 0x80 { 6184 break 6185 } 6186 } 6187 if msglen < 0 { 6188 return ErrInvalidLengthGenerated 6189 } 6190 postIndex := iNdEx + msglen 6191 if postIndex > l { 6192 return io.ErrUnexpectedEOF 6193 } 6194 if m.UpdatedAnnotations == nil { 6195 m.UpdatedAnnotations = make(map[string]string) 6196 } 6197 var mapkey string 6198 var mapvalue string 6199 for iNdEx < postIndex { 6200 entryPreIndex := iNdEx 6201 var wire uint64 6202 for shift := uint(0); ; shift += 7 { 6203 if shift >= 64 { 6204 return ErrIntOverflowGenerated 6205 } 6206 if iNdEx >= l { 6207 return io.ErrUnexpectedEOF 6208 } 6209 b := dAtA[iNdEx] 6210 iNdEx++ 6211 wire |= (uint64(b) & 0x7F) << shift 6212 if b < 0x80 { 6213 break 6214 } 6215 } 6216 fieldNum := int32(wire >> 3) 6217 if fieldNum == 1 { 6218 var stringLenmapkey uint64 6219 for shift := uint(0); ; shift += 7 { 6220 if shift >= 64 { 6221 return ErrIntOverflowGenerated 6222 } 6223 if iNdEx >= l { 6224 return io.ErrUnexpectedEOF 6225 } 6226 b := dAtA[iNdEx] 6227 iNdEx++ 6228 stringLenmapkey |= (uint64(b) & 0x7F) << shift 6229 if b < 0x80 { 6230 break 6231 } 6232 } 6233 intStringLenmapkey := int(stringLenmapkey) 6234 if intStringLenmapkey < 0 { 6235 return ErrInvalidLengthGenerated 6236 } 6237 postStringIndexmapkey := iNdEx + intStringLenmapkey 6238 if postStringIndexmapkey > l { 6239 return io.ErrUnexpectedEOF 6240 } 6241 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 6242 iNdEx = postStringIndexmapkey 6243 } else if fieldNum == 2 { 6244 var stringLenmapvalue uint64 6245 for shift := uint(0); ; shift += 7 { 6246 if shift >= 64 { 6247 return ErrIntOverflowGenerated 6248 } 6249 if iNdEx >= l { 6250 return io.ErrUnexpectedEOF 6251 } 6252 b := dAtA[iNdEx] 6253 iNdEx++ 6254 stringLenmapvalue |= (uint64(b) & 0x7F) << shift 6255 if b < 0x80 { 6256 break 6257 } 6258 } 6259 intStringLenmapvalue := int(stringLenmapvalue) 6260 if intStringLenmapvalue < 0 { 6261 return ErrInvalidLengthGenerated 6262 } 6263 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 6264 if postStringIndexmapvalue > l { 6265 return io.ErrUnexpectedEOF 6266 } 6267 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 6268 iNdEx = postStringIndexmapvalue 6269 } else { 6270 iNdEx = entryPreIndex 6271 skippy, err := skipGenerated(dAtA[iNdEx:]) 6272 if err != nil { 6273 return err 6274 } 6275 if skippy < 0 { 6276 return ErrInvalidLengthGenerated 6277 } 6278 if (iNdEx + skippy) > postIndex { 6279 return io.ErrUnexpectedEOF 6280 } 6281 iNdEx += skippy 6282 } 6283 } 6284 m.UpdatedAnnotations[mapkey] = mapvalue 6285 iNdEx = postIndex 6286 case 3: 6287 if wireType != 2 { 6288 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType) 6289 } 6290 var msglen int 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 msglen |= (int(b) & 0x7F) << shift 6301 if b < 0x80 { 6302 break 6303 } 6304 } 6305 if msglen < 0 { 6306 return ErrInvalidLengthGenerated 6307 } 6308 postIndex := iNdEx + msglen 6309 if postIndex > l { 6310 return io.ErrUnexpectedEOF 6311 } 6312 if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6313 return err 6314 } 6315 iNdEx = postIndex 6316 default: 6317 iNdEx = preIndex 6318 skippy, err := skipGenerated(dAtA[iNdEx:]) 6319 if err != nil { 6320 return err 6321 } 6322 if skippy < 0 { 6323 return ErrInvalidLengthGenerated 6324 } 6325 if (iNdEx + skippy) > l { 6326 return io.ErrUnexpectedEOF 6327 } 6328 iNdEx += skippy 6329 } 6330 } 6331 6332 if iNdEx > l { 6333 return io.ErrUnexpectedEOF 6334 } 6335 return nil 6336} 6337func (m *DeploymentSpec) Unmarshal(dAtA []byte) error { 6338 l := len(dAtA) 6339 iNdEx := 0 6340 for iNdEx < l { 6341 preIndex := iNdEx 6342 var wire uint64 6343 for shift := uint(0); ; shift += 7 { 6344 if shift >= 64 { 6345 return ErrIntOverflowGenerated 6346 } 6347 if iNdEx >= l { 6348 return io.ErrUnexpectedEOF 6349 } 6350 b := dAtA[iNdEx] 6351 iNdEx++ 6352 wire |= (uint64(b) & 0x7F) << shift 6353 if b < 0x80 { 6354 break 6355 } 6356 } 6357 fieldNum := int32(wire >> 3) 6358 wireType := int(wire & 0x7) 6359 if wireType == 4 { 6360 return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group") 6361 } 6362 if fieldNum <= 0 { 6363 return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire) 6364 } 6365 switch fieldNum { 6366 case 1: 6367 if wireType != 0 { 6368 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 6369 } 6370 var v int32 6371 for shift := uint(0); ; shift += 7 { 6372 if shift >= 64 { 6373 return ErrIntOverflowGenerated 6374 } 6375 if iNdEx >= l { 6376 return io.ErrUnexpectedEOF 6377 } 6378 b := dAtA[iNdEx] 6379 iNdEx++ 6380 v |= (int32(b) & 0x7F) << shift 6381 if b < 0x80 { 6382 break 6383 } 6384 } 6385 m.Replicas = &v 6386 case 2: 6387 if wireType != 2 { 6388 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 6389 } 6390 var msglen int 6391 for shift := uint(0); ; shift += 7 { 6392 if shift >= 64 { 6393 return ErrIntOverflowGenerated 6394 } 6395 if iNdEx >= l { 6396 return io.ErrUnexpectedEOF 6397 } 6398 b := dAtA[iNdEx] 6399 iNdEx++ 6400 msglen |= (int(b) & 0x7F) << shift 6401 if b < 0x80 { 6402 break 6403 } 6404 } 6405 if msglen < 0 { 6406 return ErrInvalidLengthGenerated 6407 } 6408 postIndex := iNdEx + msglen 6409 if postIndex > l { 6410 return io.ErrUnexpectedEOF 6411 } 6412 if m.Selector == nil { 6413 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 6414 } 6415 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6416 return err 6417 } 6418 iNdEx = postIndex 6419 case 3: 6420 if wireType != 2 { 6421 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) 6422 } 6423 var msglen int 6424 for shift := uint(0); ; shift += 7 { 6425 if shift >= 64 { 6426 return ErrIntOverflowGenerated 6427 } 6428 if iNdEx >= l { 6429 return io.ErrUnexpectedEOF 6430 } 6431 b := dAtA[iNdEx] 6432 iNdEx++ 6433 msglen |= (int(b) & 0x7F) << shift 6434 if b < 0x80 { 6435 break 6436 } 6437 } 6438 if msglen < 0 { 6439 return ErrInvalidLengthGenerated 6440 } 6441 postIndex := iNdEx + msglen 6442 if postIndex > l { 6443 return io.ErrUnexpectedEOF 6444 } 6445 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6446 return err 6447 } 6448 iNdEx = postIndex 6449 case 4: 6450 if wireType != 2 { 6451 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType) 6452 } 6453 var msglen int 6454 for shift := uint(0); ; shift += 7 { 6455 if shift >= 64 { 6456 return ErrIntOverflowGenerated 6457 } 6458 if iNdEx >= l { 6459 return io.ErrUnexpectedEOF 6460 } 6461 b := dAtA[iNdEx] 6462 iNdEx++ 6463 msglen |= (int(b) & 0x7F) << shift 6464 if b < 0x80 { 6465 break 6466 } 6467 } 6468 if msglen < 0 { 6469 return ErrInvalidLengthGenerated 6470 } 6471 postIndex := iNdEx + msglen 6472 if postIndex > l { 6473 return io.ErrUnexpectedEOF 6474 } 6475 if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6476 return err 6477 } 6478 iNdEx = postIndex 6479 case 5: 6480 if wireType != 0 { 6481 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) 6482 } 6483 m.MinReadySeconds = 0 6484 for shift := uint(0); ; shift += 7 { 6485 if shift >= 64 { 6486 return ErrIntOverflowGenerated 6487 } 6488 if iNdEx >= l { 6489 return io.ErrUnexpectedEOF 6490 } 6491 b := dAtA[iNdEx] 6492 iNdEx++ 6493 m.MinReadySeconds |= (int32(b) & 0x7F) << shift 6494 if b < 0x80 { 6495 break 6496 } 6497 } 6498 case 6: 6499 if wireType != 0 { 6500 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType) 6501 } 6502 var v int32 6503 for shift := uint(0); ; shift += 7 { 6504 if shift >= 64 { 6505 return ErrIntOverflowGenerated 6506 } 6507 if iNdEx >= l { 6508 return io.ErrUnexpectedEOF 6509 } 6510 b := dAtA[iNdEx] 6511 iNdEx++ 6512 v |= (int32(b) & 0x7F) << shift 6513 if b < 0x80 { 6514 break 6515 } 6516 } 6517 m.RevisionHistoryLimit = &v 6518 case 7: 6519 if wireType != 0 { 6520 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType) 6521 } 6522 var v int 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 v |= (int(b) & 0x7F) << shift 6533 if b < 0x80 { 6534 break 6535 } 6536 } 6537 m.Paused = bool(v != 0) 6538 case 8: 6539 if wireType != 2 { 6540 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType) 6541 } 6542 var msglen int 6543 for shift := uint(0); ; shift += 7 { 6544 if shift >= 64 { 6545 return ErrIntOverflowGenerated 6546 } 6547 if iNdEx >= l { 6548 return io.ErrUnexpectedEOF 6549 } 6550 b := dAtA[iNdEx] 6551 iNdEx++ 6552 msglen |= (int(b) & 0x7F) << shift 6553 if b < 0x80 { 6554 break 6555 } 6556 } 6557 if msglen < 0 { 6558 return ErrInvalidLengthGenerated 6559 } 6560 postIndex := iNdEx + msglen 6561 if postIndex > l { 6562 return io.ErrUnexpectedEOF 6563 } 6564 if m.RollbackTo == nil { 6565 m.RollbackTo = &RollbackConfig{} 6566 } 6567 if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6568 return err 6569 } 6570 iNdEx = postIndex 6571 case 9: 6572 if wireType != 0 { 6573 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType) 6574 } 6575 var v int32 6576 for shift := uint(0); ; shift += 7 { 6577 if shift >= 64 { 6578 return ErrIntOverflowGenerated 6579 } 6580 if iNdEx >= l { 6581 return io.ErrUnexpectedEOF 6582 } 6583 b := dAtA[iNdEx] 6584 iNdEx++ 6585 v |= (int32(b) & 0x7F) << shift 6586 if b < 0x80 { 6587 break 6588 } 6589 } 6590 m.ProgressDeadlineSeconds = &v 6591 default: 6592 iNdEx = preIndex 6593 skippy, err := skipGenerated(dAtA[iNdEx:]) 6594 if err != nil { 6595 return err 6596 } 6597 if skippy < 0 { 6598 return ErrInvalidLengthGenerated 6599 } 6600 if (iNdEx + skippy) > l { 6601 return io.ErrUnexpectedEOF 6602 } 6603 iNdEx += skippy 6604 } 6605 } 6606 6607 if iNdEx > l { 6608 return io.ErrUnexpectedEOF 6609 } 6610 return nil 6611} 6612func (m *DeploymentStatus) Unmarshal(dAtA []byte) error { 6613 l := len(dAtA) 6614 iNdEx := 0 6615 for iNdEx < l { 6616 preIndex := iNdEx 6617 var wire uint64 6618 for shift := uint(0); ; shift += 7 { 6619 if shift >= 64 { 6620 return ErrIntOverflowGenerated 6621 } 6622 if iNdEx >= l { 6623 return io.ErrUnexpectedEOF 6624 } 6625 b := dAtA[iNdEx] 6626 iNdEx++ 6627 wire |= (uint64(b) & 0x7F) << shift 6628 if b < 0x80 { 6629 break 6630 } 6631 } 6632 fieldNum := int32(wire >> 3) 6633 wireType := int(wire & 0x7) 6634 if wireType == 4 { 6635 return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group") 6636 } 6637 if fieldNum <= 0 { 6638 return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire) 6639 } 6640 switch fieldNum { 6641 case 1: 6642 if wireType != 0 { 6643 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) 6644 } 6645 m.ObservedGeneration = 0 6646 for shift := uint(0); ; shift += 7 { 6647 if shift >= 64 { 6648 return ErrIntOverflowGenerated 6649 } 6650 if iNdEx >= l { 6651 return io.ErrUnexpectedEOF 6652 } 6653 b := dAtA[iNdEx] 6654 iNdEx++ 6655 m.ObservedGeneration |= (int64(b) & 0x7F) << shift 6656 if b < 0x80 { 6657 break 6658 } 6659 } 6660 case 2: 6661 if wireType != 0 { 6662 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 6663 } 6664 m.Replicas = 0 6665 for shift := uint(0); ; shift += 7 { 6666 if shift >= 64 { 6667 return ErrIntOverflowGenerated 6668 } 6669 if iNdEx >= l { 6670 return io.ErrUnexpectedEOF 6671 } 6672 b := dAtA[iNdEx] 6673 iNdEx++ 6674 m.Replicas |= (int32(b) & 0x7F) << shift 6675 if b < 0x80 { 6676 break 6677 } 6678 } 6679 case 3: 6680 if wireType != 0 { 6681 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType) 6682 } 6683 m.UpdatedReplicas = 0 6684 for shift := uint(0); ; shift += 7 { 6685 if shift >= 64 { 6686 return ErrIntOverflowGenerated 6687 } 6688 if iNdEx >= l { 6689 return io.ErrUnexpectedEOF 6690 } 6691 b := dAtA[iNdEx] 6692 iNdEx++ 6693 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift 6694 if b < 0x80 { 6695 break 6696 } 6697 } 6698 case 4: 6699 if wireType != 0 { 6700 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) 6701 } 6702 m.AvailableReplicas = 0 6703 for shift := uint(0); ; shift += 7 { 6704 if shift >= 64 { 6705 return ErrIntOverflowGenerated 6706 } 6707 if iNdEx >= l { 6708 return io.ErrUnexpectedEOF 6709 } 6710 b := dAtA[iNdEx] 6711 iNdEx++ 6712 m.AvailableReplicas |= (int32(b) & 0x7F) << shift 6713 if b < 0x80 { 6714 break 6715 } 6716 } 6717 case 5: 6718 if wireType != 0 { 6719 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType) 6720 } 6721 m.UnavailableReplicas = 0 6722 for shift := uint(0); ; shift += 7 { 6723 if shift >= 64 { 6724 return ErrIntOverflowGenerated 6725 } 6726 if iNdEx >= l { 6727 return io.ErrUnexpectedEOF 6728 } 6729 b := dAtA[iNdEx] 6730 iNdEx++ 6731 m.UnavailableReplicas |= (int32(b) & 0x7F) << shift 6732 if b < 0x80 { 6733 break 6734 } 6735 } 6736 case 6: 6737 if wireType != 2 { 6738 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 6739 } 6740 var msglen int 6741 for shift := uint(0); ; shift += 7 { 6742 if shift >= 64 { 6743 return ErrIntOverflowGenerated 6744 } 6745 if iNdEx >= l { 6746 return io.ErrUnexpectedEOF 6747 } 6748 b := dAtA[iNdEx] 6749 iNdEx++ 6750 msglen |= (int(b) & 0x7F) << shift 6751 if b < 0x80 { 6752 break 6753 } 6754 } 6755 if msglen < 0 { 6756 return ErrInvalidLengthGenerated 6757 } 6758 postIndex := iNdEx + msglen 6759 if postIndex > l { 6760 return io.ErrUnexpectedEOF 6761 } 6762 m.Conditions = append(m.Conditions, DeploymentCondition{}) 6763 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6764 return err 6765 } 6766 iNdEx = postIndex 6767 case 7: 6768 if wireType != 0 { 6769 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) 6770 } 6771 m.ReadyReplicas = 0 6772 for shift := uint(0); ; shift += 7 { 6773 if shift >= 64 { 6774 return ErrIntOverflowGenerated 6775 } 6776 if iNdEx >= l { 6777 return io.ErrUnexpectedEOF 6778 } 6779 b := dAtA[iNdEx] 6780 iNdEx++ 6781 m.ReadyReplicas |= (int32(b) & 0x7F) << shift 6782 if b < 0x80 { 6783 break 6784 } 6785 } 6786 case 8: 6787 if wireType != 0 { 6788 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType) 6789 } 6790 var v int32 6791 for shift := uint(0); ; shift += 7 { 6792 if shift >= 64 { 6793 return ErrIntOverflowGenerated 6794 } 6795 if iNdEx >= l { 6796 return io.ErrUnexpectedEOF 6797 } 6798 b := dAtA[iNdEx] 6799 iNdEx++ 6800 v |= (int32(b) & 0x7F) << shift 6801 if b < 0x80 { 6802 break 6803 } 6804 } 6805 m.CollisionCount = &v 6806 default: 6807 iNdEx = preIndex 6808 skippy, err := skipGenerated(dAtA[iNdEx:]) 6809 if err != nil { 6810 return err 6811 } 6812 if skippy < 0 { 6813 return ErrInvalidLengthGenerated 6814 } 6815 if (iNdEx + skippy) > l { 6816 return io.ErrUnexpectedEOF 6817 } 6818 iNdEx += skippy 6819 } 6820 } 6821 6822 if iNdEx > l { 6823 return io.ErrUnexpectedEOF 6824 } 6825 return nil 6826} 6827func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error { 6828 l := len(dAtA) 6829 iNdEx := 0 6830 for iNdEx < l { 6831 preIndex := iNdEx 6832 var wire uint64 6833 for shift := uint(0); ; shift += 7 { 6834 if shift >= 64 { 6835 return ErrIntOverflowGenerated 6836 } 6837 if iNdEx >= l { 6838 return io.ErrUnexpectedEOF 6839 } 6840 b := dAtA[iNdEx] 6841 iNdEx++ 6842 wire |= (uint64(b) & 0x7F) << shift 6843 if b < 0x80 { 6844 break 6845 } 6846 } 6847 fieldNum := int32(wire >> 3) 6848 wireType := int(wire & 0x7) 6849 if wireType == 4 { 6850 return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group") 6851 } 6852 if fieldNum <= 0 { 6853 return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire) 6854 } 6855 switch fieldNum { 6856 case 1: 6857 if wireType != 2 { 6858 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 6859 } 6860 var stringLen uint64 6861 for shift := uint(0); ; shift += 7 { 6862 if shift >= 64 { 6863 return ErrIntOverflowGenerated 6864 } 6865 if iNdEx >= l { 6866 return io.ErrUnexpectedEOF 6867 } 6868 b := dAtA[iNdEx] 6869 iNdEx++ 6870 stringLen |= (uint64(b) & 0x7F) << shift 6871 if b < 0x80 { 6872 break 6873 } 6874 } 6875 intStringLen := int(stringLen) 6876 if intStringLen < 0 { 6877 return ErrInvalidLengthGenerated 6878 } 6879 postIndex := iNdEx + intStringLen 6880 if postIndex > l { 6881 return io.ErrUnexpectedEOF 6882 } 6883 m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex]) 6884 iNdEx = postIndex 6885 case 2: 6886 if wireType != 2 { 6887 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType) 6888 } 6889 var msglen int 6890 for shift := uint(0); ; shift += 7 { 6891 if shift >= 64 { 6892 return ErrIntOverflowGenerated 6893 } 6894 if iNdEx >= l { 6895 return io.ErrUnexpectedEOF 6896 } 6897 b := dAtA[iNdEx] 6898 iNdEx++ 6899 msglen |= (int(b) & 0x7F) << shift 6900 if b < 0x80 { 6901 break 6902 } 6903 } 6904 if msglen < 0 { 6905 return ErrInvalidLengthGenerated 6906 } 6907 postIndex := iNdEx + msglen 6908 if postIndex > l { 6909 return io.ErrUnexpectedEOF 6910 } 6911 if m.RollingUpdate == nil { 6912 m.RollingUpdate = &RollingUpdateDeployment{} 6913 } 6914 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6915 return err 6916 } 6917 iNdEx = postIndex 6918 default: 6919 iNdEx = preIndex 6920 skippy, err := skipGenerated(dAtA[iNdEx:]) 6921 if err != nil { 6922 return err 6923 } 6924 if skippy < 0 { 6925 return ErrInvalidLengthGenerated 6926 } 6927 if (iNdEx + skippy) > l { 6928 return io.ErrUnexpectedEOF 6929 } 6930 iNdEx += skippy 6931 } 6932 } 6933 6934 if iNdEx > l { 6935 return io.ErrUnexpectedEOF 6936 } 6937 return nil 6938} 6939func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error { 6940 l := len(dAtA) 6941 iNdEx := 0 6942 for iNdEx < l { 6943 preIndex := iNdEx 6944 var wire uint64 6945 for shift := uint(0); ; shift += 7 { 6946 if shift >= 64 { 6947 return ErrIntOverflowGenerated 6948 } 6949 if iNdEx >= l { 6950 return io.ErrUnexpectedEOF 6951 } 6952 b := dAtA[iNdEx] 6953 iNdEx++ 6954 wire |= (uint64(b) & 0x7F) << shift 6955 if b < 0x80 { 6956 break 6957 } 6958 } 6959 fieldNum := int32(wire >> 3) 6960 wireType := int(wire & 0x7) 6961 if wireType == 4 { 6962 return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group") 6963 } 6964 if fieldNum <= 0 { 6965 return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 6966 } 6967 switch fieldNum { 6968 case 1: 6969 if wireType != 2 { 6970 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 6971 } 6972 var stringLen uint64 6973 for shift := uint(0); ; shift += 7 { 6974 if shift >= 64 { 6975 return ErrIntOverflowGenerated 6976 } 6977 if iNdEx >= l { 6978 return io.ErrUnexpectedEOF 6979 } 6980 b := dAtA[iNdEx] 6981 iNdEx++ 6982 stringLen |= (uint64(b) & 0x7F) << shift 6983 if b < 0x80 { 6984 break 6985 } 6986 } 6987 intStringLen := int(stringLen) 6988 if intStringLen < 0 { 6989 return ErrInvalidLengthGenerated 6990 } 6991 postIndex := iNdEx + intStringLen 6992 if postIndex > l { 6993 return io.ErrUnexpectedEOF 6994 } 6995 m.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex]) 6996 iNdEx = postIndex 6997 case 2: 6998 if wireType != 2 { 6999 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 7000 } 7001 var msglen int 7002 for shift := uint(0); ; shift += 7 { 7003 if shift >= 64 { 7004 return ErrIntOverflowGenerated 7005 } 7006 if iNdEx >= l { 7007 return io.ErrUnexpectedEOF 7008 } 7009 b := dAtA[iNdEx] 7010 iNdEx++ 7011 msglen |= (int(b) & 0x7F) << shift 7012 if b < 0x80 { 7013 break 7014 } 7015 } 7016 if msglen < 0 { 7017 return ErrInvalidLengthGenerated 7018 } 7019 postIndex := iNdEx + msglen 7020 if postIndex > l { 7021 return io.ErrUnexpectedEOF 7022 } 7023 m.Ranges = append(m.Ranges, IDRange{}) 7024 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7025 return err 7026 } 7027 iNdEx = postIndex 7028 default: 7029 iNdEx = preIndex 7030 skippy, err := skipGenerated(dAtA[iNdEx:]) 7031 if err != nil { 7032 return err 7033 } 7034 if skippy < 0 { 7035 return ErrInvalidLengthGenerated 7036 } 7037 if (iNdEx + skippy) > l { 7038 return io.ErrUnexpectedEOF 7039 } 7040 iNdEx += skippy 7041 } 7042 } 7043 7044 if iNdEx > l { 7045 return io.ErrUnexpectedEOF 7046 } 7047 return nil 7048} 7049func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error { 7050 l := len(dAtA) 7051 iNdEx := 0 7052 for iNdEx < l { 7053 preIndex := iNdEx 7054 var wire uint64 7055 for shift := uint(0); ; shift += 7 { 7056 if shift >= 64 { 7057 return ErrIntOverflowGenerated 7058 } 7059 if iNdEx >= l { 7060 return io.ErrUnexpectedEOF 7061 } 7062 b := dAtA[iNdEx] 7063 iNdEx++ 7064 wire |= (uint64(b) & 0x7F) << shift 7065 if b < 0x80 { 7066 break 7067 } 7068 } 7069 fieldNum := int32(wire >> 3) 7070 wireType := int(wire & 0x7) 7071 if wireType == 4 { 7072 return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group") 7073 } 7074 if fieldNum <= 0 { 7075 return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire) 7076 } 7077 switch fieldNum { 7078 case 1: 7079 if wireType != 2 { 7080 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) 7081 } 7082 var stringLen uint64 7083 for shift := uint(0); ; shift += 7 { 7084 if shift >= 64 { 7085 return ErrIntOverflowGenerated 7086 } 7087 if iNdEx >= l { 7088 return io.ErrUnexpectedEOF 7089 } 7090 b := dAtA[iNdEx] 7091 iNdEx++ 7092 stringLen |= (uint64(b) & 0x7F) << shift 7093 if b < 0x80 { 7094 break 7095 } 7096 } 7097 intStringLen := int(stringLen) 7098 if intStringLen < 0 { 7099 return ErrInvalidLengthGenerated 7100 } 7101 postIndex := iNdEx + intStringLen 7102 if postIndex > l { 7103 return io.ErrUnexpectedEOF 7104 } 7105 m.Path = string(dAtA[iNdEx:postIndex]) 7106 iNdEx = postIndex 7107 case 2: 7108 if wireType != 2 { 7109 return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType) 7110 } 7111 var msglen int 7112 for shift := uint(0); ; shift += 7 { 7113 if shift >= 64 { 7114 return ErrIntOverflowGenerated 7115 } 7116 if iNdEx >= l { 7117 return io.ErrUnexpectedEOF 7118 } 7119 b := dAtA[iNdEx] 7120 iNdEx++ 7121 msglen |= (int(b) & 0x7F) << shift 7122 if b < 0x80 { 7123 break 7124 } 7125 } 7126 if msglen < 0 { 7127 return ErrInvalidLengthGenerated 7128 } 7129 postIndex := iNdEx + msglen 7130 if postIndex > l { 7131 return io.ErrUnexpectedEOF 7132 } 7133 if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7134 return err 7135 } 7136 iNdEx = postIndex 7137 default: 7138 iNdEx = preIndex 7139 skippy, err := skipGenerated(dAtA[iNdEx:]) 7140 if err != nil { 7141 return err 7142 } 7143 if skippy < 0 { 7144 return ErrInvalidLengthGenerated 7145 } 7146 if (iNdEx + skippy) > l { 7147 return io.ErrUnexpectedEOF 7148 } 7149 iNdEx += skippy 7150 } 7151 } 7152 7153 if iNdEx > l { 7154 return io.ErrUnexpectedEOF 7155 } 7156 return nil 7157} 7158func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error { 7159 l := len(dAtA) 7160 iNdEx := 0 7161 for iNdEx < l { 7162 preIndex := iNdEx 7163 var wire uint64 7164 for shift := uint(0); ; shift += 7 { 7165 if shift >= 64 { 7166 return ErrIntOverflowGenerated 7167 } 7168 if iNdEx >= l { 7169 return io.ErrUnexpectedEOF 7170 } 7171 b := dAtA[iNdEx] 7172 iNdEx++ 7173 wire |= (uint64(b) & 0x7F) << shift 7174 if b < 0x80 { 7175 break 7176 } 7177 } 7178 fieldNum := int32(wire >> 3) 7179 wireType := int(wire & 0x7) 7180 if wireType == 4 { 7181 return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group") 7182 } 7183 if fieldNum <= 0 { 7184 return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire) 7185 } 7186 switch fieldNum { 7187 case 1: 7188 if wireType != 2 { 7189 return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType) 7190 } 7191 var msglen int 7192 for shift := uint(0); ; shift += 7 { 7193 if shift >= 64 { 7194 return ErrIntOverflowGenerated 7195 } 7196 if iNdEx >= l { 7197 return io.ErrUnexpectedEOF 7198 } 7199 b := dAtA[iNdEx] 7200 iNdEx++ 7201 msglen |= (int(b) & 0x7F) << shift 7202 if b < 0x80 { 7203 break 7204 } 7205 } 7206 if msglen < 0 { 7207 return ErrInvalidLengthGenerated 7208 } 7209 postIndex := iNdEx + msglen 7210 if postIndex > l { 7211 return io.ErrUnexpectedEOF 7212 } 7213 m.Paths = append(m.Paths, HTTPIngressPath{}) 7214 if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7215 return err 7216 } 7217 iNdEx = postIndex 7218 default: 7219 iNdEx = preIndex 7220 skippy, err := skipGenerated(dAtA[iNdEx:]) 7221 if err != nil { 7222 return err 7223 } 7224 if skippy < 0 { 7225 return ErrInvalidLengthGenerated 7226 } 7227 if (iNdEx + skippy) > l { 7228 return io.ErrUnexpectedEOF 7229 } 7230 iNdEx += skippy 7231 } 7232 } 7233 7234 if iNdEx > l { 7235 return io.ErrUnexpectedEOF 7236 } 7237 return nil 7238} 7239func (m *HostPortRange) Unmarshal(dAtA []byte) error { 7240 l := len(dAtA) 7241 iNdEx := 0 7242 for iNdEx < l { 7243 preIndex := iNdEx 7244 var wire uint64 7245 for shift := uint(0); ; shift += 7 { 7246 if shift >= 64 { 7247 return ErrIntOverflowGenerated 7248 } 7249 if iNdEx >= l { 7250 return io.ErrUnexpectedEOF 7251 } 7252 b := dAtA[iNdEx] 7253 iNdEx++ 7254 wire |= (uint64(b) & 0x7F) << shift 7255 if b < 0x80 { 7256 break 7257 } 7258 } 7259 fieldNum := int32(wire >> 3) 7260 wireType := int(wire & 0x7) 7261 if wireType == 4 { 7262 return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group") 7263 } 7264 if fieldNum <= 0 { 7265 return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire) 7266 } 7267 switch fieldNum { 7268 case 1: 7269 if wireType != 0 { 7270 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType) 7271 } 7272 m.Min = 0 7273 for shift := uint(0); ; shift += 7 { 7274 if shift >= 64 { 7275 return ErrIntOverflowGenerated 7276 } 7277 if iNdEx >= l { 7278 return io.ErrUnexpectedEOF 7279 } 7280 b := dAtA[iNdEx] 7281 iNdEx++ 7282 m.Min |= (int32(b) & 0x7F) << shift 7283 if b < 0x80 { 7284 break 7285 } 7286 } 7287 case 2: 7288 if wireType != 0 { 7289 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) 7290 } 7291 m.Max = 0 7292 for shift := uint(0); ; shift += 7 { 7293 if shift >= 64 { 7294 return ErrIntOverflowGenerated 7295 } 7296 if iNdEx >= l { 7297 return io.ErrUnexpectedEOF 7298 } 7299 b := dAtA[iNdEx] 7300 iNdEx++ 7301 m.Max |= (int32(b) & 0x7F) << shift 7302 if b < 0x80 { 7303 break 7304 } 7305 } 7306 default: 7307 iNdEx = preIndex 7308 skippy, err := skipGenerated(dAtA[iNdEx:]) 7309 if err != nil { 7310 return err 7311 } 7312 if skippy < 0 { 7313 return ErrInvalidLengthGenerated 7314 } 7315 if (iNdEx + skippy) > l { 7316 return io.ErrUnexpectedEOF 7317 } 7318 iNdEx += skippy 7319 } 7320 } 7321 7322 if iNdEx > l { 7323 return io.ErrUnexpectedEOF 7324 } 7325 return nil 7326} 7327func (m *IDRange) Unmarshal(dAtA []byte) error { 7328 l := len(dAtA) 7329 iNdEx := 0 7330 for iNdEx < l { 7331 preIndex := iNdEx 7332 var wire uint64 7333 for shift := uint(0); ; shift += 7 { 7334 if shift >= 64 { 7335 return ErrIntOverflowGenerated 7336 } 7337 if iNdEx >= l { 7338 return io.ErrUnexpectedEOF 7339 } 7340 b := dAtA[iNdEx] 7341 iNdEx++ 7342 wire |= (uint64(b) & 0x7F) << shift 7343 if b < 0x80 { 7344 break 7345 } 7346 } 7347 fieldNum := int32(wire >> 3) 7348 wireType := int(wire & 0x7) 7349 if wireType == 4 { 7350 return fmt.Errorf("proto: IDRange: wiretype end group for non-group") 7351 } 7352 if fieldNum <= 0 { 7353 return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire) 7354 } 7355 switch fieldNum { 7356 case 1: 7357 if wireType != 0 { 7358 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType) 7359 } 7360 m.Min = 0 7361 for shift := uint(0); ; shift += 7 { 7362 if shift >= 64 { 7363 return ErrIntOverflowGenerated 7364 } 7365 if iNdEx >= l { 7366 return io.ErrUnexpectedEOF 7367 } 7368 b := dAtA[iNdEx] 7369 iNdEx++ 7370 m.Min |= (int64(b) & 0x7F) << shift 7371 if b < 0x80 { 7372 break 7373 } 7374 } 7375 case 2: 7376 if wireType != 0 { 7377 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) 7378 } 7379 m.Max = 0 7380 for shift := uint(0); ; shift += 7 { 7381 if shift >= 64 { 7382 return ErrIntOverflowGenerated 7383 } 7384 if iNdEx >= l { 7385 return io.ErrUnexpectedEOF 7386 } 7387 b := dAtA[iNdEx] 7388 iNdEx++ 7389 m.Max |= (int64(b) & 0x7F) << shift 7390 if b < 0x80 { 7391 break 7392 } 7393 } 7394 default: 7395 iNdEx = preIndex 7396 skippy, err := skipGenerated(dAtA[iNdEx:]) 7397 if err != nil { 7398 return err 7399 } 7400 if skippy < 0 { 7401 return ErrInvalidLengthGenerated 7402 } 7403 if (iNdEx + skippy) > l { 7404 return io.ErrUnexpectedEOF 7405 } 7406 iNdEx += skippy 7407 } 7408 } 7409 7410 if iNdEx > l { 7411 return io.ErrUnexpectedEOF 7412 } 7413 return nil 7414} 7415func (m *IPBlock) Unmarshal(dAtA []byte) error { 7416 l := len(dAtA) 7417 iNdEx := 0 7418 for iNdEx < l { 7419 preIndex := iNdEx 7420 var wire uint64 7421 for shift := uint(0); ; shift += 7 { 7422 if shift >= 64 { 7423 return ErrIntOverflowGenerated 7424 } 7425 if iNdEx >= l { 7426 return io.ErrUnexpectedEOF 7427 } 7428 b := dAtA[iNdEx] 7429 iNdEx++ 7430 wire |= (uint64(b) & 0x7F) << shift 7431 if b < 0x80 { 7432 break 7433 } 7434 } 7435 fieldNum := int32(wire >> 3) 7436 wireType := int(wire & 0x7) 7437 if wireType == 4 { 7438 return fmt.Errorf("proto: IPBlock: wiretype end group for non-group") 7439 } 7440 if fieldNum <= 0 { 7441 return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire) 7442 } 7443 switch fieldNum { 7444 case 1: 7445 if wireType != 2 { 7446 return fmt.Errorf("proto: wrong wireType = %d for field CIDR", wireType) 7447 } 7448 var stringLen uint64 7449 for shift := uint(0); ; shift += 7 { 7450 if shift >= 64 { 7451 return ErrIntOverflowGenerated 7452 } 7453 if iNdEx >= l { 7454 return io.ErrUnexpectedEOF 7455 } 7456 b := dAtA[iNdEx] 7457 iNdEx++ 7458 stringLen |= (uint64(b) & 0x7F) << shift 7459 if b < 0x80 { 7460 break 7461 } 7462 } 7463 intStringLen := int(stringLen) 7464 if intStringLen < 0 { 7465 return ErrInvalidLengthGenerated 7466 } 7467 postIndex := iNdEx + intStringLen 7468 if postIndex > l { 7469 return io.ErrUnexpectedEOF 7470 } 7471 m.CIDR = string(dAtA[iNdEx:postIndex]) 7472 iNdEx = postIndex 7473 case 2: 7474 if wireType != 2 { 7475 return fmt.Errorf("proto: wrong wireType = %d for field Except", wireType) 7476 } 7477 var stringLen uint64 7478 for shift := uint(0); ; shift += 7 { 7479 if shift >= 64 { 7480 return ErrIntOverflowGenerated 7481 } 7482 if iNdEx >= l { 7483 return io.ErrUnexpectedEOF 7484 } 7485 b := dAtA[iNdEx] 7486 iNdEx++ 7487 stringLen |= (uint64(b) & 0x7F) << shift 7488 if b < 0x80 { 7489 break 7490 } 7491 } 7492 intStringLen := int(stringLen) 7493 if intStringLen < 0 { 7494 return ErrInvalidLengthGenerated 7495 } 7496 postIndex := iNdEx + intStringLen 7497 if postIndex > l { 7498 return io.ErrUnexpectedEOF 7499 } 7500 m.Except = append(m.Except, string(dAtA[iNdEx:postIndex])) 7501 iNdEx = postIndex 7502 default: 7503 iNdEx = preIndex 7504 skippy, err := skipGenerated(dAtA[iNdEx:]) 7505 if err != nil { 7506 return err 7507 } 7508 if skippy < 0 { 7509 return ErrInvalidLengthGenerated 7510 } 7511 if (iNdEx + skippy) > l { 7512 return io.ErrUnexpectedEOF 7513 } 7514 iNdEx += skippy 7515 } 7516 } 7517 7518 if iNdEx > l { 7519 return io.ErrUnexpectedEOF 7520 } 7521 return nil 7522} 7523func (m *Ingress) Unmarshal(dAtA []byte) error { 7524 l := len(dAtA) 7525 iNdEx := 0 7526 for iNdEx < l { 7527 preIndex := iNdEx 7528 var wire uint64 7529 for shift := uint(0); ; shift += 7 { 7530 if shift >= 64 { 7531 return ErrIntOverflowGenerated 7532 } 7533 if iNdEx >= l { 7534 return io.ErrUnexpectedEOF 7535 } 7536 b := dAtA[iNdEx] 7537 iNdEx++ 7538 wire |= (uint64(b) & 0x7F) << shift 7539 if b < 0x80 { 7540 break 7541 } 7542 } 7543 fieldNum := int32(wire >> 3) 7544 wireType := int(wire & 0x7) 7545 if wireType == 4 { 7546 return fmt.Errorf("proto: Ingress: wiretype end group for non-group") 7547 } 7548 if fieldNum <= 0 { 7549 return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire) 7550 } 7551 switch fieldNum { 7552 case 1: 7553 if wireType != 2 { 7554 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 7555 } 7556 var msglen int 7557 for shift := uint(0); ; shift += 7 { 7558 if shift >= 64 { 7559 return ErrIntOverflowGenerated 7560 } 7561 if iNdEx >= l { 7562 return io.ErrUnexpectedEOF 7563 } 7564 b := dAtA[iNdEx] 7565 iNdEx++ 7566 msglen |= (int(b) & 0x7F) << shift 7567 if b < 0x80 { 7568 break 7569 } 7570 } 7571 if msglen < 0 { 7572 return ErrInvalidLengthGenerated 7573 } 7574 postIndex := iNdEx + msglen 7575 if postIndex > l { 7576 return io.ErrUnexpectedEOF 7577 } 7578 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7579 return err 7580 } 7581 iNdEx = postIndex 7582 case 2: 7583 if wireType != 2 { 7584 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 7585 } 7586 var msglen int 7587 for shift := uint(0); ; shift += 7 { 7588 if shift >= 64 { 7589 return ErrIntOverflowGenerated 7590 } 7591 if iNdEx >= l { 7592 return io.ErrUnexpectedEOF 7593 } 7594 b := dAtA[iNdEx] 7595 iNdEx++ 7596 msglen |= (int(b) & 0x7F) << shift 7597 if b < 0x80 { 7598 break 7599 } 7600 } 7601 if msglen < 0 { 7602 return ErrInvalidLengthGenerated 7603 } 7604 postIndex := iNdEx + msglen 7605 if postIndex > l { 7606 return io.ErrUnexpectedEOF 7607 } 7608 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7609 return err 7610 } 7611 iNdEx = postIndex 7612 case 3: 7613 if wireType != 2 { 7614 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 7615 } 7616 var msglen int 7617 for shift := uint(0); ; shift += 7 { 7618 if shift >= 64 { 7619 return ErrIntOverflowGenerated 7620 } 7621 if iNdEx >= l { 7622 return io.ErrUnexpectedEOF 7623 } 7624 b := dAtA[iNdEx] 7625 iNdEx++ 7626 msglen |= (int(b) & 0x7F) << shift 7627 if b < 0x80 { 7628 break 7629 } 7630 } 7631 if msglen < 0 { 7632 return ErrInvalidLengthGenerated 7633 } 7634 postIndex := iNdEx + msglen 7635 if postIndex > l { 7636 return io.ErrUnexpectedEOF 7637 } 7638 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7639 return err 7640 } 7641 iNdEx = postIndex 7642 default: 7643 iNdEx = preIndex 7644 skippy, err := skipGenerated(dAtA[iNdEx:]) 7645 if err != nil { 7646 return err 7647 } 7648 if skippy < 0 { 7649 return ErrInvalidLengthGenerated 7650 } 7651 if (iNdEx + skippy) > l { 7652 return io.ErrUnexpectedEOF 7653 } 7654 iNdEx += skippy 7655 } 7656 } 7657 7658 if iNdEx > l { 7659 return io.ErrUnexpectedEOF 7660 } 7661 return nil 7662} 7663func (m *IngressBackend) Unmarshal(dAtA []byte) error { 7664 l := len(dAtA) 7665 iNdEx := 0 7666 for iNdEx < l { 7667 preIndex := iNdEx 7668 var wire uint64 7669 for shift := uint(0); ; shift += 7 { 7670 if shift >= 64 { 7671 return ErrIntOverflowGenerated 7672 } 7673 if iNdEx >= l { 7674 return io.ErrUnexpectedEOF 7675 } 7676 b := dAtA[iNdEx] 7677 iNdEx++ 7678 wire |= (uint64(b) & 0x7F) << shift 7679 if b < 0x80 { 7680 break 7681 } 7682 } 7683 fieldNum := int32(wire >> 3) 7684 wireType := int(wire & 0x7) 7685 if wireType == 4 { 7686 return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group") 7687 } 7688 if fieldNum <= 0 { 7689 return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire) 7690 } 7691 switch fieldNum { 7692 case 1: 7693 if wireType != 2 { 7694 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) 7695 } 7696 var stringLen uint64 7697 for shift := uint(0); ; shift += 7 { 7698 if shift >= 64 { 7699 return ErrIntOverflowGenerated 7700 } 7701 if iNdEx >= l { 7702 return io.ErrUnexpectedEOF 7703 } 7704 b := dAtA[iNdEx] 7705 iNdEx++ 7706 stringLen |= (uint64(b) & 0x7F) << shift 7707 if b < 0x80 { 7708 break 7709 } 7710 } 7711 intStringLen := int(stringLen) 7712 if intStringLen < 0 { 7713 return ErrInvalidLengthGenerated 7714 } 7715 postIndex := iNdEx + intStringLen 7716 if postIndex > l { 7717 return io.ErrUnexpectedEOF 7718 } 7719 m.ServiceName = string(dAtA[iNdEx:postIndex]) 7720 iNdEx = postIndex 7721 case 2: 7722 if wireType != 2 { 7723 return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType) 7724 } 7725 var msglen int 7726 for shift := uint(0); ; shift += 7 { 7727 if shift >= 64 { 7728 return ErrIntOverflowGenerated 7729 } 7730 if iNdEx >= l { 7731 return io.ErrUnexpectedEOF 7732 } 7733 b := dAtA[iNdEx] 7734 iNdEx++ 7735 msglen |= (int(b) & 0x7F) << shift 7736 if b < 0x80 { 7737 break 7738 } 7739 } 7740 if msglen < 0 { 7741 return ErrInvalidLengthGenerated 7742 } 7743 postIndex := iNdEx + msglen 7744 if postIndex > l { 7745 return io.ErrUnexpectedEOF 7746 } 7747 if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7748 return err 7749 } 7750 iNdEx = postIndex 7751 default: 7752 iNdEx = preIndex 7753 skippy, err := skipGenerated(dAtA[iNdEx:]) 7754 if err != nil { 7755 return err 7756 } 7757 if skippy < 0 { 7758 return ErrInvalidLengthGenerated 7759 } 7760 if (iNdEx + skippy) > l { 7761 return io.ErrUnexpectedEOF 7762 } 7763 iNdEx += skippy 7764 } 7765 } 7766 7767 if iNdEx > l { 7768 return io.ErrUnexpectedEOF 7769 } 7770 return nil 7771} 7772func (m *IngressList) Unmarshal(dAtA []byte) error { 7773 l := len(dAtA) 7774 iNdEx := 0 7775 for iNdEx < l { 7776 preIndex := iNdEx 7777 var wire uint64 7778 for shift := uint(0); ; shift += 7 { 7779 if shift >= 64 { 7780 return ErrIntOverflowGenerated 7781 } 7782 if iNdEx >= l { 7783 return io.ErrUnexpectedEOF 7784 } 7785 b := dAtA[iNdEx] 7786 iNdEx++ 7787 wire |= (uint64(b) & 0x7F) << shift 7788 if b < 0x80 { 7789 break 7790 } 7791 } 7792 fieldNum := int32(wire >> 3) 7793 wireType := int(wire & 0x7) 7794 if wireType == 4 { 7795 return fmt.Errorf("proto: IngressList: wiretype end group for non-group") 7796 } 7797 if fieldNum <= 0 { 7798 return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire) 7799 } 7800 switch fieldNum { 7801 case 1: 7802 if wireType != 2 { 7803 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 7804 } 7805 var msglen int 7806 for shift := uint(0); ; shift += 7 { 7807 if shift >= 64 { 7808 return ErrIntOverflowGenerated 7809 } 7810 if iNdEx >= l { 7811 return io.ErrUnexpectedEOF 7812 } 7813 b := dAtA[iNdEx] 7814 iNdEx++ 7815 msglen |= (int(b) & 0x7F) << shift 7816 if b < 0x80 { 7817 break 7818 } 7819 } 7820 if msglen < 0 { 7821 return ErrInvalidLengthGenerated 7822 } 7823 postIndex := iNdEx + msglen 7824 if postIndex > l { 7825 return io.ErrUnexpectedEOF 7826 } 7827 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7828 return err 7829 } 7830 iNdEx = postIndex 7831 case 2: 7832 if wireType != 2 { 7833 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 7834 } 7835 var msglen int 7836 for shift := uint(0); ; shift += 7 { 7837 if shift >= 64 { 7838 return ErrIntOverflowGenerated 7839 } 7840 if iNdEx >= l { 7841 return io.ErrUnexpectedEOF 7842 } 7843 b := dAtA[iNdEx] 7844 iNdEx++ 7845 msglen |= (int(b) & 0x7F) << shift 7846 if b < 0x80 { 7847 break 7848 } 7849 } 7850 if msglen < 0 { 7851 return ErrInvalidLengthGenerated 7852 } 7853 postIndex := iNdEx + msglen 7854 if postIndex > l { 7855 return io.ErrUnexpectedEOF 7856 } 7857 m.Items = append(m.Items, Ingress{}) 7858 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7859 return err 7860 } 7861 iNdEx = postIndex 7862 default: 7863 iNdEx = preIndex 7864 skippy, err := skipGenerated(dAtA[iNdEx:]) 7865 if err != nil { 7866 return err 7867 } 7868 if skippy < 0 { 7869 return ErrInvalidLengthGenerated 7870 } 7871 if (iNdEx + skippy) > l { 7872 return io.ErrUnexpectedEOF 7873 } 7874 iNdEx += skippy 7875 } 7876 } 7877 7878 if iNdEx > l { 7879 return io.ErrUnexpectedEOF 7880 } 7881 return nil 7882} 7883func (m *IngressRule) Unmarshal(dAtA []byte) error { 7884 l := len(dAtA) 7885 iNdEx := 0 7886 for iNdEx < l { 7887 preIndex := iNdEx 7888 var wire uint64 7889 for shift := uint(0); ; shift += 7 { 7890 if shift >= 64 { 7891 return ErrIntOverflowGenerated 7892 } 7893 if iNdEx >= l { 7894 return io.ErrUnexpectedEOF 7895 } 7896 b := dAtA[iNdEx] 7897 iNdEx++ 7898 wire |= (uint64(b) & 0x7F) << shift 7899 if b < 0x80 { 7900 break 7901 } 7902 } 7903 fieldNum := int32(wire >> 3) 7904 wireType := int(wire & 0x7) 7905 if wireType == 4 { 7906 return fmt.Errorf("proto: IngressRule: wiretype end group for non-group") 7907 } 7908 if fieldNum <= 0 { 7909 return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire) 7910 } 7911 switch fieldNum { 7912 case 1: 7913 if wireType != 2 { 7914 return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) 7915 } 7916 var stringLen uint64 7917 for shift := uint(0); ; shift += 7 { 7918 if shift >= 64 { 7919 return ErrIntOverflowGenerated 7920 } 7921 if iNdEx >= l { 7922 return io.ErrUnexpectedEOF 7923 } 7924 b := dAtA[iNdEx] 7925 iNdEx++ 7926 stringLen |= (uint64(b) & 0x7F) << shift 7927 if b < 0x80 { 7928 break 7929 } 7930 } 7931 intStringLen := int(stringLen) 7932 if intStringLen < 0 { 7933 return ErrInvalidLengthGenerated 7934 } 7935 postIndex := iNdEx + intStringLen 7936 if postIndex > l { 7937 return io.ErrUnexpectedEOF 7938 } 7939 m.Host = string(dAtA[iNdEx:postIndex]) 7940 iNdEx = postIndex 7941 case 2: 7942 if wireType != 2 { 7943 return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType) 7944 } 7945 var msglen int 7946 for shift := uint(0); ; shift += 7 { 7947 if shift >= 64 { 7948 return ErrIntOverflowGenerated 7949 } 7950 if iNdEx >= l { 7951 return io.ErrUnexpectedEOF 7952 } 7953 b := dAtA[iNdEx] 7954 iNdEx++ 7955 msglen |= (int(b) & 0x7F) << shift 7956 if b < 0x80 { 7957 break 7958 } 7959 } 7960 if msglen < 0 { 7961 return ErrInvalidLengthGenerated 7962 } 7963 postIndex := iNdEx + msglen 7964 if postIndex > l { 7965 return io.ErrUnexpectedEOF 7966 } 7967 if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7968 return err 7969 } 7970 iNdEx = postIndex 7971 default: 7972 iNdEx = preIndex 7973 skippy, err := skipGenerated(dAtA[iNdEx:]) 7974 if err != nil { 7975 return err 7976 } 7977 if skippy < 0 { 7978 return ErrInvalidLengthGenerated 7979 } 7980 if (iNdEx + skippy) > l { 7981 return io.ErrUnexpectedEOF 7982 } 7983 iNdEx += skippy 7984 } 7985 } 7986 7987 if iNdEx > l { 7988 return io.ErrUnexpectedEOF 7989 } 7990 return nil 7991} 7992func (m *IngressRuleValue) Unmarshal(dAtA []byte) error { 7993 l := len(dAtA) 7994 iNdEx := 0 7995 for iNdEx < l { 7996 preIndex := iNdEx 7997 var wire uint64 7998 for shift := uint(0); ; shift += 7 { 7999 if shift >= 64 { 8000 return ErrIntOverflowGenerated 8001 } 8002 if iNdEx >= l { 8003 return io.ErrUnexpectedEOF 8004 } 8005 b := dAtA[iNdEx] 8006 iNdEx++ 8007 wire |= (uint64(b) & 0x7F) << shift 8008 if b < 0x80 { 8009 break 8010 } 8011 } 8012 fieldNum := int32(wire >> 3) 8013 wireType := int(wire & 0x7) 8014 if wireType == 4 { 8015 return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group") 8016 } 8017 if fieldNum <= 0 { 8018 return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire) 8019 } 8020 switch fieldNum { 8021 case 1: 8022 if wireType != 2 { 8023 return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType) 8024 } 8025 var msglen int 8026 for shift := uint(0); ; shift += 7 { 8027 if shift >= 64 { 8028 return ErrIntOverflowGenerated 8029 } 8030 if iNdEx >= l { 8031 return io.ErrUnexpectedEOF 8032 } 8033 b := dAtA[iNdEx] 8034 iNdEx++ 8035 msglen |= (int(b) & 0x7F) << shift 8036 if b < 0x80 { 8037 break 8038 } 8039 } 8040 if msglen < 0 { 8041 return ErrInvalidLengthGenerated 8042 } 8043 postIndex := iNdEx + msglen 8044 if postIndex > l { 8045 return io.ErrUnexpectedEOF 8046 } 8047 if m.HTTP == nil { 8048 m.HTTP = &HTTPIngressRuleValue{} 8049 } 8050 if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8051 return err 8052 } 8053 iNdEx = postIndex 8054 default: 8055 iNdEx = preIndex 8056 skippy, err := skipGenerated(dAtA[iNdEx:]) 8057 if err != nil { 8058 return err 8059 } 8060 if skippy < 0 { 8061 return ErrInvalidLengthGenerated 8062 } 8063 if (iNdEx + skippy) > l { 8064 return io.ErrUnexpectedEOF 8065 } 8066 iNdEx += skippy 8067 } 8068 } 8069 8070 if iNdEx > l { 8071 return io.ErrUnexpectedEOF 8072 } 8073 return nil 8074} 8075func (m *IngressSpec) Unmarshal(dAtA []byte) error { 8076 l := len(dAtA) 8077 iNdEx := 0 8078 for iNdEx < l { 8079 preIndex := iNdEx 8080 var wire uint64 8081 for shift := uint(0); ; shift += 7 { 8082 if shift >= 64 { 8083 return ErrIntOverflowGenerated 8084 } 8085 if iNdEx >= l { 8086 return io.ErrUnexpectedEOF 8087 } 8088 b := dAtA[iNdEx] 8089 iNdEx++ 8090 wire |= (uint64(b) & 0x7F) << shift 8091 if b < 0x80 { 8092 break 8093 } 8094 } 8095 fieldNum := int32(wire >> 3) 8096 wireType := int(wire & 0x7) 8097 if wireType == 4 { 8098 return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group") 8099 } 8100 if fieldNum <= 0 { 8101 return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire) 8102 } 8103 switch fieldNum { 8104 case 1: 8105 if wireType != 2 { 8106 return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType) 8107 } 8108 var msglen int 8109 for shift := uint(0); ; shift += 7 { 8110 if shift >= 64 { 8111 return ErrIntOverflowGenerated 8112 } 8113 if iNdEx >= l { 8114 return io.ErrUnexpectedEOF 8115 } 8116 b := dAtA[iNdEx] 8117 iNdEx++ 8118 msglen |= (int(b) & 0x7F) << shift 8119 if b < 0x80 { 8120 break 8121 } 8122 } 8123 if msglen < 0 { 8124 return ErrInvalidLengthGenerated 8125 } 8126 postIndex := iNdEx + msglen 8127 if postIndex > l { 8128 return io.ErrUnexpectedEOF 8129 } 8130 if m.Backend == nil { 8131 m.Backend = &IngressBackend{} 8132 } 8133 if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8134 return err 8135 } 8136 iNdEx = postIndex 8137 case 2: 8138 if wireType != 2 { 8139 return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType) 8140 } 8141 var msglen int 8142 for shift := uint(0); ; shift += 7 { 8143 if shift >= 64 { 8144 return ErrIntOverflowGenerated 8145 } 8146 if iNdEx >= l { 8147 return io.ErrUnexpectedEOF 8148 } 8149 b := dAtA[iNdEx] 8150 iNdEx++ 8151 msglen |= (int(b) & 0x7F) << shift 8152 if b < 0x80 { 8153 break 8154 } 8155 } 8156 if msglen < 0 { 8157 return ErrInvalidLengthGenerated 8158 } 8159 postIndex := iNdEx + msglen 8160 if postIndex > l { 8161 return io.ErrUnexpectedEOF 8162 } 8163 m.TLS = append(m.TLS, IngressTLS{}) 8164 if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8165 return err 8166 } 8167 iNdEx = postIndex 8168 case 3: 8169 if wireType != 2 { 8170 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType) 8171 } 8172 var msglen int 8173 for shift := uint(0); ; shift += 7 { 8174 if shift >= 64 { 8175 return ErrIntOverflowGenerated 8176 } 8177 if iNdEx >= l { 8178 return io.ErrUnexpectedEOF 8179 } 8180 b := dAtA[iNdEx] 8181 iNdEx++ 8182 msglen |= (int(b) & 0x7F) << shift 8183 if b < 0x80 { 8184 break 8185 } 8186 } 8187 if msglen < 0 { 8188 return ErrInvalidLengthGenerated 8189 } 8190 postIndex := iNdEx + msglen 8191 if postIndex > l { 8192 return io.ErrUnexpectedEOF 8193 } 8194 m.Rules = append(m.Rules, IngressRule{}) 8195 if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8196 return err 8197 } 8198 iNdEx = postIndex 8199 default: 8200 iNdEx = preIndex 8201 skippy, err := skipGenerated(dAtA[iNdEx:]) 8202 if err != nil { 8203 return err 8204 } 8205 if skippy < 0 { 8206 return ErrInvalidLengthGenerated 8207 } 8208 if (iNdEx + skippy) > l { 8209 return io.ErrUnexpectedEOF 8210 } 8211 iNdEx += skippy 8212 } 8213 } 8214 8215 if iNdEx > l { 8216 return io.ErrUnexpectedEOF 8217 } 8218 return nil 8219} 8220func (m *IngressStatus) Unmarshal(dAtA []byte) error { 8221 l := len(dAtA) 8222 iNdEx := 0 8223 for iNdEx < l { 8224 preIndex := iNdEx 8225 var wire uint64 8226 for shift := uint(0); ; shift += 7 { 8227 if shift >= 64 { 8228 return ErrIntOverflowGenerated 8229 } 8230 if iNdEx >= l { 8231 return io.ErrUnexpectedEOF 8232 } 8233 b := dAtA[iNdEx] 8234 iNdEx++ 8235 wire |= (uint64(b) & 0x7F) << shift 8236 if b < 0x80 { 8237 break 8238 } 8239 } 8240 fieldNum := int32(wire >> 3) 8241 wireType := int(wire & 0x7) 8242 if wireType == 4 { 8243 return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group") 8244 } 8245 if fieldNum <= 0 { 8246 return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire) 8247 } 8248 switch fieldNum { 8249 case 1: 8250 if wireType != 2 { 8251 return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType) 8252 } 8253 var msglen int 8254 for shift := uint(0); ; shift += 7 { 8255 if shift >= 64 { 8256 return ErrIntOverflowGenerated 8257 } 8258 if iNdEx >= l { 8259 return io.ErrUnexpectedEOF 8260 } 8261 b := dAtA[iNdEx] 8262 iNdEx++ 8263 msglen |= (int(b) & 0x7F) << shift 8264 if b < 0x80 { 8265 break 8266 } 8267 } 8268 if msglen < 0 { 8269 return ErrInvalidLengthGenerated 8270 } 8271 postIndex := iNdEx + msglen 8272 if postIndex > l { 8273 return io.ErrUnexpectedEOF 8274 } 8275 if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8276 return err 8277 } 8278 iNdEx = postIndex 8279 default: 8280 iNdEx = preIndex 8281 skippy, err := skipGenerated(dAtA[iNdEx:]) 8282 if err != nil { 8283 return err 8284 } 8285 if skippy < 0 { 8286 return ErrInvalidLengthGenerated 8287 } 8288 if (iNdEx + skippy) > l { 8289 return io.ErrUnexpectedEOF 8290 } 8291 iNdEx += skippy 8292 } 8293 } 8294 8295 if iNdEx > l { 8296 return io.ErrUnexpectedEOF 8297 } 8298 return nil 8299} 8300func (m *IngressTLS) Unmarshal(dAtA []byte) error { 8301 l := len(dAtA) 8302 iNdEx := 0 8303 for iNdEx < l { 8304 preIndex := iNdEx 8305 var wire uint64 8306 for shift := uint(0); ; shift += 7 { 8307 if shift >= 64 { 8308 return ErrIntOverflowGenerated 8309 } 8310 if iNdEx >= l { 8311 return io.ErrUnexpectedEOF 8312 } 8313 b := dAtA[iNdEx] 8314 iNdEx++ 8315 wire |= (uint64(b) & 0x7F) << shift 8316 if b < 0x80 { 8317 break 8318 } 8319 } 8320 fieldNum := int32(wire >> 3) 8321 wireType := int(wire & 0x7) 8322 if wireType == 4 { 8323 return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group") 8324 } 8325 if fieldNum <= 0 { 8326 return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire) 8327 } 8328 switch fieldNum { 8329 case 1: 8330 if wireType != 2 { 8331 return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType) 8332 } 8333 var stringLen uint64 8334 for shift := uint(0); ; shift += 7 { 8335 if shift >= 64 { 8336 return ErrIntOverflowGenerated 8337 } 8338 if iNdEx >= l { 8339 return io.ErrUnexpectedEOF 8340 } 8341 b := dAtA[iNdEx] 8342 iNdEx++ 8343 stringLen |= (uint64(b) & 0x7F) << shift 8344 if b < 0x80 { 8345 break 8346 } 8347 } 8348 intStringLen := int(stringLen) 8349 if intStringLen < 0 { 8350 return ErrInvalidLengthGenerated 8351 } 8352 postIndex := iNdEx + intStringLen 8353 if postIndex > l { 8354 return io.ErrUnexpectedEOF 8355 } 8356 m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex])) 8357 iNdEx = postIndex 8358 case 2: 8359 if wireType != 2 { 8360 return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType) 8361 } 8362 var stringLen uint64 8363 for shift := uint(0); ; shift += 7 { 8364 if shift >= 64 { 8365 return ErrIntOverflowGenerated 8366 } 8367 if iNdEx >= l { 8368 return io.ErrUnexpectedEOF 8369 } 8370 b := dAtA[iNdEx] 8371 iNdEx++ 8372 stringLen |= (uint64(b) & 0x7F) << shift 8373 if b < 0x80 { 8374 break 8375 } 8376 } 8377 intStringLen := int(stringLen) 8378 if intStringLen < 0 { 8379 return ErrInvalidLengthGenerated 8380 } 8381 postIndex := iNdEx + intStringLen 8382 if postIndex > l { 8383 return io.ErrUnexpectedEOF 8384 } 8385 m.SecretName = string(dAtA[iNdEx:postIndex]) 8386 iNdEx = postIndex 8387 default: 8388 iNdEx = preIndex 8389 skippy, err := skipGenerated(dAtA[iNdEx:]) 8390 if err != nil { 8391 return err 8392 } 8393 if skippy < 0 { 8394 return ErrInvalidLengthGenerated 8395 } 8396 if (iNdEx + skippy) > l { 8397 return io.ErrUnexpectedEOF 8398 } 8399 iNdEx += skippy 8400 } 8401 } 8402 8403 if iNdEx > l { 8404 return io.ErrUnexpectedEOF 8405 } 8406 return nil 8407} 8408func (m *NetworkPolicy) Unmarshal(dAtA []byte) error { 8409 l := len(dAtA) 8410 iNdEx := 0 8411 for iNdEx < l { 8412 preIndex := iNdEx 8413 var wire uint64 8414 for shift := uint(0); ; shift += 7 { 8415 if shift >= 64 { 8416 return ErrIntOverflowGenerated 8417 } 8418 if iNdEx >= l { 8419 return io.ErrUnexpectedEOF 8420 } 8421 b := dAtA[iNdEx] 8422 iNdEx++ 8423 wire |= (uint64(b) & 0x7F) << shift 8424 if b < 0x80 { 8425 break 8426 } 8427 } 8428 fieldNum := int32(wire >> 3) 8429 wireType := int(wire & 0x7) 8430 if wireType == 4 { 8431 return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group") 8432 } 8433 if fieldNum <= 0 { 8434 return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire) 8435 } 8436 switch fieldNum { 8437 case 1: 8438 if wireType != 2 { 8439 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 8440 } 8441 var msglen int 8442 for shift := uint(0); ; shift += 7 { 8443 if shift >= 64 { 8444 return ErrIntOverflowGenerated 8445 } 8446 if iNdEx >= l { 8447 return io.ErrUnexpectedEOF 8448 } 8449 b := dAtA[iNdEx] 8450 iNdEx++ 8451 msglen |= (int(b) & 0x7F) << shift 8452 if b < 0x80 { 8453 break 8454 } 8455 } 8456 if msglen < 0 { 8457 return ErrInvalidLengthGenerated 8458 } 8459 postIndex := iNdEx + msglen 8460 if postIndex > l { 8461 return io.ErrUnexpectedEOF 8462 } 8463 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8464 return err 8465 } 8466 iNdEx = postIndex 8467 case 2: 8468 if wireType != 2 { 8469 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 8470 } 8471 var msglen int 8472 for shift := uint(0); ; shift += 7 { 8473 if shift >= 64 { 8474 return ErrIntOverflowGenerated 8475 } 8476 if iNdEx >= l { 8477 return io.ErrUnexpectedEOF 8478 } 8479 b := dAtA[iNdEx] 8480 iNdEx++ 8481 msglen |= (int(b) & 0x7F) << shift 8482 if b < 0x80 { 8483 break 8484 } 8485 } 8486 if msglen < 0 { 8487 return ErrInvalidLengthGenerated 8488 } 8489 postIndex := iNdEx + msglen 8490 if postIndex > l { 8491 return io.ErrUnexpectedEOF 8492 } 8493 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8494 return err 8495 } 8496 iNdEx = postIndex 8497 default: 8498 iNdEx = preIndex 8499 skippy, err := skipGenerated(dAtA[iNdEx:]) 8500 if err != nil { 8501 return err 8502 } 8503 if skippy < 0 { 8504 return ErrInvalidLengthGenerated 8505 } 8506 if (iNdEx + skippy) > l { 8507 return io.ErrUnexpectedEOF 8508 } 8509 iNdEx += skippy 8510 } 8511 } 8512 8513 if iNdEx > l { 8514 return io.ErrUnexpectedEOF 8515 } 8516 return nil 8517} 8518func (m *NetworkPolicyEgressRule) Unmarshal(dAtA []byte) error { 8519 l := len(dAtA) 8520 iNdEx := 0 8521 for iNdEx < l { 8522 preIndex := iNdEx 8523 var wire uint64 8524 for shift := uint(0); ; shift += 7 { 8525 if shift >= 64 { 8526 return ErrIntOverflowGenerated 8527 } 8528 if iNdEx >= l { 8529 return io.ErrUnexpectedEOF 8530 } 8531 b := dAtA[iNdEx] 8532 iNdEx++ 8533 wire |= (uint64(b) & 0x7F) << shift 8534 if b < 0x80 { 8535 break 8536 } 8537 } 8538 fieldNum := int32(wire >> 3) 8539 wireType := int(wire & 0x7) 8540 if wireType == 4 { 8541 return fmt.Errorf("proto: NetworkPolicyEgressRule: wiretype end group for non-group") 8542 } 8543 if fieldNum <= 0 { 8544 return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire) 8545 } 8546 switch fieldNum { 8547 case 1: 8548 if wireType != 2 { 8549 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType) 8550 } 8551 var msglen int 8552 for shift := uint(0); ; shift += 7 { 8553 if shift >= 64 { 8554 return ErrIntOverflowGenerated 8555 } 8556 if iNdEx >= l { 8557 return io.ErrUnexpectedEOF 8558 } 8559 b := dAtA[iNdEx] 8560 iNdEx++ 8561 msglen |= (int(b) & 0x7F) << shift 8562 if b < 0x80 { 8563 break 8564 } 8565 } 8566 if msglen < 0 { 8567 return ErrInvalidLengthGenerated 8568 } 8569 postIndex := iNdEx + msglen 8570 if postIndex > l { 8571 return io.ErrUnexpectedEOF 8572 } 8573 m.Ports = append(m.Ports, NetworkPolicyPort{}) 8574 if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8575 return err 8576 } 8577 iNdEx = postIndex 8578 case 2: 8579 if wireType != 2 { 8580 return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) 8581 } 8582 var msglen int 8583 for shift := uint(0); ; shift += 7 { 8584 if shift >= 64 { 8585 return ErrIntOverflowGenerated 8586 } 8587 if iNdEx >= l { 8588 return io.ErrUnexpectedEOF 8589 } 8590 b := dAtA[iNdEx] 8591 iNdEx++ 8592 msglen |= (int(b) & 0x7F) << shift 8593 if b < 0x80 { 8594 break 8595 } 8596 } 8597 if msglen < 0 { 8598 return ErrInvalidLengthGenerated 8599 } 8600 postIndex := iNdEx + msglen 8601 if postIndex > l { 8602 return io.ErrUnexpectedEOF 8603 } 8604 m.To = append(m.To, NetworkPolicyPeer{}) 8605 if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8606 return err 8607 } 8608 iNdEx = postIndex 8609 default: 8610 iNdEx = preIndex 8611 skippy, err := skipGenerated(dAtA[iNdEx:]) 8612 if err != nil { 8613 return err 8614 } 8615 if skippy < 0 { 8616 return ErrInvalidLengthGenerated 8617 } 8618 if (iNdEx + skippy) > l { 8619 return io.ErrUnexpectedEOF 8620 } 8621 iNdEx += skippy 8622 } 8623 } 8624 8625 if iNdEx > l { 8626 return io.ErrUnexpectedEOF 8627 } 8628 return nil 8629} 8630func (m *NetworkPolicyIngressRule) Unmarshal(dAtA []byte) error { 8631 l := len(dAtA) 8632 iNdEx := 0 8633 for iNdEx < l { 8634 preIndex := iNdEx 8635 var wire uint64 8636 for shift := uint(0); ; shift += 7 { 8637 if shift >= 64 { 8638 return ErrIntOverflowGenerated 8639 } 8640 if iNdEx >= l { 8641 return io.ErrUnexpectedEOF 8642 } 8643 b := dAtA[iNdEx] 8644 iNdEx++ 8645 wire |= (uint64(b) & 0x7F) << shift 8646 if b < 0x80 { 8647 break 8648 } 8649 } 8650 fieldNum := int32(wire >> 3) 8651 wireType := int(wire & 0x7) 8652 if wireType == 4 { 8653 return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group") 8654 } 8655 if fieldNum <= 0 { 8656 return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire) 8657 } 8658 switch fieldNum { 8659 case 1: 8660 if wireType != 2 { 8661 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType) 8662 } 8663 var msglen int 8664 for shift := uint(0); ; shift += 7 { 8665 if shift >= 64 { 8666 return ErrIntOverflowGenerated 8667 } 8668 if iNdEx >= l { 8669 return io.ErrUnexpectedEOF 8670 } 8671 b := dAtA[iNdEx] 8672 iNdEx++ 8673 msglen |= (int(b) & 0x7F) << shift 8674 if b < 0x80 { 8675 break 8676 } 8677 } 8678 if msglen < 0 { 8679 return ErrInvalidLengthGenerated 8680 } 8681 postIndex := iNdEx + msglen 8682 if postIndex > l { 8683 return io.ErrUnexpectedEOF 8684 } 8685 m.Ports = append(m.Ports, NetworkPolicyPort{}) 8686 if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8687 return err 8688 } 8689 iNdEx = postIndex 8690 case 2: 8691 if wireType != 2 { 8692 return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) 8693 } 8694 var msglen int 8695 for shift := uint(0); ; shift += 7 { 8696 if shift >= 64 { 8697 return ErrIntOverflowGenerated 8698 } 8699 if iNdEx >= l { 8700 return io.ErrUnexpectedEOF 8701 } 8702 b := dAtA[iNdEx] 8703 iNdEx++ 8704 msglen |= (int(b) & 0x7F) << shift 8705 if b < 0x80 { 8706 break 8707 } 8708 } 8709 if msglen < 0 { 8710 return ErrInvalidLengthGenerated 8711 } 8712 postIndex := iNdEx + msglen 8713 if postIndex > l { 8714 return io.ErrUnexpectedEOF 8715 } 8716 m.From = append(m.From, NetworkPolicyPeer{}) 8717 if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8718 return err 8719 } 8720 iNdEx = postIndex 8721 default: 8722 iNdEx = preIndex 8723 skippy, err := skipGenerated(dAtA[iNdEx:]) 8724 if err != nil { 8725 return err 8726 } 8727 if skippy < 0 { 8728 return ErrInvalidLengthGenerated 8729 } 8730 if (iNdEx + skippy) > l { 8731 return io.ErrUnexpectedEOF 8732 } 8733 iNdEx += skippy 8734 } 8735 } 8736 8737 if iNdEx > l { 8738 return io.ErrUnexpectedEOF 8739 } 8740 return nil 8741} 8742func (m *NetworkPolicyList) Unmarshal(dAtA []byte) error { 8743 l := len(dAtA) 8744 iNdEx := 0 8745 for iNdEx < l { 8746 preIndex := iNdEx 8747 var wire uint64 8748 for shift := uint(0); ; shift += 7 { 8749 if shift >= 64 { 8750 return ErrIntOverflowGenerated 8751 } 8752 if iNdEx >= l { 8753 return io.ErrUnexpectedEOF 8754 } 8755 b := dAtA[iNdEx] 8756 iNdEx++ 8757 wire |= (uint64(b) & 0x7F) << shift 8758 if b < 0x80 { 8759 break 8760 } 8761 } 8762 fieldNum := int32(wire >> 3) 8763 wireType := int(wire & 0x7) 8764 if wireType == 4 { 8765 return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group") 8766 } 8767 if fieldNum <= 0 { 8768 return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire) 8769 } 8770 switch fieldNum { 8771 case 1: 8772 if wireType != 2 { 8773 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 8774 } 8775 var msglen int 8776 for shift := uint(0); ; shift += 7 { 8777 if shift >= 64 { 8778 return ErrIntOverflowGenerated 8779 } 8780 if iNdEx >= l { 8781 return io.ErrUnexpectedEOF 8782 } 8783 b := dAtA[iNdEx] 8784 iNdEx++ 8785 msglen |= (int(b) & 0x7F) << shift 8786 if b < 0x80 { 8787 break 8788 } 8789 } 8790 if msglen < 0 { 8791 return ErrInvalidLengthGenerated 8792 } 8793 postIndex := iNdEx + msglen 8794 if postIndex > l { 8795 return io.ErrUnexpectedEOF 8796 } 8797 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8798 return err 8799 } 8800 iNdEx = postIndex 8801 case 2: 8802 if wireType != 2 { 8803 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 8804 } 8805 var msglen int 8806 for shift := uint(0); ; shift += 7 { 8807 if shift >= 64 { 8808 return ErrIntOverflowGenerated 8809 } 8810 if iNdEx >= l { 8811 return io.ErrUnexpectedEOF 8812 } 8813 b := dAtA[iNdEx] 8814 iNdEx++ 8815 msglen |= (int(b) & 0x7F) << shift 8816 if b < 0x80 { 8817 break 8818 } 8819 } 8820 if msglen < 0 { 8821 return ErrInvalidLengthGenerated 8822 } 8823 postIndex := iNdEx + msglen 8824 if postIndex > l { 8825 return io.ErrUnexpectedEOF 8826 } 8827 m.Items = append(m.Items, NetworkPolicy{}) 8828 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8829 return err 8830 } 8831 iNdEx = postIndex 8832 default: 8833 iNdEx = preIndex 8834 skippy, err := skipGenerated(dAtA[iNdEx:]) 8835 if err != nil { 8836 return err 8837 } 8838 if skippy < 0 { 8839 return ErrInvalidLengthGenerated 8840 } 8841 if (iNdEx + skippy) > l { 8842 return io.ErrUnexpectedEOF 8843 } 8844 iNdEx += skippy 8845 } 8846 } 8847 8848 if iNdEx > l { 8849 return io.ErrUnexpectedEOF 8850 } 8851 return nil 8852} 8853func (m *NetworkPolicyPeer) Unmarshal(dAtA []byte) error { 8854 l := len(dAtA) 8855 iNdEx := 0 8856 for iNdEx < l { 8857 preIndex := iNdEx 8858 var wire uint64 8859 for shift := uint(0); ; shift += 7 { 8860 if shift >= 64 { 8861 return ErrIntOverflowGenerated 8862 } 8863 if iNdEx >= l { 8864 return io.ErrUnexpectedEOF 8865 } 8866 b := dAtA[iNdEx] 8867 iNdEx++ 8868 wire |= (uint64(b) & 0x7F) << shift 8869 if b < 0x80 { 8870 break 8871 } 8872 } 8873 fieldNum := int32(wire >> 3) 8874 wireType := int(wire & 0x7) 8875 if wireType == 4 { 8876 return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group") 8877 } 8878 if fieldNum <= 0 { 8879 return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire) 8880 } 8881 switch fieldNum { 8882 case 1: 8883 if wireType != 2 { 8884 return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType) 8885 } 8886 var msglen int 8887 for shift := uint(0); ; shift += 7 { 8888 if shift >= 64 { 8889 return ErrIntOverflowGenerated 8890 } 8891 if iNdEx >= l { 8892 return io.ErrUnexpectedEOF 8893 } 8894 b := dAtA[iNdEx] 8895 iNdEx++ 8896 msglen |= (int(b) & 0x7F) << shift 8897 if b < 0x80 { 8898 break 8899 } 8900 } 8901 if msglen < 0 { 8902 return ErrInvalidLengthGenerated 8903 } 8904 postIndex := iNdEx + msglen 8905 if postIndex > l { 8906 return io.ErrUnexpectedEOF 8907 } 8908 if m.PodSelector == nil { 8909 m.PodSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 8910 } 8911 if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8912 return err 8913 } 8914 iNdEx = postIndex 8915 case 2: 8916 if wireType != 2 { 8917 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType) 8918 } 8919 var msglen int 8920 for shift := uint(0); ; shift += 7 { 8921 if shift >= 64 { 8922 return ErrIntOverflowGenerated 8923 } 8924 if iNdEx >= l { 8925 return io.ErrUnexpectedEOF 8926 } 8927 b := dAtA[iNdEx] 8928 iNdEx++ 8929 msglen |= (int(b) & 0x7F) << shift 8930 if b < 0x80 { 8931 break 8932 } 8933 } 8934 if msglen < 0 { 8935 return ErrInvalidLengthGenerated 8936 } 8937 postIndex := iNdEx + msglen 8938 if postIndex > l { 8939 return io.ErrUnexpectedEOF 8940 } 8941 if m.NamespaceSelector == nil { 8942 m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 8943 } 8944 if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8945 return err 8946 } 8947 iNdEx = postIndex 8948 case 3: 8949 if wireType != 2 { 8950 return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", wireType) 8951 } 8952 var msglen int 8953 for shift := uint(0); ; shift += 7 { 8954 if shift >= 64 { 8955 return ErrIntOverflowGenerated 8956 } 8957 if iNdEx >= l { 8958 return io.ErrUnexpectedEOF 8959 } 8960 b := dAtA[iNdEx] 8961 iNdEx++ 8962 msglen |= (int(b) & 0x7F) << shift 8963 if b < 0x80 { 8964 break 8965 } 8966 } 8967 if msglen < 0 { 8968 return ErrInvalidLengthGenerated 8969 } 8970 postIndex := iNdEx + msglen 8971 if postIndex > l { 8972 return io.ErrUnexpectedEOF 8973 } 8974 if m.IPBlock == nil { 8975 m.IPBlock = &IPBlock{} 8976 } 8977 if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8978 return err 8979 } 8980 iNdEx = postIndex 8981 default: 8982 iNdEx = preIndex 8983 skippy, err := skipGenerated(dAtA[iNdEx:]) 8984 if err != nil { 8985 return err 8986 } 8987 if skippy < 0 { 8988 return ErrInvalidLengthGenerated 8989 } 8990 if (iNdEx + skippy) > l { 8991 return io.ErrUnexpectedEOF 8992 } 8993 iNdEx += skippy 8994 } 8995 } 8996 8997 if iNdEx > l { 8998 return io.ErrUnexpectedEOF 8999 } 9000 return nil 9001} 9002func (m *NetworkPolicyPort) Unmarshal(dAtA []byte) error { 9003 l := len(dAtA) 9004 iNdEx := 0 9005 for iNdEx < l { 9006 preIndex := iNdEx 9007 var wire uint64 9008 for shift := uint(0); ; shift += 7 { 9009 if shift >= 64 { 9010 return ErrIntOverflowGenerated 9011 } 9012 if iNdEx >= l { 9013 return io.ErrUnexpectedEOF 9014 } 9015 b := dAtA[iNdEx] 9016 iNdEx++ 9017 wire |= (uint64(b) & 0x7F) << shift 9018 if b < 0x80 { 9019 break 9020 } 9021 } 9022 fieldNum := int32(wire >> 3) 9023 wireType := int(wire & 0x7) 9024 if wireType == 4 { 9025 return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group") 9026 } 9027 if fieldNum <= 0 { 9028 return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire) 9029 } 9030 switch fieldNum { 9031 case 1: 9032 if wireType != 2 { 9033 return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) 9034 } 9035 var stringLen uint64 9036 for shift := uint(0); ; shift += 7 { 9037 if shift >= 64 { 9038 return ErrIntOverflowGenerated 9039 } 9040 if iNdEx >= l { 9041 return io.ErrUnexpectedEOF 9042 } 9043 b := dAtA[iNdEx] 9044 iNdEx++ 9045 stringLen |= (uint64(b) & 0x7F) << shift 9046 if b < 0x80 { 9047 break 9048 } 9049 } 9050 intStringLen := int(stringLen) 9051 if intStringLen < 0 { 9052 return ErrInvalidLengthGenerated 9053 } 9054 postIndex := iNdEx + intStringLen 9055 if postIndex > l { 9056 return io.ErrUnexpectedEOF 9057 } 9058 s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex]) 9059 m.Protocol = &s 9060 iNdEx = postIndex 9061 case 2: 9062 if wireType != 2 { 9063 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) 9064 } 9065 var msglen int 9066 for shift := uint(0); ; shift += 7 { 9067 if shift >= 64 { 9068 return ErrIntOverflowGenerated 9069 } 9070 if iNdEx >= l { 9071 return io.ErrUnexpectedEOF 9072 } 9073 b := dAtA[iNdEx] 9074 iNdEx++ 9075 msglen |= (int(b) & 0x7F) << shift 9076 if b < 0x80 { 9077 break 9078 } 9079 } 9080 if msglen < 0 { 9081 return ErrInvalidLengthGenerated 9082 } 9083 postIndex := iNdEx + msglen 9084 if postIndex > l { 9085 return io.ErrUnexpectedEOF 9086 } 9087 if m.Port == nil { 9088 m.Port = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 9089 } 9090 if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9091 return err 9092 } 9093 iNdEx = postIndex 9094 default: 9095 iNdEx = preIndex 9096 skippy, err := skipGenerated(dAtA[iNdEx:]) 9097 if err != nil { 9098 return err 9099 } 9100 if skippy < 0 { 9101 return ErrInvalidLengthGenerated 9102 } 9103 if (iNdEx + skippy) > l { 9104 return io.ErrUnexpectedEOF 9105 } 9106 iNdEx += skippy 9107 } 9108 } 9109 9110 if iNdEx > l { 9111 return io.ErrUnexpectedEOF 9112 } 9113 return nil 9114} 9115func (m *NetworkPolicySpec) Unmarshal(dAtA []byte) error { 9116 l := len(dAtA) 9117 iNdEx := 0 9118 for iNdEx < l { 9119 preIndex := iNdEx 9120 var wire uint64 9121 for shift := uint(0); ; shift += 7 { 9122 if shift >= 64 { 9123 return ErrIntOverflowGenerated 9124 } 9125 if iNdEx >= l { 9126 return io.ErrUnexpectedEOF 9127 } 9128 b := dAtA[iNdEx] 9129 iNdEx++ 9130 wire |= (uint64(b) & 0x7F) << shift 9131 if b < 0x80 { 9132 break 9133 } 9134 } 9135 fieldNum := int32(wire >> 3) 9136 wireType := int(wire & 0x7) 9137 if wireType == 4 { 9138 return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group") 9139 } 9140 if fieldNum <= 0 { 9141 return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire) 9142 } 9143 switch fieldNum { 9144 case 1: 9145 if wireType != 2 { 9146 return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType) 9147 } 9148 var msglen int 9149 for shift := uint(0); ; shift += 7 { 9150 if shift >= 64 { 9151 return ErrIntOverflowGenerated 9152 } 9153 if iNdEx >= l { 9154 return io.ErrUnexpectedEOF 9155 } 9156 b := dAtA[iNdEx] 9157 iNdEx++ 9158 msglen |= (int(b) & 0x7F) << shift 9159 if b < 0x80 { 9160 break 9161 } 9162 } 9163 if msglen < 0 { 9164 return ErrInvalidLengthGenerated 9165 } 9166 postIndex := iNdEx + msglen 9167 if postIndex > l { 9168 return io.ErrUnexpectedEOF 9169 } 9170 if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9171 return err 9172 } 9173 iNdEx = postIndex 9174 case 2: 9175 if wireType != 2 { 9176 return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType) 9177 } 9178 var msglen int 9179 for shift := uint(0); ; shift += 7 { 9180 if shift >= 64 { 9181 return ErrIntOverflowGenerated 9182 } 9183 if iNdEx >= l { 9184 return io.ErrUnexpectedEOF 9185 } 9186 b := dAtA[iNdEx] 9187 iNdEx++ 9188 msglen |= (int(b) & 0x7F) << shift 9189 if b < 0x80 { 9190 break 9191 } 9192 } 9193 if msglen < 0 { 9194 return ErrInvalidLengthGenerated 9195 } 9196 postIndex := iNdEx + msglen 9197 if postIndex > l { 9198 return io.ErrUnexpectedEOF 9199 } 9200 m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{}) 9201 if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9202 return err 9203 } 9204 iNdEx = postIndex 9205 case 3: 9206 if wireType != 2 { 9207 return fmt.Errorf("proto: wrong wireType = %d for field Egress", wireType) 9208 } 9209 var msglen int 9210 for shift := uint(0); ; shift += 7 { 9211 if shift >= 64 { 9212 return ErrIntOverflowGenerated 9213 } 9214 if iNdEx >= l { 9215 return io.ErrUnexpectedEOF 9216 } 9217 b := dAtA[iNdEx] 9218 iNdEx++ 9219 msglen |= (int(b) & 0x7F) << shift 9220 if b < 0x80 { 9221 break 9222 } 9223 } 9224 if msglen < 0 { 9225 return ErrInvalidLengthGenerated 9226 } 9227 postIndex := iNdEx + msglen 9228 if postIndex > l { 9229 return io.ErrUnexpectedEOF 9230 } 9231 m.Egress = append(m.Egress, NetworkPolicyEgressRule{}) 9232 if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9233 return err 9234 } 9235 iNdEx = postIndex 9236 case 4: 9237 if wireType != 2 { 9238 return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", wireType) 9239 } 9240 var stringLen uint64 9241 for shift := uint(0); ; shift += 7 { 9242 if shift >= 64 { 9243 return ErrIntOverflowGenerated 9244 } 9245 if iNdEx >= l { 9246 return io.ErrUnexpectedEOF 9247 } 9248 b := dAtA[iNdEx] 9249 iNdEx++ 9250 stringLen |= (uint64(b) & 0x7F) << shift 9251 if b < 0x80 { 9252 break 9253 } 9254 } 9255 intStringLen := int(stringLen) 9256 if intStringLen < 0 { 9257 return ErrInvalidLengthGenerated 9258 } 9259 postIndex := iNdEx + intStringLen 9260 if postIndex > l { 9261 return io.ErrUnexpectedEOF 9262 } 9263 m.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex])) 9264 iNdEx = postIndex 9265 default: 9266 iNdEx = preIndex 9267 skippy, err := skipGenerated(dAtA[iNdEx:]) 9268 if err != nil { 9269 return err 9270 } 9271 if skippy < 0 { 9272 return ErrInvalidLengthGenerated 9273 } 9274 if (iNdEx + skippy) > l { 9275 return io.ErrUnexpectedEOF 9276 } 9277 iNdEx += skippy 9278 } 9279 } 9280 9281 if iNdEx > l { 9282 return io.ErrUnexpectedEOF 9283 } 9284 return nil 9285} 9286func (m *PodSecurityPolicy) Unmarshal(dAtA []byte) error { 9287 l := len(dAtA) 9288 iNdEx := 0 9289 for iNdEx < l { 9290 preIndex := iNdEx 9291 var wire uint64 9292 for shift := uint(0); ; shift += 7 { 9293 if shift >= 64 { 9294 return ErrIntOverflowGenerated 9295 } 9296 if iNdEx >= l { 9297 return io.ErrUnexpectedEOF 9298 } 9299 b := dAtA[iNdEx] 9300 iNdEx++ 9301 wire |= (uint64(b) & 0x7F) << shift 9302 if b < 0x80 { 9303 break 9304 } 9305 } 9306 fieldNum := int32(wire >> 3) 9307 wireType := int(wire & 0x7) 9308 if wireType == 4 { 9309 return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group") 9310 } 9311 if fieldNum <= 0 { 9312 return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire) 9313 } 9314 switch fieldNum { 9315 case 1: 9316 if wireType != 2 { 9317 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 9318 } 9319 var msglen int 9320 for shift := uint(0); ; shift += 7 { 9321 if shift >= 64 { 9322 return ErrIntOverflowGenerated 9323 } 9324 if iNdEx >= l { 9325 return io.ErrUnexpectedEOF 9326 } 9327 b := dAtA[iNdEx] 9328 iNdEx++ 9329 msglen |= (int(b) & 0x7F) << shift 9330 if b < 0x80 { 9331 break 9332 } 9333 } 9334 if msglen < 0 { 9335 return ErrInvalidLengthGenerated 9336 } 9337 postIndex := iNdEx + msglen 9338 if postIndex > l { 9339 return io.ErrUnexpectedEOF 9340 } 9341 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9342 return err 9343 } 9344 iNdEx = postIndex 9345 case 2: 9346 if wireType != 2 { 9347 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 9348 } 9349 var msglen int 9350 for shift := uint(0); ; shift += 7 { 9351 if shift >= 64 { 9352 return ErrIntOverflowGenerated 9353 } 9354 if iNdEx >= l { 9355 return io.ErrUnexpectedEOF 9356 } 9357 b := dAtA[iNdEx] 9358 iNdEx++ 9359 msglen |= (int(b) & 0x7F) << shift 9360 if b < 0x80 { 9361 break 9362 } 9363 } 9364 if msglen < 0 { 9365 return ErrInvalidLengthGenerated 9366 } 9367 postIndex := iNdEx + msglen 9368 if postIndex > l { 9369 return io.ErrUnexpectedEOF 9370 } 9371 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9372 return err 9373 } 9374 iNdEx = postIndex 9375 default: 9376 iNdEx = preIndex 9377 skippy, err := skipGenerated(dAtA[iNdEx:]) 9378 if err != nil { 9379 return err 9380 } 9381 if skippy < 0 { 9382 return ErrInvalidLengthGenerated 9383 } 9384 if (iNdEx + skippy) > l { 9385 return io.ErrUnexpectedEOF 9386 } 9387 iNdEx += skippy 9388 } 9389 } 9390 9391 if iNdEx > l { 9392 return io.ErrUnexpectedEOF 9393 } 9394 return nil 9395} 9396func (m *PodSecurityPolicyList) Unmarshal(dAtA []byte) error { 9397 l := len(dAtA) 9398 iNdEx := 0 9399 for iNdEx < l { 9400 preIndex := iNdEx 9401 var wire uint64 9402 for shift := uint(0); ; shift += 7 { 9403 if shift >= 64 { 9404 return ErrIntOverflowGenerated 9405 } 9406 if iNdEx >= l { 9407 return io.ErrUnexpectedEOF 9408 } 9409 b := dAtA[iNdEx] 9410 iNdEx++ 9411 wire |= (uint64(b) & 0x7F) << shift 9412 if b < 0x80 { 9413 break 9414 } 9415 } 9416 fieldNum := int32(wire >> 3) 9417 wireType := int(wire & 0x7) 9418 if wireType == 4 { 9419 return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group") 9420 } 9421 if fieldNum <= 0 { 9422 return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire) 9423 } 9424 switch fieldNum { 9425 case 1: 9426 if wireType != 2 { 9427 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 9428 } 9429 var msglen int 9430 for shift := uint(0); ; shift += 7 { 9431 if shift >= 64 { 9432 return ErrIntOverflowGenerated 9433 } 9434 if iNdEx >= l { 9435 return io.ErrUnexpectedEOF 9436 } 9437 b := dAtA[iNdEx] 9438 iNdEx++ 9439 msglen |= (int(b) & 0x7F) << shift 9440 if b < 0x80 { 9441 break 9442 } 9443 } 9444 if msglen < 0 { 9445 return ErrInvalidLengthGenerated 9446 } 9447 postIndex := iNdEx + msglen 9448 if postIndex > l { 9449 return io.ErrUnexpectedEOF 9450 } 9451 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9452 return err 9453 } 9454 iNdEx = postIndex 9455 case 2: 9456 if wireType != 2 { 9457 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 9458 } 9459 var msglen int 9460 for shift := uint(0); ; shift += 7 { 9461 if shift >= 64 { 9462 return ErrIntOverflowGenerated 9463 } 9464 if iNdEx >= l { 9465 return io.ErrUnexpectedEOF 9466 } 9467 b := dAtA[iNdEx] 9468 iNdEx++ 9469 msglen |= (int(b) & 0x7F) << shift 9470 if b < 0x80 { 9471 break 9472 } 9473 } 9474 if msglen < 0 { 9475 return ErrInvalidLengthGenerated 9476 } 9477 postIndex := iNdEx + msglen 9478 if postIndex > l { 9479 return io.ErrUnexpectedEOF 9480 } 9481 m.Items = append(m.Items, PodSecurityPolicy{}) 9482 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9483 return err 9484 } 9485 iNdEx = postIndex 9486 default: 9487 iNdEx = preIndex 9488 skippy, err := skipGenerated(dAtA[iNdEx:]) 9489 if err != nil { 9490 return err 9491 } 9492 if skippy < 0 { 9493 return ErrInvalidLengthGenerated 9494 } 9495 if (iNdEx + skippy) > l { 9496 return io.ErrUnexpectedEOF 9497 } 9498 iNdEx += skippy 9499 } 9500 } 9501 9502 if iNdEx > l { 9503 return io.ErrUnexpectedEOF 9504 } 9505 return nil 9506} 9507func (m *PodSecurityPolicySpec) Unmarshal(dAtA []byte) error { 9508 l := len(dAtA) 9509 iNdEx := 0 9510 for iNdEx < l { 9511 preIndex := iNdEx 9512 var wire uint64 9513 for shift := uint(0); ; shift += 7 { 9514 if shift >= 64 { 9515 return ErrIntOverflowGenerated 9516 } 9517 if iNdEx >= l { 9518 return io.ErrUnexpectedEOF 9519 } 9520 b := dAtA[iNdEx] 9521 iNdEx++ 9522 wire |= (uint64(b) & 0x7F) << shift 9523 if b < 0x80 { 9524 break 9525 } 9526 } 9527 fieldNum := int32(wire >> 3) 9528 wireType := int(wire & 0x7) 9529 if wireType == 4 { 9530 return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group") 9531 } 9532 if fieldNum <= 0 { 9533 return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire) 9534 } 9535 switch fieldNum { 9536 case 1: 9537 if wireType != 0 { 9538 return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType) 9539 } 9540 var v int 9541 for shift := uint(0); ; shift += 7 { 9542 if shift >= 64 { 9543 return ErrIntOverflowGenerated 9544 } 9545 if iNdEx >= l { 9546 return io.ErrUnexpectedEOF 9547 } 9548 b := dAtA[iNdEx] 9549 iNdEx++ 9550 v |= (int(b) & 0x7F) << shift 9551 if b < 0x80 { 9552 break 9553 } 9554 } 9555 m.Privileged = bool(v != 0) 9556 case 2: 9557 if wireType != 2 { 9558 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType) 9559 } 9560 var stringLen uint64 9561 for shift := uint(0); ; shift += 7 { 9562 if shift >= 64 { 9563 return ErrIntOverflowGenerated 9564 } 9565 if iNdEx >= l { 9566 return io.ErrUnexpectedEOF 9567 } 9568 b := dAtA[iNdEx] 9569 iNdEx++ 9570 stringLen |= (uint64(b) & 0x7F) << shift 9571 if b < 0x80 { 9572 break 9573 } 9574 } 9575 intStringLen := int(stringLen) 9576 if intStringLen < 0 { 9577 return ErrInvalidLengthGenerated 9578 } 9579 postIndex := iNdEx + intStringLen 9580 if postIndex > l { 9581 return io.ErrUnexpectedEOF 9582 } 9583 m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) 9584 iNdEx = postIndex 9585 case 3: 9586 if wireType != 2 { 9587 return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType) 9588 } 9589 var stringLen uint64 9590 for shift := uint(0); ; shift += 7 { 9591 if shift >= 64 { 9592 return ErrIntOverflowGenerated 9593 } 9594 if iNdEx >= l { 9595 return io.ErrUnexpectedEOF 9596 } 9597 b := dAtA[iNdEx] 9598 iNdEx++ 9599 stringLen |= (uint64(b) & 0x7F) << shift 9600 if b < 0x80 { 9601 break 9602 } 9603 } 9604 intStringLen := int(stringLen) 9605 if intStringLen < 0 { 9606 return ErrInvalidLengthGenerated 9607 } 9608 postIndex := iNdEx + intStringLen 9609 if postIndex > l { 9610 return io.ErrUnexpectedEOF 9611 } 9612 m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) 9613 iNdEx = postIndex 9614 case 4: 9615 if wireType != 2 { 9616 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType) 9617 } 9618 var stringLen uint64 9619 for shift := uint(0); ; shift += 7 { 9620 if shift >= 64 { 9621 return ErrIntOverflowGenerated 9622 } 9623 if iNdEx >= l { 9624 return io.ErrUnexpectedEOF 9625 } 9626 b := dAtA[iNdEx] 9627 iNdEx++ 9628 stringLen |= (uint64(b) & 0x7F) << shift 9629 if b < 0x80 { 9630 break 9631 } 9632 } 9633 intStringLen := int(stringLen) 9634 if intStringLen < 0 { 9635 return ErrInvalidLengthGenerated 9636 } 9637 postIndex := iNdEx + intStringLen 9638 if postIndex > l { 9639 return io.ErrUnexpectedEOF 9640 } 9641 m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) 9642 iNdEx = postIndex 9643 case 5: 9644 if wireType != 2 { 9645 return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType) 9646 } 9647 var stringLen uint64 9648 for shift := uint(0); ; shift += 7 { 9649 if shift >= 64 { 9650 return ErrIntOverflowGenerated 9651 } 9652 if iNdEx >= l { 9653 return io.ErrUnexpectedEOF 9654 } 9655 b := dAtA[iNdEx] 9656 iNdEx++ 9657 stringLen |= (uint64(b) & 0x7F) << shift 9658 if b < 0x80 { 9659 break 9660 } 9661 } 9662 intStringLen := int(stringLen) 9663 if intStringLen < 0 { 9664 return ErrInvalidLengthGenerated 9665 } 9666 postIndex := iNdEx + intStringLen 9667 if postIndex > l { 9668 return io.ErrUnexpectedEOF 9669 } 9670 m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex])) 9671 iNdEx = postIndex 9672 case 6: 9673 if wireType != 0 { 9674 return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType) 9675 } 9676 var v int 9677 for shift := uint(0); ; shift += 7 { 9678 if shift >= 64 { 9679 return ErrIntOverflowGenerated 9680 } 9681 if iNdEx >= l { 9682 return io.ErrUnexpectedEOF 9683 } 9684 b := dAtA[iNdEx] 9685 iNdEx++ 9686 v |= (int(b) & 0x7F) << shift 9687 if b < 0x80 { 9688 break 9689 } 9690 } 9691 m.HostNetwork = bool(v != 0) 9692 case 7: 9693 if wireType != 2 { 9694 return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType) 9695 } 9696 var msglen int 9697 for shift := uint(0); ; shift += 7 { 9698 if shift >= 64 { 9699 return ErrIntOverflowGenerated 9700 } 9701 if iNdEx >= l { 9702 return io.ErrUnexpectedEOF 9703 } 9704 b := dAtA[iNdEx] 9705 iNdEx++ 9706 msglen |= (int(b) & 0x7F) << shift 9707 if b < 0x80 { 9708 break 9709 } 9710 } 9711 if msglen < 0 { 9712 return ErrInvalidLengthGenerated 9713 } 9714 postIndex := iNdEx + msglen 9715 if postIndex > l { 9716 return io.ErrUnexpectedEOF 9717 } 9718 m.HostPorts = append(m.HostPorts, HostPortRange{}) 9719 if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9720 return err 9721 } 9722 iNdEx = postIndex 9723 case 8: 9724 if wireType != 0 { 9725 return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType) 9726 } 9727 var v int 9728 for shift := uint(0); ; shift += 7 { 9729 if shift >= 64 { 9730 return ErrIntOverflowGenerated 9731 } 9732 if iNdEx >= l { 9733 return io.ErrUnexpectedEOF 9734 } 9735 b := dAtA[iNdEx] 9736 iNdEx++ 9737 v |= (int(b) & 0x7F) << shift 9738 if b < 0x80 { 9739 break 9740 } 9741 } 9742 m.HostPID = bool(v != 0) 9743 case 9: 9744 if wireType != 0 { 9745 return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType) 9746 } 9747 var v int 9748 for shift := uint(0); ; shift += 7 { 9749 if shift >= 64 { 9750 return ErrIntOverflowGenerated 9751 } 9752 if iNdEx >= l { 9753 return io.ErrUnexpectedEOF 9754 } 9755 b := dAtA[iNdEx] 9756 iNdEx++ 9757 v |= (int(b) & 0x7F) << shift 9758 if b < 0x80 { 9759 break 9760 } 9761 } 9762 m.HostIPC = bool(v != 0) 9763 case 10: 9764 if wireType != 2 { 9765 return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType) 9766 } 9767 var msglen int 9768 for shift := uint(0); ; shift += 7 { 9769 if shift >= 64 { 9770 return ErrIntOverflowGenerated 9771 } 9772 if iNdEx >= l { 9773 return io.ErrUnexpectedEOF 9774 } 9775 b := dAtA[iNdEx] 9776 iNdEx++ 9777 msglen |= (int(b) & 0x7F) << shift 9778 if b < 0x80 { 9779 break 9780 } 9781 } 9782 if msglen < 0 { 9783 return ErrInvalidLengthGenerated 9784 } 9785 postIndex := iNdEx + msglen 9786 if postIndex > l { 9787 return io.ErrUnexpectedEOF 9788 } 9789 if err := m.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9790 return err 9791 } 9792 iNdEx = postIndex 9793 case 11: 9794 if wireType != 2 { 9795 return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType) 9796 } 9797 var msglen int 9798 for shift := uint(0); ; shift += 7 { 9799 if shift >= 64 { 9800 return ErrIntOverflowGenerated 9801 } 9802 if iNdEx >= l { 9803 return io.ErrUnexpectedEOF 9804 } 9805 b := dAtA[iNdEx] 9806 iNdEx++ 9807 msglen |= (int(b) & 0x7F) << shift 9808 if b < 0x80 { 9809 break 9810 } 9811 } 9812 if msglen < 0 { 9813 return ErrInvalidLengthGenerated 9814 } 9815 postIndex := iNdEx + msglen 9816 if postIndex > l { 9817 return io.ErrUnexpectedEOF 9818 } 9819 if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9820 return err 9821 } 9822 iNdEx = postIndex 9823 case 12: 9824 if wireType != 2 { 9825 return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType) 9826 } 9827 var msglen int 9828 for shift := uint(0); ; shift += 7 { 9829 if shift >= 64 { 9830 return ErrIntOverflowGenerated 9831 } 9832 if iNdEx >= l { 9833 return io.ErrUnexpectedEOF 9834 } 9835 b := dAtA[iNdEx] 9836 iNdEx++ 9837 msglen |= (int(b) & 0x7F) << shift 9838 if b < 0x80 { 9839 break 9840 } 9841 } 9842 if msglen < 0 { 9843 return ErrInvalidLengthGenerated 9844 } 9845 postIndex := iNdEx + msglen 9846 if postIndex > l { 9847 return io.ErrUnexpectedEOF 9848 } 9849 if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9850 return err 9851 } 9852 iNdEx = postIndex 9853 case 13: 9854 if wireType != 2 { 9855 return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType) 9856 } 9857 var msglen int 9858 for shift := uint(0); ; shift += 7 { 9859 if shift >= 64 { 9860 return ErrIntOverflowGenerated 9861 } 9862 if iNdEx >= l { 9863 return io.ErrUnexpectedEOF 9864 } 9865 b := dAtA[iNdEx] 9866 iNdEx++ 9867 msglen |= (int(b) & 0x7F) << shift 9868 if b < 0x80 { 9869 break 9870 } 9871 } 9872 if msglen < 0 { 9873 return ErrInvalidLengthGenerated 9874 } 9875 postIndex := iNdEx + msglen 9876 if postIndex > l { 9877 return io.ErrUnexpectedEOF 9878 } 9879 if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9880 return err 9881 } 9882 iNdEx = postIndex 9883 case 14: 9884 if wireType != 0 { 9885 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType) 9886 } 9887 var v int 9888 for shift := uint(0); ; shift += 7 { 9889 if shift >= 64 { 9890 return ErrIntOverflowGenerated 9891 } 9892 if iNdEx >= l { 9893 return io.ErrUnexpectedEOF 9894 } 9895 b := dAtA[iNdEx] 9896 iNdEx++ 9897 v |= (int(b) & 0x7F) << shift 9898 if b < 0x80 { 9899 break 9900 } 9901 } 9902 m.ReadOnlyRootFilesystem = bool(v != 0) 9903 case 15: 9904 if wireType != 0 { 9905 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType) 9906 } 9907 var v int 9908 for shift := uint(0); ; shift += 7 { 9909 if shift >= 64 { 9910 return ErrIntOverflowGenerated 9911 } 9912 if iNdEx >= l { 9913 return io.ErrUnexpectedEOF 9914 } 9915 b := dAtA[iNdEx] 9916 iNdEx++ 9917 v |= (int(b) & 0x7F) << shift 9918 if b < 0x80 { 9919 break 9920 } 9921 } 9922 b := bool(v != 0) 9923 m.DefaultAllowPrivilegeEscalation = &b 9924 case 16: 9925 if wireType != 0 { 9926 return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType) 9927 } 9928 var v int 9929 for shift := uint(0); ; shift += 7 { 9930 if shift >= 64 { 9931 return ErrIntOverflowGenerated 9932 } 9933 if iNdEx >= l { 9934 return io.ErrUnexpectedEOF 9935 } 9936 b := dAtA[iNdEx] 9937 iNdEx++ 9938 v |= (int(b) & 0x7F) << shift 9939 if b < 0x80 { 9940 break 9941 } 9942 } 9943 b := bool(v != 0) 9944 m.AllowPrivilegeEscalation = &b 9945 case 17: 9946 if wireType != 2 { 9947 return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", wireType) 9948 } 9949 var msglen int 9950 for shift := uint(0); ; shift += 7 { 9951 if shift >= 64 { 9952 return ErrIntOverflowGenerated 9953 } 9954 if iNdEx >= l { 9955 return io.ErrUnexpectedEOF 9956 } 9957 b := dAtA[iNdEx] 9958 iNdEx++ 9959 msglen |= (int(b) & 0x7F) << shift 9960 if b < 0x80 { 9961 break 9962 } 9963 } 9964 if msglen < 0 { 9965 return ErrInvalidLengthGenerated 9966 } 9967 postIndex := iNdEx + msglen 9968 if postIndex > l { 9969 return io.ErrUnexpectedEOF 9970 } 9971 m.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{}) 9972 if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9973 return err 9974 } 9975 iNdEx = postIndex 9976 case 18: 9977 if wireType != 2 { 9978 return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType) 9979 } 9980 var msglen int 9981 for shift := uint(0); ; shift += 7 { 9982 if shift >= 64 { 9983 return ErrIntOverflowGenerated 9984 } 9985 if iNdEx >= l { 9986 return io.ErrUnexpectedEOF 9987 } 9988 b := dAtA[iNdEx] 9989 iNdEx++ 9990 msglen |= (int(b) & 0x7F) << shift 9991 if b < 0x80 { 9992 break 9993 } 9994 } 9995 if msglen < 0 { 9996 return ErrInvalidLengthGenerated 9997 } 9998 postIndex := iNdEx + msglen 9999 if postIndex > l { 10000 return io.ErrUnexpectedEOF 10001 } 10002 m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{}) 10003 if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10004 return err 10005 } 10006 iNdEx = postIndex 10007 case 19: 10008 if wireType != 2 { 10009 return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType) 10010 } 10011 var stringLen uint64 10012 for shift := uint(0); ; shift += 7 { 10013 if shift >= 64 { 10014 return ErrIntOverflowGenerated 10015 } 10016 if iNdEx >= l { 10017 return io.ErrUnexpectedEOF 10018 } 10019 b := dAtA[iNdEx] 10020 iNdEx++ 10021 stringLen |= (uint64(b) & 0x7F) << shift 10022 if b < 0x80 { 10023 break 10024 } 10025 } 10026 intStringLen := int(stringLen) 10027 if intStringLen < 0 { 10028 return ErrInvalidLengthGenerated 10029 } 10030 postIndex := iNdEx + intStringLen 10031 if postIndex > l { 10032 return io.ErrUnexpectedEOF 10033 } 10034 m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex])) 10035 iNdEx = postIndex 10036 case 20: 10037 if wireType != 2 { 10038 return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType) 10039 } 10040 var stringLen uint64 10041 for shift := uint(0); ; shift += 7 { 10042 if shift >= 64 { 10043 return ErrIntOverflowGenerated 10044 } 10045 if iNdEx >= l { 10046 return io.ErrUnexpectedEOF 10047 } 10048 b := dAtA[iNdEx] 10049 iNdEx++ 10050 stringLen |= (uint64(b) & 0x7F) << shift 10051 if b < 0x80 { 10052 break 10053 } 10054 } 10055 intStringLen := int(stringLen) 10056 if intStringLen < 0 { 10057 return ErrInvalidLengthGenerated 10058 } 10059 postIndex := iNdEx + intStringLen 10060 if postIndex > l { 10061 return io.ErrUnexpectedEOF 10062 } 10063 m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex])) 10064 iNdEx = postIndex 10065 case 21: 10066 if wireType != 2 { 10067 return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", wireType) 10068 } 10069 var stringLen uint64 10070 for shift := uint(0); ; shift += 7 { 10071 if shift >= 64 { 10072 return ErrIntOverflowGenerated 10073 } 10074 if iNdEx >= l { 10075 return io.ErrUnexpectedEOF 10076 } 10077 b := dAtA[iNdEx] 10078 iNdEx++ 10079 stringLen |= (uint64(b) & 0x7F) << shift 10080 if b < 0x80 { 10081 break 10082 } 10083 } 10084 intStringLen := int(stringLen) 10085 if intStringLen < 0 { 10086 return ErrInvalidLengthGenerated 10087 } 10088 postIndex := iNdEx + intStringLen 10089 if postIndex > l { 10090 return io.ErrUnexpectedEOF 10091 } 10092 m.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex])) 10093 iNdEx = postIndex 10094 case 22: 10095 if wireType != 2 { 10096 return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", wireType) 10097 } 10098 var msglen int 10099 for shift := uint(0); ; shift += 7 { 10100 if shift >= 64 { 10101 return ErrIntOverflowGenerated 10102 } 10103 if iNdEx >= l { 10104 return io.ErrUnexpectedEOF 10105 } 10106 b := dAtA[iNdEx] 10107 iNdEx++ 10108 msglen |= (int(b) & 0x7F) << shift 10109 if b < 0x80 { 10110 break 10111 } 10112 } 10113 if msglen < 0 { 10114 return ErrInvalidLengthGenerated 10115 } 10116 postIndex := iNdEx + msglen 10117 if postIndex > l { 10118 return io.ErrUnexpectedEOF 10119 } 10120 if m.RunAsGroup == nil { 10121 m.RunAsGroup = &RunAsGroupStrategyOptions{} 10122 } 10123 if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10124 return err 10125 } 10126 iNdEx = postIndex 10127 case 23: 10128 if wireType != 2 { 10129 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCSIDrivers", wireType) 10130 } 10131 var msglen int 10132 for shift := uint(0); ; shift += 7 { 10133 if shift >= 64 { 10134 return ErrIntOverflowGenerated 10135 } 10136 if iNdEx >= l { 10137 return io.ErrUnexpectedEOF 10138 } 10139 b := dAtA[iNdEx] 10140 iNdEx++ 10141 msglen |= (int(b) & 0x7F) << shift 10142 if b < 0x80 { 10143 break 10144 } 10145 } 10146 if msglen < 0 { 10147 return ErrInvalidLengthGenerated 10148 } 10149 postIndex := iNdEx + msglen 10150 if postIndex > l { 10151 return io.ErrUnexpectedEOF 10152 } 10153 m.AllowedCSIDrivers = append(m.AllowedCSIDrivers, AllowedCSIDriver{}) 10154 if err := m.AllowedCSIDrivers[len(m.AllowedCSIDrivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10155 return err 10156 } 10157 iNdEx = postIndex 10158 default: 10159 iNdEx = preIndex 10160 skippy, err := skipGenerated(dAtA[iNdEx:]) 10161 if err != nil { 10162 return err 10163 } 10164 if skippy < 0 { 10165 return ErrInvalidLengthGenerated 10166 } 10167 if (iNdEx + skippy) > l { 10168 return io.ErrUnexpectedEOF 10169 } 10170 iNdEx += skippy 10171 } 10172 } 10173 10174 if iNdEx > l { 10175 return io.ErrUnexpectedEOF 10176 } 10177 return nil 10178} 10179func (m *ReplicaSet) Unmarshal(dAtA []byte) error { 10180 l := len(dAtA) 10181 iNdEx := 0 10182 for iNdEx < l { 10183 preIndex := iNdEx 10184 var wire uint64 10185 for shift := uint(0); ; shift += 7 { 10186 if shift >= 64 { 10187 return ErrIntOverflowGenerated 10188 } 10189 if iNdEx >= l { 10190 return io.ErrUnexpectedEOF 10191 } 10192 b := dAtA[iNdEx] 10193 iNdEx++ 10194 wire |= (uint64(b) & 0x7F) << shift 10195 if b < 0x80 { 10196 break 10197 } 10198 } 10199 fieldNum := int32(wire >> 3) 10200 wireType := int(wire & 0x7) 10201 if wireType == 4 { 10202 return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group") 10203 } 10204 if fieldNum <= 0 { 10205 return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire) 10206 } 10207 switch fieldNum { 10208 case 1: 10209 if wireType != 2 { 10210 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 10211 } 10212 var msglen int 10213 for shift := uint(0); ; shift += 7 { 10214 if shift >= 64 { 10215 return ErrIntOverflowGenerated 10216 } 10217 if iNdEx >= l { 10218 return io.ErrUnexpectedEOF 10219 } 10220 b := dAtA[iNdEx] 10221 iNdEx++ 10222 msglen |= (int(b) & 0x7F) << shift 10223 if b < 0x80 { 10224 break 10225 } 10226 } 10227 if msglen < 0 { 10228 return ErrInvalidLengthGenerated 10229 } 10230 postIndex := iNdEx + msglen 10231 if postIndex > l { 10232 return io.ErrUnexpectedEOF 10233 } 10234 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10235 return err 10236 } 10237 iNdEx = postIndex 10238 case 2: 10239 if wireType != 2 { 10240 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 10241 } 10242 var msglen int 10243 for shift := uint(0); ; shift += 7 { 10244 if shift >= 64 { 10245 return ErrIntOverflowGenerated 10246 } 10247 if iNdEx >= l { 10248 return io.ErrUnexpectedEOF 10249 } 10250 b := dAtA[iNdEx] 10251 iNdEx++ 10252 msglen |= (int(b) & 0x7F) << shift 10253 if b < 0x80 { 10254 break 10255 } 10256 } 10257 if msglen < 0 { 10258 return ErrInvalidLengthGenerated 10259 } 10260 postIndex := iNdEx + msglen 10261 if postIndex > l { 10262 return io.ErrUnexpectedEOF 10263 } 10264 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10265 return err 10266 } 10267 iNdEx = postIndex 10268 case 3: 10269 if wireType != 2 { 10270 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 10271 } 10272 var msglen int 10273 for shift := uint(0); ; shift += 7 { 10274 if shift >= 64 { 10275 return ErrIntOverflowGenerated 10276 } 10277 if iNdEx >= l { 10278 return io.ErrUnexpectedEOF 10279 } 10280 b := dAtA[iNdEx] 10281 iNdEx++ 10282 msglen |= (int(b) & 0x7F) << shift 10283 if b < 0x80 { 10284 break 10285 } 10286 } 10287 if msglen < 0 { 10288 return ErrInvalidLengthGenerated 10289 } 10290 postIndex := iNdEx + msglen 10291 if postIndex > l { 10292 return io.ErrUnexpectedEOF 10293 } 10294 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10295 return err 10296 } 10297 iNdEx = postIndex 10298 default: 10299 iNdEx = preIndex 10300 skippy, err := skipGenerated(dAtA[iNdEx:]) 10301 if err != nil { 10302 return err 10303 } 10304 if skippy < 0 { 10305 return ErrInvalidLengthGenerated 10306 } 10307 if (iNdEx + skippy) > l { 10308 return io.ErrUnexpectedEOF 10309 } 10310 iNdEx += skippy 10311 } 10312 } 10313 10314 if iNdEx > l { 10315 return io.ErrUnexpectedEOF 10316 } 10317 return nil 10318} 10319func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error { 10320 l := len(dAtA) 10321 iNdEx := 0 10322 for iNdEx < l { 10323 preIndex := iNdEx 10324 var wire uint64 10325 for shift := uint(0); ; shift += 7 { 10326 if shift >= 64 { 10327 return ErrIntOverflowGenerated 10328 } 10329 if iNdEx >= l { 10330 return io.ErrUnexpectedEOF 10331 } 10332 b := dAtA[iNdEx] 10333 iNdEx++ 10334 wire |= (uint64(b) & 0x7F) << shift 10335 if b < 0x80 { 10336 break 10337 } 10338 } 10339 fieldNum := int32(wire >> 3) 10340 wireType := int(wire & 0x7) 10341 if wireType == 4 { 10342 return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group") 10343 } 10344 if fieldNum <= 0 { 10345 return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) 10346 } 10347 switch fieldNum { 10348 case 1: 10349 if wireType != 2 { 10350 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 10351 } 10352 var stringLen uint64 10353 for shift := uint(0); ; shift += 7 { 10354 if shift >= 64 { 10355 return ErrIntOverflowGenerated 10356 } 10357 if iNdEx >= l { 10358 return io.ErrUnexpectedEOF 10359 } 10360 b := dAtA[iNdEx] 10361 iNdEx++ 10362 stringLen |= (uint64(b) & 0x7F) << shift 10363 if b < 0x80 { 10364 break 10365 } 10366 } 10367 intStringLen := int(stringLen) 10368 if intStringLen < 0 { 10369 return ErrInvalidLengthGenerated 10370 } 10371 postIndex := iNdEx + intStringLen 10372 if postIndex > l { 10373 return io.ErrUnexpectedEOF 10374 } 10375 m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex]) 10376 iNdEx = postIndex 10377 case 2: 10378 if wireType != 2 { 10379 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 10380 } 10381 var stringLen uint64 10382 for shift := uint(0); ; shift += 7 { 10383 if shift >= 64 { 10384 return ErrIntOverflowGenerated 10385 } 10386 if iNdEx >= l { 10387 return io.ErrUnexpectedEOF 10388 } 10389 b := dAtA[iNdEx] 10390 iNdEx++ 10391 stringLen |= (uint64(b) & 0x7F) << shift 10392 if b < 0x80 { 10393 break 10394 } 10395 } 10396 intStringLen := int(stringLen) 10397 if intStringLen < 0 { 10398 return ErrInvalidLengthGenerated 10399 } 10400 postIndex := iNdEx + intStringLen 10401 if postIndex > l { 10402 return io.ErrUnexpectedEOF 10403 } 10404 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) 10405 iNdEx = postIndex 10406 case 3: 10407 if wireType != 2 { 10408 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) 10409 } 10410 var msglen int 10411 for shift := uint(0); ; shift += 7 { 10412 if shift >= 64 { 10413 return ErrIntOverflowGenerated 10414 } 10415 if iNdEx >= l { 10416 return io.ErrUnexpectedEOF 10417 } 10418 b := dAtA[iNdEx] 10419 iNdEx++ 10420 msglen |= (int(b) & 0x7F) << shift 10421 if b < 0x80 { 10422 break 10423 } 10424 } 10425 if msglen < 0 { 10426 return ErrInvalidLengthGenerated 10427 } 10428 postIndex := iNdEx + msglen 10429 if postIndex > l { 10430 return io.ErrUnexpectedEOF 10431 } 10432 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10433 return err 10434 } 10435 iNdEx = postIndex 10436 case 4: 10437 if wireType != 2 { 10438 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) 10439 } 10440 var stringLen uint64 10441 for shift := uint(0); ; shift += 7 { 10442 if shift >= 64 { 10443 return ErrIntOverflowGenerated 10444 } 10445 if iNdEx >= l { 10446 return io.ErrUnexpectedEOF 10447 } 10448 b := dAtA[iNdEx] 10449 iNdEx++ 10450 stringLen |= (uint64(b) & 0x7F) << shift 10451 if b < 0x80 { 10452 break 10453 } 10454 } 10455 intStringLen := int(stringLen) 10456 if intStringLen < 0 { 10457 return ErrInvalidLengthGenerated 10458 } 10459 postIndex := iNdEx + intStringLen 10460 if postIndex > l { 10461 return io.ErrUnexpectedEOF 10462 } 10463 m.Reason = string(dAtA[iNdEx:postIndex]) 10464 iNdEx = postIndex 10465 case 5: 10466 if wireType != 2 { 10467 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 10468 } 10469 var stringLen uint64 10470 for shift := uint(0); ; shift += 7 { 10471 if shift >= 64 { 10472 return ErrIntOverflowGenerated 10473 } 10474 if iNdEx >= l { 10475 return io.ErrUnexpectedEOF 10476 } 10477 b := dAtA[iNdEx] 10478 iNdEx++ 10479 stringLen |= (uint64(b) & 0x7F) << shift 10480 if b < 0x80 { 10481 break 10482 } 10483 } 10484 intStringLen := int(stringLen) 10485 if intStringLen < 0 { 10486 return ErrInvalidLengthGenerated 10487 } 10488 postIndex := iNdEx + intStringLen 10489 if postIndex > l { 10490 return io.ErrUnexpectedEOF 10491 } 10492 m.Message = string(dAtA[iNdEx:postIndex]) 10493 iNdEx = postIndex 10494 default: 10495 iNdEx = preIndex 10496 skippy, err := skipGenerated(dAtA[iNdEx:]) 10497 if err != nil { 10498 return err 10499 } 10500 if skippy < 0 { 10501 return ErrInvalidLengthGenerated 10502 } 10503 if (iNdEx + skippy) > l { 10504 return io.ErrUnexpectedEOF 10505 } 10506 iNdEx += skippy 10507 } 10508 } 10509 10510 if iNdEx > l { 10511 return io.ErrUnexpectedEOF 10512 } 10513 return nil 10514} 10515func (m *ReplicaSetList) Unmarshal(dAtA []byte) error { 10516 l := len(dAtA) 10517 iNdEx := 0 10518 for iNdEx < l { 10519 preIndex := iNdEx 10520 var wire uint64 10521 for shift := uint(0); ; shift += 7 { 10522 if shift >= 64 { 10523 return ErrIntOverflowGenerated 10524 } 10525 if iNdEx >= l { 10526 return io.ErrUnexpectedEOF 10527 } 10528 b := dAtA[iNdEx] 10529 iNdEx++ 10530 wire |= (uint64(b) & 0x7F) << shift 10531 if b < 0x80 { 10532 break 10533 } 10534 } 10535 fieldNum := int32(wire >> 3) 10536 wireType := int(wire & 0x7) 10537 if wireType == 4 { 10538 return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group") 10539 } 10540 if fieldNum <= 0 { 10541 return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire) 10542 } 10543 switch fieldNum { 10544 case 1: 10545 if wireType != 2 { 10546 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 10547 } 10548 var msglen int 10549 for shift := uint(0); ; shift += 7 { 10550 if shift >= 64 { 10551 return ErrIntOverflowGenerated 10552 } 10553 if iNdEx >= l { 10554 return io.ErrUnexpectedEOF 10555 } 10556 b := dAtA[iNdEx] 10557 iNdEx++ 10558 msglen |= (int(b) & 0x7F) << shift 10559 if b < 0x80 { 10560 break 10561 } 10562 } 10563 if msglen < 0 { 10564 return ErrInvalidLengthGenerated 10565 } 10566 postIndex := iNdEx + msglen 10567 if postIndex > l { 10568 return io.ErrUnexpectedEOF 10569 } 10570 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10571 return err 10572 } 10573 iNdEx = postIndex 10574 case 2: 10575 if wireType != 2 { 10576 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 10577 } 10578 var msglen int 10579 for shift := uint(0); ; shift += 7 { 10580 if shift >= 64 { 10581 return ErrIntOverflowGenerated 10582 } 10583 if iNdEx >= l { 10584 return io.ErrUnexpectedEOF 10585 } 10586 b := dAtA[iNdEx] 10587 iNdEx++ 10588 msglen |= (int(b) & 0x7F) << shift 10589 if b < 0x80 { 10590 break 10591 } 10592 } 10593 if msglen < 0 { 10594 return ErrInvalidLengthGenerated 10595 } 10596 postIndex := iNdEx + msglen 10597 if postIndex > l { 10598 return io.ErrUnexpectedEOF 10599 } 10600 m.Items = append(m.Items, ReplicaSet{}) 10601 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10602 return err 10603 } 10604 iNdEx = postIndex 10605 default: 10606 iNdEx = preIndex 10607 skippy, err := skipGenerated(dAtA[iNdEx:]) 10608 if err != nil { 10609 return err 10610 } 10611 if skippy < 0 { 10612 return ErrInvalidLengthGenerated 10613 } 10614 if (iNdEx + skippy) > l { 10615 return io.ErrUnexpectedEOF 10616 } 10617 iNdEx += skippy 10618 } 10619 } 10620 10621 if iNdEx > l { 10622 return io.ErrUnexpectedEOF 10623 } 10624 return nil 10625} 10626func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error { 10627 l := len(dAtA) 10628 iNdEx := 0 10629 for iNdEx < l { 10630 preIndex := iNdEx 10631 var wire uint64 10632 for shift := uint(0); ; shift += 7 { 10633 if shift >= 64 { 10634 return ErrIntOverflowGenerated 10635 } 10636 if iNdEx >= l { 10637 return io.ErrUnexpectedEOF 10638 } 10639 b := dAtA[iNdEx] 10640 iNdEx++ 10641 wire |= (uint64(b) & 0x7F) << shift 10642 if b < 0x80 { 10643 break 10644 } 10645 } 10646 fieldNum := int32(wire >> 3) 10647 wireType := int(wire & 0x7) 10648 if wireType == 4 { 10649 return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group") 10650 } 10651 if fieldNum <= 0 { 10652 return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) 10653 } 10654 switch fieldNum { 10655 case 1: 10656 if wireType != 0 { 10657 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 10658 } 10659 var v int32 10660 for shift := uint(0); ; shift += 7 { 10661 if shift >= 64 { 10662 return ErrIntOverflowGenerated 10663 } 10664 if iNdEx >= l { 10665 return io.ErrUnexpectedEOF 10666 } 10667 b := dAtA[iNdEx] 10668 iNdEx++ 10669 v |= (int32(b) & 0x7F) << shift 10670 if b < 0x80 { 10671 break 10672 } 10673 } 10674 m.Replicas = &v 10675 case 2: 10676 if wireType != 2 { 10677 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 10678 } 10679 var msglen int 10680 for shift := uint(0); ; shift += 7 { 10681 if shift >= 64 { 10682 return ErrIntOverflowGenerated 10683 } 10684 if iNdEx >= l { 10685 return io.ErrUnexpectedEOF 10686 } 10687 b := dAtA[iNdEx] 10688 iNdEx++ 10689 msglen |= (int(b) & 0x7F) << shift 10690 if b < 0x80 { 10691 break 10692 } 10693 } 10694 if msglen < 0 { 10695 return ErrInvalidLengthGenerated 10696 } 10697 postIndex := iNdEx + msglen 10698 if postIndex > l { 10699 return io.ErrUnexpectedEOF 10700 } 10701 if m.Selector == nil { 10702 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 10703 } 10704 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10705 return err 10706 } 10707 iNdEx = postIndex 10708 case 3: 10709 if wireType != 2 { 10710 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) 10711 } 10712 var msglen int 10713 for shift := uint(0); ; shift += 7 { 10714 if shift >= 64 { 10715 return ErrIntOverflowGenerated 10716 } 10717 if iNdEx >= l { 10718 return io.ErrUnexpectedEOF 10719 } 10720 b := dAtA[iNdEx] 10721 iNdEx++ 10722 msglen |= (int(b) & 0x7F) << shift 10723 if b < 0x80 { 10724 break 10725 } 10726 } 10727 if msglen < 0 { 10728 return ErrInvalidLengthGenerated 10729 } 10730 postIndex := iNdEx + msglen 10731 if postIndex > l { 10732 return io.ErrUnexpectedEOF 10733 } 10734 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10735 return err 10736 } 10737 iNdEx = postIndex 10738 case 4: 10739 if wireType != 0 { 10740 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) 10741 } 10742 m.MinReadySeconds = 0 10743 for shift := uint(0); ; shift += 7 { 10744 if shift >= 64 { 10745 return ErrIntOverflowGenerated 10746 } 10747 if iNdEx >= l { 10748 return io.ErrUnexpectedEOF 10749 } 10750 b := dAtA[iNdEx] 10751 iNdEx++ 10752 m.MinReadySeconds |= (int32(b) & 0x7F) << shift 10753 if b < 0x80 { 10754 break 10755 } 10756 } 10757 default: 10758 iNdEx = preIndex 10759 skippy, err := skipGenerated(dAtA[iNdEx:]) 10760 if err != nil { 10761 return err 10762 } 10763 if skippy < 0 { 10764 return ErrInvalidLengthGenerated 10765 } 10766 if (iNdEx + skippy) > l { 10767 return io.ErrUnexpectedEOF 10768 } 10769 iNdEx += skippy 10770 } 10771 } 10772 10773 if iNdEx > l { 10774 return io.ErrUnexpectedEOF 10775 } 10776 return nil 10777} 10778func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error { 10779 l := len(dAtA) 10780 iNdEx := 0 10781 for iNdEx < l { 10782 preIndex := iNdEx 10783 var wire uint64 10784 for shift := uint(0); ; shift += 7 { 10785 if shift >= 64 { 10786 return ErrIntOverflowGenerated 10787 } 10788 if iNdEx >= l { 10789 return io.ErrUnexpectedEOF 10790 } 10791 b := dAtA[iNdEx] 10792 iNdEx++ 10793 wire |= (uint64(b) & 0x7F) << shift 10794 if b < 0x80 { 10795 break 10796 } 10797 } 10798 fieldNum := int32(wire >> 3) 10799 wireType := int(wire & 0x7) 10800 if wireType == 4 { 10801 return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group") 10802 } 10803 if fieldNum <= 0 { 10804 return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) 10805 } 10806 switch fieldNum { 10807 case 1: 10808 if wireType != 0 { 10809 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 10810 } 10811 m.Replicas = 0 10812 for shift := uint(0); ; shift += 7 { 10813 if shift >= 64 { 10814 return ErrIntOverflowGenerated 10815 } 10816 if iNdEx >= l { 10817 return io.ErrUnexpectedEOF 10818 } 10819 b := dAtA[iNdEx] 10820 iNdEx++ 10821 m.Replicas |= (int32(b) & 0x7F) << shift 10822 if b < 0x80 { 10823 break 10824 } 10825 } 10826 case 2: 10827 if wireType != 0 { 10828 return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType) 10829 } 10830 m.FullyLabeledReplicas = 0 10831 for shift := uint(0); ; shift += 7 { 10832 if shift >= 64 { 10833 return ErrIntOverflowGenerated 10834 } 10835 if iNdEx >= l { 10836 return io.ErrUnexpectedEOF 10837 } 10838 b := dAtA[iNdEx] 10839 iNdEx++ 10840 m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift 10841 if b < 0x80 { 10842 break 10843 } 10844 } 10845 case 3: 10846 if wireType != 0 { 10847 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) 10848 } 10849 m.ObservedGeneration = 0 10850 for shift := uint(0); ; shift += 7 { 10851 if shift >= 64 { 10852 return ErrIntOverflowGenerated 10853 } 10854 if iNdEx >= l { 10855 return io.ErrUnexpectedEOF 10856 } 10857 b := dAtA[iNdEx] 10858 iNdEx++ 10859 m.ObservedGeneration |= (int64(b) & 0x7F) << shift 10860 if b < 0x80 { 10861 break 10862 } 10863 } 10864 case 4: 10865 if wireType != 0 { 10866 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) 10867 } 10868 m.ReadyReplicas = 0 10869 for shift := uint(0); ; shift += 7 { 10870 if shift >= 64 { 10871 return ErrIntOverflowGenerated 10872 } 10873 if iNdEx >= l { 10874 return io.ErrUnexpectedEOF 10875 } 10876 b := dAtA[iNdEx] 10877 iNdEx++ 10878 m.ReadyReplicas |= (int32(b) & 0x7F) << shift 10879 if b < 0x80 { 10880 break 10881 } 10882 } 10883 case 5: 10884 if wireType != 0 { 10885 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) 10886 } 10887 m.AvailableReplicas = 0 10888 for shift := uint(0); ; shift += 7 { 10889 if shift >= 64 { 10890 return ErrIntOverflowGenerated 10891 } 10892 if iNdEx >= l { 10893 return io.ErrUnexpectedEOF 10894 } 10895 b := dAtA[iNdEx] 10896 iNdEx++ 10897 m.AvailableReplicas |= (int32(b) & 0x7F) << shift 10898 if b < 0x80 { 10899 break 10900 } 10901 } 10902 case 6: 10903 if wireType != 2 { 10904 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 10905 } 10906 var msglen int 10907 for shift := uint(0); ; shift += 7 { 10908 if shift >= 64 { 10909 return ErrIntOverflowGenerated 10910 } 10911 if iNdEx >= l { 10912 return io.ErrUnexpectedEOF 10913 } 10914 b := dAtA[iNdEx] 10915 iNdEx++ 10916 msglen |= (int(b) & 0x7F) << shift 10917 if b < 0x80 { 10918 break 10919 } 10920 } 10921 if msglen < 0 { 10922 return ErrInvalidLengthGenerated 10923 } 10924 postIndex := iNdEx + msglen 10925 if postIndex > l { 10926 return io.ErrUnexpectedEOF 10927 } 10928 m.Conditions = append(m.Conditions, ReplicaSetCondition{}) 10929 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10930 return err 10931 } 10932 iNdEx = postIndex 10933 default: 10934 iNdEx = preIndex 10935 skippy, err := skipGenerated(dAtA[iNdEx:]) 10936 if err != nil { 10937 return err 10938 } 10939 if skippy < 0 { 10940 return ErrInvalidLengthGenerated 10941 } 10942 if (iNdEx + skippy) > l { 10943 return io.ErrUnexpectedEOF 10944 } 10945 iNdEx += skippy 10946 } 10947 } 10948 10949 if iNdEx > l { 10950 return io.ErrUnexpectedEOF 10951 } 10952 return nil 10953} 10954func (m *ReplicationControllerDummy) Unmarshal(dAtA []byte) error { 10955 l := len(dAtA) 10956 iNdEx := 0 10957 for iNdEx < l { 10958 preIndex := iNdEx 10959 var wire uint64 10960 for shift := uint(0); ; shift += 7 { 10961 if shift >= 64 { 10962 return ErrIntOverflowGenerated 10963 } 10964 if iNdEx >= l { 10965 return io.ErrUnexpectedEOF 10966 } 10967 b := dAtA[iNdEx] 10968 iNdEx++ 10969 wire |= (uint64(b) & 0x7F) << shift 10970 if b < 0x80 { 10971 break 10972 } 10973 } 10974 fieldNum := int32(wire >> 3) 10975 wireType := int(wire & 0x7) 10976 if wireType == 4 { 10977 return fmt.Errorf("proto: ReplicationControllerDummy: wiretype end group for non-group") 10978 } 10979 if fieldNum <= 0 { 10980 return fmt.Errorf("proto: ReplicationControllerDummy: illegal tag %d (wire type %d)", fieldNum, wire) 10981 } 10982 switch fieldNum { 10983 default: 10984 iNdEx = preIndex 10985 skippy, err := skipGenerated(dAtA[iNdEx:]) 10986 if err != nil { 10987 return err 10988 } 10989 if skippy < 0 { 10990 return ErrInvalidLengthGenerated 10991 } 10992 if (iNdEx + skippy) > l { 10993 return io.ErrUnexpectedEOF 10994 } 10995 iNdEx += skippy 10996 } 10997 } 10998 10999 if iNdEx > l { 11000 return io.ErrUnexpectedEOF 11001 } 11002 return nil 11003} 11004func (m *RollbackConfig) Unmarshal(dAtA []byte) error { 11005 l := len(dAtA) 11006 iNdEx := 0 11007 for iNdEx < l { 11008 preIndex := iNdEx 11009 var wire uint64 11010 for shift := uint(0); ; shift += 7 { 11011 if shift >= 64 { 11012 return ErrIntOverflowGenerated 11013 } 11014 if iNdEx >= l { 11015 return io.ErrUnexpectedEOF 11016 } 11017 b := dAtA[iNdEx] 11018 iNdEx++ 11019 wire |= (uint64(b) & 0x7F) << shift 11020 if b < 0x80 { 11021 break 11022 } 11023 } 11024 fieldNum := int32(wire >> 3) 11025 wireType := int(wire & 0x7) 11026 if wireType == 4 { 11027 return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group") 11028 } 11029 if fieldNum <= 0 { 11030 return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire) 11031 } 11032 switch fieldNum { 11033 case 1: 11034 if wireType != 0 { 11035 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) 11036 } 11037 m.Revision = 0 11038 for shift := uint(0); ; shift += 7 { 11039 if shift >= 64 { 11040 return ErrIntOverflowGenerated 11041 } 11042 if iNdEx >= l { 11043 return io.ErrUnexpectedEOF 11044 } 11045 b := dAtA[iNdEx] 11046 iNdEx++ 11047 m.Revision |= (int64(b) & 0x7F) << shift 11048 if b < 0x80 { 11049 break 11050 } 11051 } 11052 default: 11053 iNdEx = preIndex 11054 skippy, err := skipGenerated(dAtA[iNdEx:]) 11055 if err != nil { 11056 return err 11057 } 11058 if skippy < 0 { 11059 return ErrInvalidLengthGenerated 11060 } 11061 if (iNdEx + skippy) > l { 11062 return io.ErrUnexpectedEOF 11063 } 11064 iNdEx += skippy 11065 } 11066 } 11067 11068 if iNdEx > l { 11069 return io.ErrUnexpectedEOF 11070 } 11071 return nil 11072} 11073func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error { 11074 l := len(dAtA) 11075 iNdEx := 0 11076 for iNdEx < l { 11077 preIndex := iNdEx 11078 var wire uint64 11079 for shift := uint(0); ; shift += 7 { 11080 if shift >= 64 { 11081 return ErrIntOverflowGenerated 11082 } 11083 if iNdEx >= l { 11084 return io.ErrUnexpectedEOF 11085 } 11086 b := dAtA[iNdEx] 11087 iNdEx++ 11088 wire |= (uint64(b) & 0x7F) << shift 11089 if b < 0x80 { 11090 break 11091 } 11092 } 11093 fieldNum := int32(wire >> 3) 11094 wireType := int(wire & 0x7) 11095 if wireType == 4 { 11096 return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group") 11097 } 11098 if fieldNum <= 0 { 11099 return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire) 11100 } 11101 switch fieldNum { 11102 case 1: 11103 if wireType != 2 { 11104 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType) 11105 } 11106 var msglen int 11107 for shift := uint(0); ; shift += 7 { 11108 if shift >= 64 { 11109 return ErrIntOverflowGenerated 11110 } 11111 if iNdEx >= l { 11112 return io.ErrUnexpectedEOF 11113 } 11114 b := dAtA[iNdEx] 11115 iNdEx++ 11116 msglen |= (int(b) & 0x7F) << shift 11117 if b < 0x80 { 11118 break 11119 } 11120 } 11121 if msglen < 0 { 11122 return ErrInvalidLengthGenerated 11123 } 11124 postIndex := iNdEx + msglen 11125 if postIndex > l { 11126 return io.ErrUnexpectedEOF 11127 } 11128 if m.MaxUnavailable == nil { 11129 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 11130 } 11131 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11132 return err 11133 } 11134 iNdEx = postIndex 11135 default: 11136 iNdEx = preIndex 11137 skippy, err := skipGenerated(dAtA[iNdEx:]) 11138 if err != nil { 11139 return err 11140 } 11141 if skippy < 0 { 11142 return ErrInvalidLengthGenerated 11143 } 11144 if (iNdEx + skippy) > l { 11145 return io.ErrUnexpectedEOF 11146 } 11147 iNdEx += skippy 11148 } 11149 } 11150 11151 if iNdEx > l { 11152 return io.ErrUnexpectedEOF 11153 } 11154 return nil 11155} 11156func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error { 11157 l := len(dAtA) 11158 iNdEx := 0 11159 for iNdEx < l { 11160 preIndex := iNdEx 11161 var wire uint64 11162 for shift := uint(0); ; shift += 7 { 11163 if shift >= 64 { 11164 return ErrIntOverflowGenerated 11165 } 11166 if iNdEx >= l { 11167 return io.ErrUnexpectedEOF 11168 } 11169 b := dAtA[iNdEx] 11170 iNdEx++ 11171 wire |= (uint64(b) & 0x7F) << shift 11172 if b < 0x80 { 11173 break 11174 } 11175 } 11176 fieldNum := int32(wire >> 3) 11177 wireType := int(wire & 0x7) 11178 if wireType == 4 { 11179 return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group") 11180 } 11181 if fieldNum <= 0 { 11182 return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire) 11183 } 11184 switch fieldNum { 11185 case 1: 11186 if wireType != 2 { 11187 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType) 11188 } 11189 var msglen int 11190 for shift := uint(0); ; shift += 7 { 11191 if shift >= 64 { 11192 return ErrIntOverflowGenerated 11193 } 11194 if iNdEx >= l { 11195 return io.ErrUnexpectedEOF 11196 } 11197 b := dAtA[iNdEx] 11198 iNdEx++ 11199 msglen |= (int(b) & 0x7F) << shift 11200 if b < 0x80 { 11201 break 11202 } 11203 } 11204 if msglen < 0 { 11205 return ErrInvalidLengthGenerated 11206 } 11207 postIndex := iNdEx + msglen 11208 if postIndex > l { 11209 return io.ErrUnexpectedEOF 11210 } 11211 if m.MaxUnavailable == nil { 11212 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 11213 } 11214 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11215 return err 11216 } 11217 iNdEx = postIndex 11218 case 2: 11219 if wireType != 2 { 11220 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType) 11221 } 11222 var msglen int 11223 for shift := uint(0); ; shift += 7 { 11224 if shift >= 64 { 11225 return ErrIntOverflowGenerated 11226 } 11227 if iNdEx >= l { 11228 return io.ErrUnexpectedEOF 11229 } 11230 b := dAtA[iNdEx] 11231 iNdEx++ 11232 msglen |= (int(b) & 0x7F) << shift 11233 if b < 0x80 { 11234 break 11235 } 11236 } 11237 if msglen < 0 { 11238 return ErrInvalidLengthGenerated 11239 } 11240 postIndex := iNdEx + msglen 11241 if postIndex > l { 11242 return io.ErrUnexpectedEOF 11243 } 11244 if m.MaxSurge == nil { 11245 m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 11246 } 11247 if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11248 return err 11249 } 11250 iNdEx = postIndex 11251 default: 11252 iNdEx = preIndex 11253 skippy, err := skipGenerated(dAtA[iNdEx:]) 11254 if err != nil { 11255 return err 11256 } 11257 if skippy < 0 { 11258 return ErrInvalidLengthGenerated 11259 } 11260 if (iNdEx + skippy) > l { 11261 return io.ErrUnexpectedEOF 11262 } 11263 iNdEx += skippy 11264 } 11265 } 11266 11267 if iNdEx > l { 11268 return io.ErrUnexpectedEOF 11269 } 11270 return nil 11271} 11272func (m *RunAsGroupStrategyOptions) Unmarshal(dAtA []byte) error { 11273 l := len(dAtA) 11274 iNdEx := 0 11275 for iNdEx < l { 11276 preIndex := iNdEx 11277 var wire uint64 11278 for shift := uint(0); ; shift += 7 { 11279 if shift >= 64 { 11280 return ErrIntOverflowGenerated 11281 } 11282 if iNdEx >= l { 11283 return io.ErrUnexpectedEOF 11284 } 11285 b := dAtA[iNdEx] 11286 iNdEx++ 11287 wire |= (uint64(b) & 0x7F) << shift 11288 if b < 0x80 { 11289 break 11290 } 11291 } 11292 fieldNum := int32(wire >> 3) 11293 wireType := int(wire & 0x7) 11294 if wireType == 4 { 11295 return fmt.Errorf("proto: RunAsGroupStrategyOptions: wiretype end group for non-group") 11296 } 11297 if fieldNum <= 0 { 11298 return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11299 } 11300 switch fieldNum { 11301 case 1: 11302 if wireType != 2 { 11303 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 11304 } 11305 var stringLen uint64 11306 for shift := uint(0); ; shift += 7 { 11307 if shift >= 64 { 11308 return ErrIntOverflowGenerated 11309 } 11310 if iNdEx >= l { 11311 return io.ErrUnexpectedEOF 11312 } 11313 b := dAtA[iNdEx] 11314 iNdEx++ 11315 stringLen |= (uint64(b) & 0x7F) << shift 11316 if b < 0x80 { 11317 break 11318 } 11319 } 11320 intStringLen := int(stringLen) 11321 if intStringLen < 0 { 11322 return ErrInvalidLengthGenerated 11323 } 11324 postIndex := iNdEx + intStringLen 11325 if postIndex > l { 11326 return io.ErrUnexpectedEOF 11327 } 11328 m.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex]) 11329 iNdEx = postIndex 11330 case 2: 11331 if wireType != 2 { 11332 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 11333 } 11334 var msglen int 11335 for shift := uint(0); ; shift += 7 { 11336 if shift >= 64 { 11337 return ErrIntOverflowGenerated 11338 } 11339 if iNdEx >= l { 11340 return io.ErrUnexpectedEOF 11341 } 11342 b := dAtA[iNdEx] 11343 iNdEx++ 11344 msglen |= (int(b) & 0x7F) << shift 11345 if b < 0x80 { 11346 break 11347 } 11348 } 11349 if msglen < 0 { 11350 return ErrInvalidLengthGenerated 11351 } 11352 postIndex := iNdEx + msglen 11353 if postIndex > l { 11354 return io.ErrUnexpectedEOF 11355 } 11356 m.Ranges = append(m.Ranges, IDRange{}) 11357 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11358 return err 11359 } 11360 iNdEx = postIndex 11361 default: 11362 iNdEx = preIndex 11363 skippy, err := skipGenerated(dAtA[iNdEx:]) 11364 if err != nil { 11365 return err 11366 } 11367 if skippy < 0 { 11368 return ErrInvalidLengthGenerated 11369 } 11370 if (iNdEx + skippy) > l { 11371 return io.ErrUnexpectedEOF 11372 } 11373 iNdEx += skippy 11374 } 11375 } 11376 11377 if iNdEx > l { 11378 return io.ErrUnexpectedEOF 11379 } 11380 return nil 11381} 11382func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error { 11383 l := len(dAtA) 11384 iNdEx := 0 11385 for iNdEx < l { 11386 preIndex := iNdEx 11387 var wire uint64 11388 for shift := uint(0); ; shift += 7 { 11389 if shift >= 64 { 11390 return ErrIntOverflowGenerated 11391 } 11392 if iNdEx >= l { 11393 return io.ErrUnexpectedEOF 11394 } 11395 b := dAtA[iNdEx] 11396 iNdEx++ 11397 wire |= (uint64(b) & 0x7F) << shift 11398 if b < 0x80 { 11399 break 11400 } 11401 } 11402 fieldNum := int32(wire >> 3) 11403 wireType := int(wire & 0x7) 11404 if wireType == 4 { 11405 return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group") 11406 } 11407 if fieldNum <= 0 { 11408 return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11409 } 11410 switch fieldNum { 11411 case 1: 11412 if wireType != 2 { 11413 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 11414 } 11415 var stringLen uint64 11416 for shift := uint(0); ; shift += 7 { 11417 if shift >= 64 { 11418 return ErrIntOverflowGenerated 11419 } 11420 if iNdEx >= l { 11421 return io.ErrUnexpectedEOF 11422 } 11423 b := dAtA[iNdEx] 11424 iNdEx++ 11425 stringLen |= (uint64(b) & 0x7F) << shift 11426 if b < 0x80 { 11427 break 11428 } 11429 } 11430 intStringLen := int(stringLen) 11431 if intStringLen < 0 { 11432 return ErrInvalidLengthGenerated 11433 } 11434 postIndex := iNdEx + intStringLen 11435 if postIndex > l { 11436 return io.ErrUnexpectedEOF 11437 } 11438 m.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex]) 11439 iNdEx = postIndex 11440 case 2: 11441 if wireType != 2 { 11442 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 11443 } 11444 var msglen int 11445 for shift := uint(0); ; shift += 7 { 11446 if shift >= 64 { 11447 return ErrIntOverflowGenerated 11448 } 11449 if iNdEx >= l { 11450 return io.ErrUnexpectedEOF 11451 } 11452 b := dAtA[iNdEx] 11453 iNdEx++ 11454 msglen |= (int(b) & 0x7F) << shift 11455 if b < 0x80 { 11456 break 11457 } 11458 } 11459 if msglen < 0 { 11460 return ErrInvalidLengthGenerated 11461 } 11462 postIndex := iNdEx + msglen 11463 if postIndex > l { 11464 return io.ErrUnexpectedEOF 11465 } 11466 m.Ranges = append(m.Ranges, IDRange{}) 11467 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11468 return err 11469 } 11470 iNdEx = postIndex 11471 default: 11472 iNdEx = preIndex 11473 skippy, err := skipGenerated(dAtA[iNdEx:]) 11474 if err != nil { 11475 return err 11476 } 11477 if skippy < 0 { 11478 return ErrInvalidLengthGenerated 11479 } 11480 if (iNdEx + skippy) > l { 11481 return io.ErrUnexpectedEOF 11482 } 11483 iNdEx += skippy 11484 } 11485 } 11486 11487 if iNdEx > l { 11488 return io.ErrUnexpectedEOF 11489 } 11490 return nil 11491} 11492func (m *SELinuxStrategyOptions) Unmarshal(dAtA []byte) error { 11493 l := len(dAtA) 11494 iNdEx := 0 11495 for iNdEx < l { 11496 preIndex := iNdEx 11497 var wire uint64 11498 for shift := uint(0); ; shift += 7 { 11499 if shift >= 64 { 11500 return ErrIntOverflowGenerated 11501 } 11502 if iNdEx >= l { 11503 return io.ErrUnexpectedEOF 11504 } 11505 b := dAtA[iNdEx] 11506 iNdEx++ 11507 wire |= (uint64(b) & 0x7F) << shift 11508 if b < 0x80 { 11509 break 11510 } 11511 } 11512 fieldNum := int32(wire >> 3) 11513 wireType := int(wire & 0x7) 11514 if wireType == 4 { 11515 return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group") 11516 } 11517 if fieldNum <= 0 { 11518 return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11519 } 11520 switch fieldNum { 11521 case 1: 11522 if wireType != 2 { 11523 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 11524 } 11525 var stringLen uint64 11526 for shift := uint(0); ; shift += 7 { 11527 if shift >= 64 { 11528 return ErrIntOverflowGenerated 11529 } 11530 if iNdEx >= l { 11531 return io.ErrUnexpectedEOF 11532 } 11533 b := dAtA[iNdEx] 11534 iNdEx++ 11535 stringLen |= (uint64(b) & 0x7F) << shift 11536 if b < 0x80 { 11537 break 11538 } 11539 } 11540 intStringLen := int(stringLen) 11541 if intStringLen < 0 { 11542 return ErrInvalidLengthGenerated 11543 } 11544 postIndex := iNdEx + intStringLen 11545 if postIndex > l { 11546 return io.ErrUnexpectedEOF 11547 } 11548 m.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex]) 11549 iNdEx = postIndex 11550 case 2: 11551 if wireType != 2 { 11552 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType) 11553 } 11554 var msglen int 11555 for shift := uint(0); ; shift += 7 { 11556 if shift >= 64 { 11557 return ErrIntOverflowGenerated 11558 } 11559 if iNdEx >= l { 11560 return io.ErrUnexpectedEOF 11561 } 11562 b := dAtA[iNdEx] 11563 iNdEx++ 11564 msglen |= (int(b) & 0x7F) << shift 11565 if b < 0x80 { 11566 break 11567 } 11568 } 11569 if msglen < 0 { 11570 return ErrInvalidLengthGenerated 11571 } 11572 postIndex := iNdEx + msglen 11573 if postIndex > l { 11574 return io.ErrUnexpectedEOF 11575 } 11576 if m.SELinuxOptions == nil { 11577 m.SELinuxOptions = &k8s_io_api_core_v1.SELinuxOptions{} 11578 } 11579 if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11580 return err 11581 } 11582 iNdEx = postIndex 11583 default: 11584 iNdEx = preIndex 11585 skippy, err := skipGenerated(dAtA[iNdEx:]) 11586 if err != nil { 11587 return err 11588 } 11589 if skippy < 0 { 11590 return ErrInvalidLengthGenerated 11591 } 11592 if (iNdEx + skippy) > l { 11593 return io.ErrUnexpectedEOF 11594 } 11595 iNdEx += skippy 11596 } 11597 } 11598 11599 if iNdEx > l { 11600 return io.ErrUnexpectedEOF 11601 } 11602 return nil 11603} 11604func (m *Scale) Unmarshal(dAtA []byte) error { 11605 l := len(dAtA) 11606 iNdEx := 0 11607 for iNdEx < l { 11608 preIndex := iNdEx 11609 var wire uint64 11610 for shift := uint(0); ; shift += 7 { 11611 if shift >= 64 { 11612 return ErrIntOverflowGenerated 11613 } 11614 if iNdEx >= l { 11615 return io.ErrUnexpectedEOF 11616 } 11617 b := dAtA[iNdEx] 11618 iNdEx++ 11619 wire |= (uint64(b) & 0x7F) << shift 11620 if b < 0x80 { 11621 break 11622 } 11623 } 11624 fieldNum := int32(wire >> 3) 11625 wireType := int(wire & 0x7) 11626 if wireType == 4 { 11627 return fmt.Errorf("proto: Scale: wiretype end group for non-group") 11628 } 11629 if fieldNum <= 0 { 11630 return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire) 11631 } 11632 switch fieldNum { 11633 case 1: 11634 if wireType != 2 { 11635 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 11636 } 11637 var msglen int 11638 for shift := uint(0); ; shift += 7 { 11639 if shift >= 64 { 11640 return ErrIntOverflowGenerated 11641 } 11642 if iNdEx >= l { 11643 return io.ErrUnexpectedEOF 11644 } 11645 b := dAtA[iNdEx] 11646 iNdEx++ 11647 msglen |= (int(b) & 0x7F) << shift 11648 if b < 0x80 { 11649 break 11650 } 11651 } 11652 if msglen < 0 { 11653 return ErrInvalidLengthGenerated 11654 } 11655 postIndex := iNdEx + msglen 11656 if postIndex > l { 11657 return io.ErrUnexpectedEOF 11658 } 11659 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11660 return err 11661 } 11662 iNdEx = postIndex 11663 case 2: 11664 if wireType != 2 { 11665 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 11666 } 11667 var msglen int 11668 for shift := uint(0); ; shift += 7 { 11669 if shift >= 64 { 11670 return ErrIntOverflowGenerated 11671 } 11672 if iNdEx >= l { 11673 return io.ErrUnexpectedEOF 11674 } 11675 b := dAtA[iNdEx] 11676 iNdEx++ 11677 msglen |= (int(b) & 0x7F) << shift 11678 if b < 0x80 { 11679 break 11680 } 11681 } 11682 if msglen < 0 { 11683 return ErrInvalidLengthGenerated 11684 } 11685 postIndex := iNdEx + msglen 11686 if postIndex > l { 11687 return io.ErrUnexpectedEOF 11688 } 11689 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11690 return err 11691 } 11692 iNdEx = postIndex 11693 case 3: 11694 if wireType != 2 { 11695 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 11696 } 11697 var msglen int 11698 for shift := uint(0); ; shift += 7 { 11699 if shift >= 64 { 11700 return ErrIntOverflowGenerated 11701 } 11702 if iNdEx >= l { 11703 return io.ErrUnexpectedEOF 11704 } 11705 b := dAtA[iNdEx] 11706 iNdEx++ 11707 msglen |= (int(b) & 0x7F) << shift 11708 if b < 0x80 { 11709 break 11710 } 11711 } 11712 if msglen < 0 { 11713 return ErrInvalidLengthGenerated 11714 } 11715 postIndex := iNdEx + msglen 11716 if postIndex > l { 11717 return io.ErrUnexpectedEOF 11718 } 11719 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11720 return err 11721 } 11722 iNdEx = postIndex 11723 default: 11724 iNdEx = preIndex 11725 skippy, err := skipGenerated(dAtA[iNdEx:]) 11726 if err != nil { 11727 return err 11728 } 11729 if skippy < 0 { 11730 return ErrInvalidLengthGenerated 11731 } 11732 if (iNdEx + skippy) > l { 11733 return io.ErrUnexpectedEOF 11734 } 11735 iNdEx += skippy 11736 } 11737 } 11738 11739 if iNdEx > l { 11740 return io.ErrUnexpectedEOF 11741 } 11742 return nil 11743} 11744func (m *ScaleSpec) Unmarshal(dAtA []byte) error { 11745 l := len(dAtA) 11746 iNdEx := 0 11747 for iNdEx < l { 11748 preIndex := iNdEx 11749 var wire uint64 11750 for shift := uint(0); ; shift += 7 { 11751 if shift >= 64 { 11752 return ErrIntOverflowGenerated 11753 } 11754 if iNdEx >= l { 11755 return io.ErrUnexpectedEOF 11756 } 11757 b := dAtA[iNdEx] 11758 iNdEx++ 11759 wire |= (uint64(b) & 0x7F) << shift 11760 if b < 0x80 { 11761 break 11762 } 11763 } 11764 fieldNum := int32(wire >> 3) 11765 wireType := int(wire & 0x7) 11766 if wireType == 4 { 11767 return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group") 11768 } 11769 if fieldNum <= 0 { 11770 return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire) 11771 } 11772 switch fieldNum { 11773 case 1: 11774 if wireType != 0 { 11775 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 11776 } 11777 m.Replicas = 0 11778 for shift := uint(0); ; shift += 7 { 11779 if shift >= 64 { 11780 return ErrIntOverflowGenerated 11781 } 11782 if iNdEx >= l { 11783 return io.ErrUnexpectedEOF 11784 } 11785 b := dAtA[iNdEx] 11786 iNdEx++ 11787 m.Replicas |= (int32(b) & 0x7F) << shift 11788 if b < 0x80 { 11789 break 11790 } 11791 } 11792 default: 11793 iNdEx = preIndex 11794 skippy, err := skipGenerated(dAtA[iNdEx:]) 11795 if err != nil { 11796 return err 11797 } 11798 if skippy < 0 { 11799 return ErrInvalidLengthGenerated 11800 } 11801 if (iNdEx + skippy) > l { 11802 return io.ErrUnexpectedEOF 11803 } 11804 iNdEx += skippy 11805 } 11806 } 11807 11808 if iNdEx > l { 11809 return io.ErrUnexpectedEOF 11810 } 11811 return nil 11812} 11813func (m *ScaleStatus) Unmarshal(dAtA []byte) error { 11814 l := len(dAtA) 11815 iNdEx := 0 11816 for iNdEx < l { 11817 preIndex := iNdEx 11818 var wire uint64 11819 for shift := uint(0); ; shift += 7 { 11820 if shift >= 64 { 11821 return ErrIntOverflowGenerated 11822 } 11823 if iNdEx >= l { 11824 return io.ErrUnexpectedEOF 11825 } 11826 b := dAtA[iNdEx] 11827 iNdEx++ 11828 wire |= (uint64(b) & 0x7F) << shift 11829 if b < 0x80 { 11830 break 11831 } 11832 } 11833 fieldNum := int32(wire >> 3) 11834 wireType := int(wire & 0x7) 11835 if wireType == 4 { 11836 return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group") 11837 } 11838 if fieldNum <= 0 { 11839 return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire) 11840 } 11841 switch fieldNum { 11842 case 1: 11843 if wireType != 0 { 11844 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 11845 } 11846 m.Replicas = 0 11847 for shift := uint(0); ; shift += 7 { 11848 if shift >= 64 { 11849 return ErrIntOverflowGenerated 11850 } 11851 if iNdEx >= l { 11852 return io.ErrUnexpectedEOF 11853 } 11854 b := dAtA[iNdEx] 11855 iNdEx++ 11856 m.Replicas |= (int32(b) & 0x7F) << shift 11857 if b < 0x80 { 11858 break 11859 } 11860 } 11861 case 2: 11862 if wireType != 2 { 11863 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 11864 } 11865 var msglen int 11866 for shift := uint(0); ; shift += 7 { 11867 if shift >= 64 { 11868 return ErrIntOverflowGenerated 11869 } 11870 if iNdEx >= l { 11871 return io.ErrUnexpectedEOF 11872 } 11873 b := dAtA[iNdEx] 11874 iNdEx++ 11875 msglen |= (int(b) & 0x7F) << shift 11876 if b < 0x80 { 11877 break 11878 } 11879 } 11880 if msglen < 0 { 11881 return ErrInvalidLengthGenerated 11882 } 11883 postIndex := iNdEx + msglen 11884 if postIndex > l { 11885 return io.ErrUnexpectedEOF 11886 } 11887 if m.Selector == nil { 11888 m.Selector = make(map[string]string) 11889 } 11890 var mapkey string 11891 var mapvalue string 11892 for iNdEx < postIndex { 11893 entryPreIndex := iNdEx 11894 var wire uint64 11895 for shift := uint(0); ; shift += 7 { 11896 if shift >= 64 { 11897 return ErrIntOverflowGenerated 11898 } 11899 if iNdEx >= l { 11900 return io.ErrUnexpectedEOF 11901 } 11902 b := dAtA[iNdEx] 11903 iNdEx++ 11904 wire |= (uint64(b) & 0x7F) << shift 11905 if b < 0x80 { 11906 break 11907 } 11908 } 11909 fieldNum := int32(wire >> 3) 11910 if fieldNum == 1 { 11911 var stringLenmapkey uint64 11912 for shift := uint(0); ; shift += 7 { 11913 if shift >= 64 { 11914 return ErrIntOverflowGenerated 11915 } 11916 if iNdEx >= l { 11917 return io.ErrUnexpectedEOF 11918 } 11919 b := dAtA[iNdEx] 11920 iNdEx++ 11921 stringLenmapkey |= (uint64(b) & 0x7F) << shift 11922 if b < 0x80 { 11923 break 11924 } 11925 } 11926 intStringLenmapkey := int(stringLenmapkey) 11927 if intStringLenmapkey < 0 { 11928 return ErrInvalidLengthGenerated 11929 } 11930 postStringIndexmapkey := iNdEx + intStringLenmapkey 11931 if postStringIndexmapkey > l { 11932 return io.ErrUnexpectedEOF 11933 } 11934 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 11935 iNdEx = postStringIndexmapkey 11936 } else if fieldNum == 2 { 11937 var stringLenmapvalue uint64 11938 for shift := uint(0); ; shift += 7 { 11939 if shift >= 64 { 11940 return ErrIntOverflowGenerated 11941 } 11942 if iNdEx >= l { 11943 return io.ErrUnexpectedEOF 11944 } 11945 b := dAtA[iNdEx] 11946 iNdEx++ 11947 stringLenmapvalue |= (uint64(b) & 0x7F) << shift 11948 if b < 0x80 { 11949 break 11950 } 11951 } 11952 intStringLenmapvalue := int(stringLenmapvalue) 11953 if intStringLenmapvalue < 0 { 11954 return ErrInvalidLengthGenerated 11955 } 11956 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 11957 if postStringIndexmapvalue > l { 11958 return io.ErrUnexpectedEOF 11959 } 11960 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 11961 iNdEx = postStringIndexmapvalue 11962 } else { 11963 iNdEx = entryPreIndex 11964 skippy, err := skipGenerated(dAtA[iNdEx:]) 11965 if err != nil { 11966 return err 11967 } 11968 if skippy < 0 { 11969 return ErrInvalidLengthGenerated 11970 } 11971 if (iNdEx + skippy) > postIndex { 11972 return io.ErrUnexpectedEOF 11973 } 11974 iNdEx += skippy 11975 } 11976 } 11977 m.Selector[mapkey] = mapvalue 11978 iNdEx = postIndex 11979 case 3: 11980 if wireType != 2 { 11981 return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType) 11982 } 11983 var stringLen uint64 11984 for shift := uint(0); ; shift += 7 { 11985 if shift >= 64 { 11986 return ErrIntOverflowGenerated 11987 } 11988 if iNdEx >= l { 11989 return io.ErrUnexpectedEOF 11990 } 11991 b := dAtA[iNdEx] 11992 iNdEx++ 11993 stringLen |= (uint64(b) & 0x7F) << shift 11994 if b < 0x80 { 11995 break 11996 } 11997 } 11998 intStringLen := int(stringLen) 11999 if intStringLen < 0 { 12000 return ErrInvalidLengthGenerated 12001 } 12002 postIndex := iNdEx + intStringLen 12003 if postIndex > l { 12004 return io.ErrUnexpectedEOF 12005 } 12006 m.TargetSelector = string(dAtA[iNdEx:postIndex]) 12007 iNdEx = postIndex 12008 default: 12009 iNdEx = preIndex 12010 skippy, err := skipGenerated(dAtA[iNdEx:]) 12011 if err != nil { 12012 return err 12013 } 12014 if skippy < 0 { 12015 return ErrInvalidLengthGenerated 12016 } 12017 if (iNdEx + skippy) > l { 12018 return io.ErrUnexpectedEOF 12019 } 12020 iNdEx += skippy 12021 } 12022 } 12023 12024 if iNdEx > l { 12025 return io.ErrUnexpectedEOF 12026 } 12027 return nil 12028} 12029func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error { 12030 l := len(dAtA) 12031 iNdEx := 0 12032 for iNdEx < l { 12033 preIndex := iNdEx 12034 var wire uint64 12035 for shift := uint(0); ; shift += 7 { 12036 if shift >= 64 { 12037 return ErrIntOverflowGenerated 12038 } 12039 if iNdEx >= l { 12040 return io.ErrUnexpectedEOF 12041 } 12042 b := dAtA[iNdEx] 12043 iNdEx++ 12044 wire |= (uint64(b) & 0x7F) << shift 12045 if b < 0x80 { 12046 break 12047 } 12048 } 12049 fieldNum := int32(wire >> 3) 12050 wireType := int(wire & 0x7) 12051 if wireType == 4 { 12052 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group") 12053 } 12054 if fieldNum <= 0 { 12055 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 12056 } 12057 switch fieldNum { 12058 case 1: 12059 if wireType != 2 { 12060 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 12061 } 12062 var stringLen uint64 12063 for shift := uint(0); ; shift += 7 { 12064 if shift >= 64 { 12065 return ErrIntOverflowGenerated 12066 } 12067 if iNdEx >= l { 12068 return io.ErrUnexpectedEOF 12069 } 12070 b := dAtA[iNdEx] 12071 iNdEx++ 12072 stringLen |= (uint64(b) & 0x7F) << shift 12073 if b < 0x80 { 12074 break 12075 } 12076 } 12077 intStringLen := int(stringLen) 12078 if intStringLen < 0 { 12079 return ErrInvalidLengthGenerated 12080 } 12081 postIndex := iNdEx + intStringLen 12082 if postIndex > l { 12083 return io.ErrUnexpectedEOF 12084 } 12085 m.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex]) 12086 iNdEx = postIndex 12087 case 2: 12088 if wireType != 2 { 12089 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 12090 } 12091 var msglen int 12092 for shift := uint(0); ; shift += 7 { 12093 if shift >= 64 { 12094 return ErrIntOverflowGenerated 12095 } 12096 if iNdEx >= l { 12097 return io.ErrUnexpectedEOF 12098 } 12099 b := dAtA[iNdEx] 12100 iNdEx++ 12101 msglen |= (int(b) & 0x7F) << shift 12102 if b < 0x80 { 12103 break 12104 } 12105 } 12106 if msglen < 0 { 12107 return ErrInvalidLengthGenerated 12108 } 12109 postIndex := iNdEx + msglen 12110 if postIndex > l { 12111 return io.ErrUnexpectedEOF 12112 } 12113 m.Ranges = append(m.Ranges, IDRange{}) 12114 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12115 return err 12116 } 12117 iNdEx = postIndex 12118 default: 12119 iNdEx = preIndex 12120 skippy, err := skipGenerated(dAtA[iNdEx:]) 12121 if err != nil { 12122 return err 12123 } 12124 if skippy < 0 { 12125 return ErrInvalidLengthGenerated 12126 } 12127 if (iNdEx + skippy) > l { 12128 return io.ErrUnexpectedEOF 12129 } 12130 iNdEx += skippy 12131 } 12132 } 12133 12134 if iNdEx > l { 12135 return io.ErrUnexpectedEOF 12136 } 12137 return nil 12138} 12139func skipGenerated(dAtA []byte) (n int, err error) { 12140 l := len(dAtA) 12141 iNdEx := 0 12142 for iNdEx < l { 12143 var wire uint64 12144 for shift := uint(0); ; shift += 7 { 12145 if shift >= 64 { 12146 return 0, ErrIntOverflowGenerated 12147 } 12148 if iNdEx >= l { 12149 return 0, io.ErrUnexpectedEOF 12150 } 12151 b := dAtA[iNdEx] 12152 iNdEx++ 12153 wire |= (uint64(b) & 0x7F) << shift 12154 if b < 0x80 { 12155 break 12156 } 12157 } 12158 wireType := int(wire & 0x7) 12159 switch wireType { 12160 case 0: 12161 for shift := uint(0); ; shift += 7 { 12162 if shift >= 64 { 12163 return 0, ErrIntOverflowGenerated 12164 } 12165 if iNdEx >= l { 12166 return 0, io.ErrUnexpectedEOF 12167 } 12168 iNdEx++ 12169 if dAtA[iNdEx-1] < 0x80 { 12170 break 12171 } 12172 } 12173 return iNdEx, nil 12174 case 1: 12175 iNdEx += 8 12176 return iNdEx, nil 12177 case 2: 12178 var length int 12179 for shift := uint(0); ; shift += 7 { 12180 if shift >= 64 { 12181 return 0, ErrIntOverflowGenerated 12182 } 12183 if iNdEx >= l { 12184 return 0, io.ErrUnexpectedEOF 12185 } 12186 b := dAtA[iNdEx] 12187 iNdEx++ 12188 length |= (int(b) & 0x7F) << shift 12189 if b < 0x80 { 12190 break 12191 } 12192 } 12193 iNdEx += length 12194 if length < 0 { 12195 return 0, ErrInvalidLengthGenerated 12196 } 12197 return iNdEx, nil 12198 case 3: 12199 for { 12200 var innerWire uint64 12201 var start int = iNdEx 12202 for shift := uint(0); ; shift += 7 { 12203 if shift >= 64 { 12204 return 0, ErrIntOverflowGenerated 12205 } 12206 if iNdEx >= l { 12207 return 0, io.ErrUnexpectedEOF 12208 } 12209 b := dAtA[iNdEx] 12210 iNdEx++ 12211 innerWire |= (uint64(b) & 0x7F) << shift 12212 if b < 0x80 { 12213 break 12214 } 12215 } 12216 innerWireType := int(innerWire & 0x7) 12217 if innerWireType == 4 { 12218 break 12219 } 12220 next, err := skipGenerated(dAtA[start:]) 12221 if err != nil { 12222 return 0, err 12223 } 12224 iNdEx = start + next 12225 } 12226 return iNdEx, nil 12227 case 4: 12228 return iNdEx, nil 12229 case 5: 12230 iNdEx += 4 12231 return iNdEx, nil 12232 default: 12233 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 12234 } 12235 } 12236 panic("unreachable") 12237} 12238 12239var ( 12240 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") 12241 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") 12242) 12243 12244func init() { 12245 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptorGenerated) 12246} 12247 12248var fileDescriptorGenerated = []byte{ 12249 // 3622 bytes of a gzipped FileDescriptorProto 12250 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcd, 0x6f, 0x1c, 0x47, 12251 0x76, 0x57, 0xcf, 0x0c, 0x39, 0xc3, 0x47, 0xf1, 0xab, 0x48, 0x91, 0x63, 0xc9, 0xe2, 0xc8, 0x6d, 12252 0x40, 0x91, 0x1d, 0x69, 0xc6, 0x92, 0x25, 0x59, 0xb1, 0x10, 0xdb, 0x1c, 0x52, 0x94, 0xe8, 0xf0, 12253 0x63, 0x5c, 0x43, 0x2a, 0x86, 0x11, 0x3b, 0x6e, 0xce, 0x14, 0x87, 0x2d, 0xf6, 0x74, 0xb7, 0xbb, 12254 0x6b, 0x68, 0x0e, 0x90, 0x43, 0x0e, 0x41, 0x80, 0x00, 0x09, 0x92, 0x8b, 0x93, 0x1c, 0x63, 0x04, 12255 0xc8, 0x29, 0x41, 0x72, 0xcb, 0x1e, 0x0c, 0x03, 0x0b, 0x78, 0x01, 0x61, 0xe1, 0x05, 0x7c, 0x5b, 12256 0x9f, 0x88, 0x35, 0x7d, 0x5a, 0xec, 0x3f, 0xb0, 0xd0, 0x61, 0x77, 0x51, 0xd5, 0xd5, 0xdf, 0xdd, 12257 0x9a, 0x26, 0x2d, 0x11, 0x8b, 0xc5, 0xde, 0x38, 0xf5, 0xde, 0xfb, 0xbd, 0x57, 0x55, 0xaf, 0xde, 12258 0x7b, 0x5d, 0xf5, 0x08, 0xcb, 0x7b, 0x77, 0xec, 0xaa, 0x6a, 0xd4, 0xf6, 0x7a, 0xdb, 0xc4, 0xd2, 12259 0x09, 0x25, 0x76, 0x6d, 0x9f, 0xe8, 0x6d, 0xc3, 0xaa, 0x09, 0x82, 0x62, 0xaa, 0x35, 0x72, 0x40, 12260 0x89, 0x6e, 0xab, 0x86, 0x6e, 0xd7, 0xf6, 0xaf, 0x6f, 0x13, 0xaa, 0x5c, 0xaf, 0x75, 0x88, 0x4e, 12261 0x2c, 0x85, 0x92, 0x76, 0xd5, 0xb4, 0x0c, 0x6a, 0xa0, 0x8b, 0x0e, 0x7b, 0x55, 0x31, 0xd5, 0xaa, 12262 0xcf, 0x5e, 0x15, 0xec, 0xe7, 0xaf, 0x75, 0x54, 0xba, 0xdb, 0xdb, 0xae, 0xb6, 0x8c, 0x6e, 0xad, 12263 0x63, 0x74, 0x8c, 0x1a, 0x97, 0xda, 0xee, 0xed, 0xf0, 0x5f, 0xfc, 0x07, 0xff, 0xcb, 0x41, 0x3b, 12264 0x2f, 0x07, 0x94, 0xb7, 0x0c, 0x8b, 0xd4, 0xf6, 0x63, 0x1a, 0xcf, 0xdf, 0xf4, 0x79, 0xba, 0x4a, 12265 0x6b, 0x57, 0xd5, 0x89, 0xd5, 0xaf, 0x99, 0x7b, 0x1d, 0x36, 0x60, 0xd7, 0xba, 0x84, 0x2a, 0x49, 12266 0x52, 0xb5, 0x34, 0x29, 0xab, 0xa7, 0x53, 0xb5, 0x4b, 0x62, 0x02, 0xb7, 0x07, 0x09, 0xd8, 0xad, 12267 0x5d, 0xd2, 0x55, 0x62, 0x72, 0xaf, 0xa7, 0xc9, 0xf5, 0xa8, 0xaa, 0xd5, 0x54, 0x9d, 0xda, 0xd4, 12268 0x8a, 0x0a, 0xc9, 0x37, 0x61, 0x72, 0x41, 0xd3, 0x8c, 0x4f, 0x49, 0x7b, 0xb1, 0xb9, 0xb2, 0x64, 12269 0xa9, 0xfb, 0xc4, 0x42, 0x97, 0xa0, 0xa0, 0x2b, 0x5d, 0x52, 0x96, 0x2e, 0x49, 0x57, 0x46, 0xea, 12270 0x67, 0x1f, 0x1f, 0x56, 0xce, 0x1c, 0x1d, 0x56, 0x0a, 0xeb, 0x4a, 0x97, 0x60, 0x4e, 0x91, 0xef, 12271 0xc2, 0x94, 0x90, 0x5a, 0xd6, 0xc8, 0xc1, 0x43, 0x43, 0xeb, 0x75, 0x09, 0xba, 0x0c, 0xc3, 0x6d, 12272 0x0e, 0x20, 0x04, 0xc7, 0x85, 0xe0, 0xb0, 0x03, 0x8b, 0x05, 0x55, 0xb6, 0x61, 0x42, 0x08, 0x3f, 12273 0x30, 0x6c, 0xda, 0x50, 0xe8, 0x2e, 0xba, 0x01, 0x60, 0x2a, 0x74, 0xb7, 0x61, 0x91, 0x1d, 0xf5, 12274 0x40, 0x88, 0x23, 0x21, 0x0e, 0x0d, 0x8f, 0x82, 0x03, 0x5c, 0xe8, 0x2a, 0x94, 0x2c, 0xa2, 0xb4, 12275 0x37, 0x74, 0xad, 0x5f, 0xce, 0x5d, 0x92, 0xae, 0x94, 0xea, 0x93, 0x42, 0xa2, 0x84, 0xc5, 0x38, 12276 0xf6, 0x38, 0xe4, 0xcf, 0x72, 0x30, 0xb2, 0xa4, 0x90, 0xae, 0xa1, 0x37, 0x09, 0x45, 0x1f, 0x43, 12277 0x89, 0x6d, 0x57, 0x5b, 0xa1, 0x0a, 0xd7, 0x36, 0x7a, 0xe3, 0xb5, 0xaa, 0xef, 0x4e, 0xde, 0xea, 12278 0x55, 0xcd, 0xbd, 0x0e, 0x1b, 0xb0, 0xab, 0x8c, 0xbb, 0xba, 0x7f, 0xbd, 0xba, 0xb1, 0xfd, 0x88, 12279 0xb4, 0xe8, 0x1a, 0xa1, 0x8a, 0x6f, 0x9f, 0x3f, 0x86, 0x3d, 0x54, 0xb4, 0x0e, 0x05, 0xdb, 0x24, 12280 0x2d, 0x6e, 0xd9, 0xe8, 0x8d, 0xab, 0xd5, 0xa7, 0x3a, 0x6b, 0xd5, 0xb3, 0xac, 0x69, 0x92, 0x96, 12281 0xbf, 0xe2, 0xec, 0x17, 0xe6, 0x38, 0xe8, 0x21, 0x0c, 0xdb, 0x54, 0xa1, 0x3d, 0xbb, 0x9c, 0xe7, 12282 0x88, 0xd5, 0xcc, 0x88, 0x5c, 0xca, 0xdf, 0x0c, 0xe7, 0x37, 0x16, 0x68, 0xf2, 0x2f, 0x73, 0x80, 12283 0x3c, 0xde, 0x45, 0x43, 0x6f, 0xab, 0x54, 0x35, 0x74, 0xf4, 0x26, 0x14, 0x68, 0xdf, 0x74, 0x5d, 12284 0xe0, 0xb2, 0x6b, 0xd0, 0x66, 0xdf, 0x24, 0x4f, 0x0e, 0x2b, 0xb3, 0x71, 0x09, 0x46, 0xc1, 0x5c, 12285 0x06, 0xad, 0x7a, 0xa6, 0xe6, 0xb8, 0xf4, 0xcd, 0xb0, 0xea, 0x27, 0x87, 0x95, 0x84, 0xc3, 0x56, 12286 0xf5, 0x90, 0xc2, 0x06, 0xa2, 0x7d, 0x40, 0x9a, 0x62, 0xd3, 0x4d, 0x4b, 0xd1, 0x6d, 0x47, 0x93, 12287 0xda, 0x25, 0x62, 0x11, 0x5e, 0xcd, 0xb6, 0x69, 0x4c, 0xa2, 0x7e, 0x5e, 0x58, 0x81, 0x56, 0x63, 12288 0x68, 0x38, 0x41, 0x03, 0xf3, 0x66, 0x8b, 0x28, 0xb6, 0xa1, 0x97, 0x0b, 0x61, 0x6f, 0xc6, 0x7c, 12289 0x14, 0x0b, 0x2a, 0x7a, 0x05, 0x8a, 0x5d, 0x62, 0xdb, 0x4a, 0x87, 0x94, 0x87, 0x38, 0xe3, 0x84, 12290 0x60, 0x2c, 0xae, 0x39, 0xc3, 0xd8, 0xa5, 0xcb, 0x5f, 0x48, 0x30, 0xe6, 0xad, 0xdc, 0xaa, 0x6a, 12291 0x53, 0xf4, 0x57, 0x31, 0x3f, 0xac, 0x66, 0x9b, 0x12, 0x93, 0xe6, 0x5e, 0xe8, 0xf9, 0xbc, 0x3b, 12292 0x12, 0xf0, 0xc1, 0x35, 0x18, 0x52, 0x29, 0xe9, 0xb2, 0x7d, 0xc8, 0x5f, 0x19, 0xbd, 0x71, 0x25, 12293 0xab, 0xcb, 0xd4, 0xc7, 0x04, 0xe8, 0xd0, 0x0a, 0x13, 0xc7, 0x0e, 0x8a, 0xfc, 0xaf, 0x85, 0x80, 12294 0xf9, 0xcc, 0x35, 0xd1, 0x87, 0x50, 0xb2, 0x89, 0x46, 0x5a, 0xd4, 0xb0, 0x84, 0xf9, 0xaf, 0x67, 12295 0x34, 0x5f, 0xd9, 0x26, 0x5a, 0x53, 0x88, 0xd6, 0xcf, 0x32, 0xfb, 0xdd, 0x5f, 0xd8, 0x83, 0x44, 12296 0xef, 0x41, 0x89, 0x92, 0xae, 0xa9, 0x29, 0x94, 0x88, 0x73, 0xf4, 0x72, 0x70, 0x0a, 0xcc, 0x73, 12297 0x18, 0x58, 0xc3, 0x68, 0x6f, 0x0a, 0x36, 0x7e, 0x7c, 0xbc, 0x25, 0x71, 0x47, 0xb1, 0x07, 0x83, 12298 0xf6, 0x61, 0xbc, 0x67, 0xb6, 0x19, 0x27, 0x65, 0x51, 0xb0, 0xd3, 0x17, 0x9e, 0x74, 0x3b, 0xeb, 12299 0xda, 0x6c, 0x85, 0xa4, 0xeb, 0xb3, 0x42, 0xd7, 0x78, 0x78, 0x1c, 0x47, 0xb4, 0xa0, 0x05, 0x98, 12300 0xe8, 0xaa, 0x3a, 0x8b, 0x4b, 0xfd, 0x26, 0x69, 0x19, 0x7a, 0xdb, 0xe6, 0x6e, 0x35, 0x54, 0x9f, 12301 0x13, 0x00, 0x13, 0x6b, 0x61, 0x32, 0x8e, 0xf2, 0xa3, 0x77, 0x01, 0xb9, 0xd3, 0xb8, 0xef, 0x04, 12302 0x71, 0xd5, 0xd0, 0xb9, 0xcf, 0xe5, 0x7d, 0xe7, 0xde, 0x8c, 0x71, 0xe0, 0x04, 0x29, 0xb4, 0x0a, 12303 0x33, 0x16, 0xd9, 0x57, 0xd9, 0x1c, 0x1f, 0xa8, 0x36, 0x35, 0xac, 0xfe, 0xaa, 0xda, 0x55, 0x69, 12304 0x79, 0x98, 0xdb, 0x54, 0x3e, 0x3a, 0xac, 0xcc, 0xe0, 0x04, 0x3a, 0x4e, 0x94, 0x92, 0xff, 0x6d, 12305 0x18, 0x26, 0x22, 0xf1, 0x06, 0x3d, 0x84, 0xd9, 0x56, 0xcf, 0xb2, 0x88, 0x4e, 0xd7, 0x7b, 0xdd, 12306 0x6d, 0x62, 0x35, 0x5b, 0xbb, 0xa4, 0xdd, 0xd3, 0x48, 0x9b, 0x3b, 0xca, 0x50, 0x7d, 0x5e, 0x58, 12307 0x3c, 0xbb, 0x98, 0xc8, 0x85, 0x53, 0xa4, 0xd9, 0x2a, 0xe8, 0x7c, 0x68, 0x4d, 0xb5, 0x6d, 0x0f, 12308 0x33, 0xc7, 0x31, 0xbd, 0x55, 0x58, 0x8f, 0x71, 0xe0, 0x04, 0x29, 0x66, 0x63, 0x9b, 0xd8, 0xaa, 12309 0x45, 0xda, 0x51, 0x1b, 0xf3, 0x61, 0x1b, 0x97, 0x12, 0xb9, 0x70, 0x8a, 0x34, 0xba, 0x05, 0xa3, 12310 0x8e, 0x36, 0xbe, 0x7f, 0x62, 0xa3, 0xa7, 0x05, 0xd8, 0xe8, 0xba, 0x4f, 0xc2, 0x41, 0x3e, 0x36, 12311 0x35, 0x63, 0xdb, 0x26, 0xd6, 0x3e, 0x69, 0xa7, 0x6f, 0xf0, 0x46, 0x8c, 0x03, 0x27, 0x48, 0xb1, 12312 0xa9, 0x39, 0x1e, 0x18, 0x9b, 0xda, 0x70, 0x78, 0x6a, 0x5b, 0x89, 0x5c, 0x38, 0x45, 0x9a, 0xf9, 12313 0xb1, 0x63, 0xf2, 0xc2, 0xbe, 0xa2, 0x6a, 0xca, 0xb6, 0x46, 0xca, 0xc5, 0xb0, 0x1f, 0xaf, 0x87, 12314 0xc9, 0x38, 0xca, 0x8f, 0xee, 0xc3, 0x94, 0x33, 0xb4, 0xa5, 0x2b, 0x1e, 0x48, 0x89, 0x83, 0xbc, 12315 0x20, 0x40, 0xa6, 0xd6, 0xa3, 0x0c, 0x38, 0x2e, 0x83, 0xde, 0x84, 0xf1, 0x96, 0xa1, 0x69, 0xdc, 12316 0x1f, 0x17, 0x8d, 0x9e, 0x4e, 0xcb, 0x23, 0x1c, 0x05, 0xb1, 0xf3, 0xb8, 0x18, 0xa2, 0xe0, 0x08, 12317 0x27, 0x22, 0x00, 0x2d, 0x37, 0xe1, 0xd8, 0x65, 0xe0, 0xf1, 0xf1, 0x7a, 0xd6, 0x18, 0xe0, 0xa5, 12318 0x2a, 0xbf, 0x06, 0xf0, 0x86, 0x6c, 0x1c, 0x00, 0x96, 0x7f, 0x2a, 0xc1, 0x5c, 0x4a, 0xe8, 0x40, 12319 0x6f, 0x87, 0x52, 0xec, 0x9f, 0x46, 0x52, 0xec, 0x85, 0x14, 0xb1, 0x40, 0x9e, 0xd5, 0x61, 0xcc, 12320 0x62, 0xb3, 0xd2, 0x3b, 0x0e, 0x8b, 0x88, 0x91, 0xb7, 0x06, 0x4c, 0x03, 0x07, 0x65, 0xfc, 0x98, 12321 0x3f, 0x75, 0x74, 0x58, 0x19, 0x0b, 0xd1, 0x70, 0x18, 0x5e, 0xfe, 0xf7, 0x1c, 0xc0, 0x12, 0x31, 12322 0x35, 0xa3, 0xdf, 0x25, 0xfa, 0x69, 0xd4, 0x50, 0x1b, 0xa1, 0x1a, 0xea, 0xda, 0xa0, 0xed, 0xf1, 12323 0x4c, 0x4b, 0x2d, 0xa2, 0xfe, 0x32, 0x52, 0x44, 0xd5, 0xb2, 0x43, 0x3e, 0xbd, 0x8a, 0xfa, 0x79, 12324 0x1e, 0xa6, 0x7d, 0x66, 0xbf, 0x8c, 0xba, 0x1b, 0xda, 0xe3, 0x3f, 0x89, 0xec, 0xf1, 0x5c, 0x82, 12325 0xc8, 0x73, 0xab, 0xa3, 0x9e, 0x7d, 0x3d, 0x83, 0x1e, 0xc1, 0x38, 0x2b, 0x9c, 0x1c, 0xf7, 0xe0, 12326 0x65, 0xd9, 0xf0, 0xb1, 0xcb, 0x32, 0x2f, 0x81, 0xae, 0x86, 0x90, 0x70, 0x04, 0x39, 0xa5, 0x0c, 12327 0x2c, 0x3e, 0xef, 0x32, 0x50, 0xfe, 0x52, 0x82, 0x71, 0x7f, 0x9b, 0x4e, 0xa1, 0x68, 0x5b, 0x0f, 12328 0x17, 0x6d, 0xaf, 0x64, 0x76, 0xd1, 0x94, 0xaa, 0xed, 0xd7, 0xac, 0xc0, 0xf7, 0x98, 0xd8, 0x01, 12329 0xdf, 0x56, 0x5a, 0x7b, 0x83, 0xbf, 0xf1, 0xd0, 0x67, 0x12, 0x20, 0x91, 0x05, 0x16, 0x74, 0xdd, 12330 0xa0, 0x8a, 0x13, 0x2b, 0x1d, 0xb3, 0x56, 0x32, 0x9b, 0xe5, 0x6a, 0xac, 0x6e, 0xc5, 0xb0, 0xee, 12331 0xe9, 0xd4, 0xea, 0xfb, 0x3b, 0x12, 0x67, 0xc0, 0x09, 0x06, 0x20, 0x05, 0xc0, 0x12, 0x98, 0x9b, 12332 0x86, 0x38, 0xc8, 0xd7, 0x32, 0xc4, 0x3c, 0x26, 0xb0, 0x68, 0xe8, 0x3b, 0x6a, 0xc7, 0x0f, 0x3b, 12333 0xd8, 0x03, 0xc2, 0x01, 0xd0, 0xf3, 0xf7, 0x60, 0x2e, 0xc5, 0x5a, 0x34, 0x09, 0xf9, 0x3d, 0xd2, 12334 0x77, 0x96, 0x0d, 0xb3, 0x3f, 0xd1, 0x0c, 0x0c, 0xed, 0x2b, 0x5a, 0xcf, 0x09, 0xbf, 0x23, 0xd8, 12335 0xf9, 0xf1, 0x66, 0xee, 0x8e, 0x24, 0x7f, 0x31, 0x14, 0xf4, 0x1d, 0x5e, 0x31, 0x5f, 0x61, 0x1f, 12336 0xad, 0xa6, 0xa6, 0xb6, 0x14, 0x5b, 0x14, 0x42, 0x67, 0x9d, 0x0f, 0x56, 0x67, 0x0c, 0x7b, 0xd4, 12337 0x50, 0x6d, 0x9d, 0x7b, 0xbe, 0xb5, 0x75, 0xfe, 0xd9, 0xd4, 0xd6, 0x7f, 0x0d, 0x25, 0xdb, 0xad, 12338 0xaa, 0x0b, 0x1c, 0xf2, 0xfa, 0x31, 0xe2, 0xab, 0x28, 0xa8, 0x3d, 0x05, 0x5e, 0x29, 0xed, 0x81, 12339 0x26, 0x15, 0xd1, 0x43, 0xc7, 0x2c, 0xa2, 0x9f, 0x69, 0xe1, 0xcb, 0x62, 0xaa, 0xa9, 0xf4, 0x6c, 12340 0xd2, 0xe6, 0x81, 0xa8, 0xe4, 0xc7, 0xd4, 0x06, 0x1f, 0xc5, 0x82, 0x8a, 0x3e, 0x0c, 0xb9, 0x6c, 12341 0xe9, 0x24, 0x2e, 0x3b, 0x9e, 0xee, 0xae, 0x68, 0x0b, 0xe6, 0x4c, 0xcb, 0xe8, 0x58, 0xc4, 0xb6, 12342 0x97, 0x88, 0xd2, 0xd6, 0x54, 0x9d, 0xb8, 0xeb, 0xe3, 0x54, 0x44, 0x17, 0x8e, 0x0e, 0x2b, 0x73, 12343 0x8d, 0x64, 0x16, 0x9c, 0x26, 0x2b, 0x3f, 0x2e, 0xc0, 0x64, 0x34, 0x03, 0xa6, 0x14, 0xa9, 0xd2, 12344 0x89, 0x8a, 0xd4, 0xab, 0x81, 0xc3, 0xe0, 0x54, 0xf0, 0x81, 0x1b, 0x9c, 0xd8, 0x81, 0x58, 0x80, 12345 0x09, 0x11, 0x0d, 0x5c, 0xa2, 0x28, 0xd3, 0xbd, 0xdd, 0xdf, 0x0a, 0x93, 0x71, 0x94, 0x9f, 0x95, 12346 0x9e, 0x7e, 0x45, 0xe9, 0x82, 0x14, 0xc2, 0xa5, 0xe7, 0x42, 0x94, 0x01, 0xc7, 0x65, 0xd0, 0x1a, 12347 0x4c, 0xf7, 0xf4, 0x38, 0x94, 0xe3, 0x8d, 0x17, 0x04, 0xd4, 0xf4, 0x56, 0x9c, 0x05, 0x27, 0xc9, 12348 0xa1, 0x9d, 0x50, 0x35, 0x3a, 0xcc, 0x23, 0xec, 0x8d, 0xcc, 0x67, 0x27, 0x73, 0x39, 0x8a, 0xee, 12349 0xc2, 0x98, 0xc5, 0xbf, 0x3b, 0x5c, 0x83, 0x9d, 0xda, 0xfd, 0x9c, 0x10, 0x1b, 0xc3, 0x41, 0x22, 12350 0x0e, 0xf3, 0x26, 0x94, 0xdb, 0xa5, 0xac, 0xe5, 0xb6, 0xfc, 0x63, 0x29, 0x98, 0x84, 0xbc, 0x12, 12351 0x78, 0xd0, 0x2d, 0x53, 0x4c, 0x22, 0x50, 0x1d, 0x19, 0xc9, 0xd5, 0xef, 0xed, 0x63, 0x55, 0xbf, 12352 0x7e, 0xf2, 0x1c, 0x5c, 0xfe, 0x7e, 0x2e, 0xc1, 0xec, 0x72, 0xf3, 0xbe, 0x65, 0xf4, 0x4c, 0xd7, 12353 0x9c, 0x0d, 0xd3, 0x59, 0xd7, 0x37, 0xa0, 0x60, 0xf5, 0x34, 0x77, 0x1e, 0x2f, 0xbb, 0xf3, 0xc0, 12354 0x3d, 0x8d, 0xcd, 0x63, 0x3a, 0x22, 0xe5, 0x4c, 0x82, 0x09, 0xa0, 0x75, 0x18, 0xb6, 0x14, 0xbd, 12355 0x43, 0xdc, 0xb4, 0x7a, 0x79, 0x80, 0xf5, 0x2b, 0x4b, 0x98, 0xb1, 0x07, 0x8a, 0x37, 0x2e, 0x8d, 12356 0x05, 0x8a, 0xfc, 0x4f, 0x12, 0x4c, 0x3c, 0xd8, 0xdc, 0x6c, 0xac, 0xe8, 0xfc, 0x44, 0xf3, 0xbb, 12357 0xd5, 0x4b, 0x50, 0x30, 0x15, 0xba, 0x1b, 0xcd, 0xf4, 0x8c, 0x86, 0x39, 0x05, 0xbd, 0x0f, 0x45, 12358 0x16, 0x49, 0x88, 0xde, 0xce, 0x58, 0x6a, 0x0b, 0xf8, 0xba, 0x23, 0xe4, 0x57, 0x88, 0x62, 0x00, 12359 0xbb, 0x70, 0xf2, 0x1e, 0xcc, 0x04, 0xcc, 0x61, 0xeb, 0xf1, 0x90, 0x65, 0x47, 0xd4, 0x84, 0x21, 12360 0xa6, 0x99, 0xe5, 0xc0, 0x7c, 0x86, 0xcb, 0xcc, 0xc8, 0x94, 0xfc, 0x4a, 0x87, 0xfd, 0xb2, 0xb1, 12361 0x83, 0x25, 0xaf, 0xc1, 0x18, 0xbf, 0x50, 0x36, 0x2c, 0xca, 0x97, 0x05, 0x5d, 0x84, 0x7c, 0x57, 12362 0xd5, 0x45, 0x9e, 0x1d, 0x15, 0x32, 0x79, 0x96, 0x23, 0xd8, 0x38, 0x27, 0x2b, 0x07, 0x22, 0xf2, 12363 0xf8, 0x64, 0xe5, 0x00, 0xb3, 0x71, 0xf9, 0x3e, 0x14, 0xc5, 0x72, 0x07, 0x81, 0xf2, 0x4f, 0x07, 12364 0xca, 0x27, 0x00, 0x6d, 0x40, 0x71, 0xa5, 0x51, 0xd7, 0x0c, 0xa7, 0xea, 0x6a, 0xa9, 0x6d, 0x2b, 12365 0xba, 0x17, 0x8b, 0x2b, 0x4b, 0x18, 0x73, 0x0a, 0x92, 0x61, 0x98, 0x1c, 0xb4, 0x88, 0x49, 0xb9, 12366 0x47, 0x8c, 0xd4, 0x81, 0xed, 0xf2, 0x3d, 0x3e, 0x82, 0x05, 0x45, 0xfe, 0xe7, 0x1c, 0x14, 0xc5, 12367 0x72, 0x9c, 0xc2, 0x57, 0xd8, 0x6a, 0xe8, 0x2b, 0xec, 0xd5, 0x6c, 0xae, 0x91, 0xfa, 0x09, 0xb6, 12368 0x19, 0xf9, 0x04, 0xbb, 0x9a, 0x11, 0xef, 0xe9, 0xdf, 0x5f, 0xff, 0x27, 0xc1, 0x78, 0xd8, 0x29, 12369 0xd1, 0x2d, 0x18, 0x65, 0x09, 0x47, 0x6d, 0x91, 0x75, 0xbf, 0xce, 0xf5, 0x2e, 0x61, 0x9a, 0x3e, 12370 0x09, 0x07, 0xf9, 0x50, 0xc7, 0x13, 0x63, 0x7e, 0x24, 0x26, 0x9d, 0xbe, 0xa4, 0x3d, 0xaa, 0x6a, 12371 0x55, 0xe7, 0x69, 0xa5, 0xba, 0xa2, 0xd3, 0x0d, 0xab, 0x49, 0x2d, 0x55, 0xef, 0xc4, 0x14, 0x71, 12372 0xa7, 0x0c, 0x22, 0xcb, 0x3f, 0x92, 0x60, 0x54, 0x98, 0x7c, 0x0a, 0x5f, 0x15, 0x7f, 0x11, 0xfe, 12373 0xaa, 0xb8, 0x9c, 0xf1, 0x80, 0x27, 0x7f, 0x52, 0xfc, 0x97, 0x6f, 0x3a, 0x3b, 0xd2, 0xcc, 0xab, 12374 0x77, 0x0d, 0x9b, 0x46, 0xbd, 0x9a, 0x1d, 0x46, 0xcc, 0x29, 0xa8, 0x07, 0x93, 0x6a, 0x24, 0x06, 12375 0x88, 0xa5, 0xad, 0x65, 0xb3, 0xc4, 0x13, 0xab, 0x97, 0x05, 0xfc, 0x64, 0x94, 0x82, 0x63, 0x2a, 12376 0x64, 0x02, 0x31, 0x2e, 0xf4, 0x1e, 0x14, 0x76, 0x29, 0x35, 0x13, 0xee, 0xab, 0x07, 0x44, 0x1e, 12377 0xdf, 0x84, 0x12, 0x9f, 0xdd, 0xe6, 0x66, 0x03, 0x73, 0x28, 0xf9, 0x37, 0xfe, 0x7a, 0x34, 0x1d, 12378 0x1f, 0xf7, 0xe2, 0xa9, 0x74, 0x92, 0x78, 0x3a, 0x9a, 0x14, 0x4b, 0xd1, 0x03, 0xc8, 0x53, 0x2d, 12379 0xeb, 0x67, 0xa1, 0x40, 0xdc, 0x5c, 0x6d, 0xfa, 0x01, 0x69, 0x73, 0xb5, 0x89, 0x19, 0x04, 0xda, 12380 0x80, 0x21, 0x96, 0x7d, 0xd8, 0x11, 0xcc, 0x67, 0x3f, 0xd2, 0x6c, 0xfe, 0xbe, 0x43, 0xb0, 0x5f, 12381 0x36, 0x76, 0x70, 0xe4, 0x4f, 0x60, 0x2c, 0x74, 0x4e, 0xd1, 0xc7, 0x70, 0x56, 0x33, 0x94, 0x76, 12382 0x5d, 0xd1, 0x14, 0xbd, 0x45, 0xdc, 0xc7, 0x81, 0xcb, 0x49, 0x5f, 0x18, 0xab, 0x01, 0x3e, 0x71, 12383 0xca, 0x67, 0x84, 0x92, 0xb3, 0x41, 0x1a, 0x0e, 0x21, 0xca, 0x0a, 0x80, 0x3f, 0x47, 0x54, 0x81, 12384 0x21, 0xe6, 0x67, 0x4e, 0x3e, 0x19, 0xa9, 0x8f, 0x30, 0x0b, 0x99, 0xfb, 0xd9, 0xd8, 0x19, 0x47, 12385 0x37, 0x00, 0x6c, 0xd2, 0xb2, 0x08, 0xe5, 0xc1, 0x20, 0x17, 0x7e, 0x60, 0x6c, 0x7a, 0x14, 0x1c, 12386 0xe0, 0x92, 0x7f, 0x22, 0xc1, 0xd8, 0x3a, 0xa1, 0x9f, 0x1a, 0xd6, 0x5e, 0xc3, 0xd0, 0xd4, 0x56, 12387 0xff, 0x14, 0x82, 0x2d, 0x0e, 0x05, 0xdb, 0xd7, 0x06, 0xec, 0x4c, 0xc8, 0xba, 0xb4, 0x90, 0x2b, 12388 0x7f, 0x29, 0xc1, 0x5c, 0x88, 0xf3, 0x9e, 0x7f, 0x74, 0xb7, 0x60, 0xc8, 0x34, 0x2c, 0xea, 0x26, 12389 0xe2, 0x63, 0x29, 0x64, 0x61, 0x2c, 0x90, 0x8a, 0x19, 0x0c, 0x76, 0xd0, 0xd0, 0x2a, 0xe4, 0xa8, 12390 0x21, 0x5c, 0xf5, 0x78, 0x98, 0x84, 0x58, 0x75, 0x10, 0x98, 0xb9, 0x4d, 0x03, 0xe7, 0xa8, 0xc1, 12391 0x36, 0xa2, 0x1c, 0xe2, 0x0a, 0x06, 0x9f, 0xe7, 0x34, 0x03, 0x0c, 0x85, 0x1d, 0xcb, 0xe8, 0x9e, 12392 0x78, 0x0e, 0xde, 0x46, 0x2c, 0x5b, 0x46, 0x17, 0x73, 0x2c, 0xf9, 0x2b, 0x09, 0xa6, 0x42, 0x9c, 12393 0xa7, 0x10, 0xf8, 0xdf, 0x0b, 0x07, 0xfe, 0xab, 0xc7, 0x99, 0x48, 0x4a, 0xf8, 0xff, 0x2a, 0x17, 12394 0x99, 0x06, 0x9b, 0x30, 0xda, 0x81, 0x51, 0xd3, 0x68, 0x37, 0x9f, 0xc1, 0x73, 0xe0, 0x04, 0xcb, 12395 0x9b, 0x0d, 0x1f, 0x0b, 0x07, 0x81, 0xd1, 0x01, 0x4c, 0xe9, 0x4a, 0x97, 0xd8, 0xa6, 0xd2, 0x22, 12396 0xcd, 0x67, 0x70, 0x41, 0x72, 0x8e, 0xbf, 0x37, 0x44, 0x11, 0x71, 0x5c, 0x09, 0x5a, 0x83, 0xa2, 12397 0x6a, 0xf2, 0x3a, 0x4e, 0xd4, 0x2e, 0x03, 0xb3, 0xa8, 0x53, 0xf5, 0x39, 0xf1, 0x5c, 0xfc, 0xc0, 12398 0x2e, 0x86, 0xfc, 0xdf, 0x51, 0x6f, 0x60, 0xfe, 0x87, 0xee, 0x43, 0x89, 0x37, 0x66, 0xb4, 0x0c, 12399 0xcd, 0x7d, 0x19, 0x60, 0x3b, 0xdb, 0x10, 0x63, 0x4f, 0x0e, 0x2b, 0x17, 0x12, 0x2e, 0x7d, 0x5d, 12400 0x32, 0xf6, 0x84, 0xd1, 0x3a, 0x14, 0xcc, 0x1f, 0x52, 0xc1, 0xf0, 0x24, 0xc7, 0xcb, 0x16, 0x8e, 12401 0x23, 0xff, 0x5d, 0x3e, 0x62, 0x2e, 0x4f, 0x75, 0x8f, 0x9e, 0xd9, 0xae, 0x7b, 0x15, 0x53, 0xea, 12402 0xce, 0x6f, 0x43, 0x51, 0x64, 0x78, 0xe1, 0xcc, 0x6f, 0x1c, 0xc7, 0x99, 0x83, 0x59, 0xcc, 0xfb, 12403 0x60, 0x71, 0x07, 0x5d, 0x60, 0xf4, 0x11, 0x0c, 0x13, 0x47, 0x85, 0x93, 0x1b, 0x6f, 0x1f, 0x47, 12404 0x85, 0x1f, 0x57, 0xfd, 0x42, 0x55, 0x8c, 0x09, 0x54, 0xf4, 0x36, 0x5b, 0x2f, 0xc6, 0xcb, 0x3e, 12405 0x02, 0xed, 0x72, 0x81, 0xa7, 0xab, 0x8b, 0xce, 0xb4, 0xbd, 0xe1, 0x27, 0x87, 0x15, 0xf0, 0x7f, 12406 0xe2, 0xa0, 0x84, 0xfc, 0x33, 0x09, 0xa6, 0xf8, 0x0a, 0xb5, 0x7a, 0x96, 0x4a, 0xfb, 0xa7, 0x96, 12407 0x98, 0x1e, 0x86, 0x12, 0xd3, 0xcd, 0x01, 0xcb, 0x12, 0xb3, 0x30, 0x35, 0x39, 0x7d, 0x2d, 0xc1, 12408 0xb9, 0x18, 0xf7, 0x29, 0xc4, 0xc5, 0xad, 0x70, 0x5c, 0x7c, 0xed, 0xb8, 0x13, 0x4a, 0x89, 0x8d, 12409 0xbf, 0x9d, 0x4c, 0x98, 0x0e, 0x3f, 0x29, 0x37, 0x00, 0x4c, 0x4b, 0xdd, 0x57, 0x35, 0xd2, 0x11, 12410 0x8f, 0xe0, 0xa5, 0x40, 0x8b, 0x93, 0x47, 0xc1, 0x01, 0x2e, 0x64, 0xc3, 0x6c, 0x9b, 0xec, 0x28, 12411 0x3d, 0x8d, 0x2e, 0xb4, 0xdb, 0x8b, 0x8a, 0xa9, 0x6c, 0xab, 0x9a, 0x4a, 0x55, 0x71, 0x5d, 0x30, 12412 0x52, 0xbf, 0xeb, 0x3c, 0x4e, 0x27, 0x71, 0x3c, 0x39, 0xac, 0x5c, 0x4c, 0x7a, 0x1d, 0x72, 0x59, 12413 0xfa, 0x38, 0x05, 0x1a, 0xf5, 0xa1, 0x6c, 0x91, 0x4f, 0x7a, 0xaa, 0x45, 0xda, 0x4b, 0x96, 0x61, 12414 0x86, 0xd4, 0xe6, 0xb9, 0xda, 0x3f, 0x3f, 0x3a, 0xac, 0x94, 0x71, 0x0a, 0xcf, 0x60, 0xc5, 0xa9, 12415 0xf0, 0xe8, 0x11, 0x4c, 0x2b, 0xa2, 0x19, 0x2d, 0xa8, 0xd5, 0x39, 0x25, 0x77, 0x8e, 0x0e, 0x2b, 12416 0xd3, 0x0b, 0x71, 0xf2, 0x60, 0x85, 0x49, 0xa0, 0xa8, 0x06, 0xc5, 0x7d, 0xde, 0xb7, 0x66, 0x97, 12417 0x87, 0x38, 0x3e, 0x4b, 0x04, 0x45, 0xa7, 0x95, 0x8d, 0x61, 0x0e, 0x2f, 0x37, 0xf9, 0xe9, 0x73, 12418 0xb9, 0xd8, 0x07, 0x25, 0xab, 0x25, 0xc5, 0x89, 0xe7, 0x37, 0xc6, 0x25, 0x3f, 0x6a, 0x3d, 0xf0, 12419 0x49, 0x38, 0xc8, 0x87, 0x3e, 0x84, 0x91, 0x5d, 0x71, 0x2b, 0x61, 0x97, 0x8b, 0x99, 0x92, 0x70, 12420 0xe8, 0x16, 0xa3, 0x3e, 0x25, 0x54, 0x8c, 0xb8, 0xc3, 0x36, 0xf6, 0x11, 0xd1, 0x2b, 0x50, 0xe4, 12421 0x3f, 0x56, 0x96, 0xf8, 0x75, 0x5c, 0xc9, 0x8f, 0x6d, 0x0f, 0x9c, 0x61, 0xec, 0xd2, 0x5d, 0xd6, 12422 0x95, 0xc6, 0x22, 0xbf, 0x16, 0x8e, 0xb0, 0xae, 0x34, 0x16, 0xb1, 0x4b, 0x47, 0x1f, 0x43, 0xd1, 12423 0x26, 0xab, 0xaa, 0xde, 0x3b, 0x28, 0x43, 0xa6, 0x47, 0xe5, 0xe6, 0x3d, 0xce, 0x1d, 0xb9, 0x18, 12424 0xf3, 0x35, 0x08, 0x3a, 0x76, 0x61, 0xd1, 0x2e, 0x8c, 0x58, 0x3d, 0x7d, 0xc1, 0xde, 0xb2, 0x89, 12425 0x55, 0x1e, 0xe5, 0x3a, 0x06, 0x85, 0x73, 0xec, 0xf2, 0x47, 0xb5, 0x78, 0x2b, 0xe4, 0x71, 0x60, 12426 0x1f, 0x1c, 0xfd, 0xa3, 0x04, 0xc8, 0xee, 0x99, 0xa6, 0x46, 0xba, 0x44, 0xa7, 0x8a, 0xc6, 0xef, 12427 0xe2, 0xec, 0xf2, 0x59, 0xae, 0xf3, 0x9d, 0x41, 0xf3, 0x8a, 0x09, 0x46, 0x95, 0x7b, 0x97, 0xde, 12428 0x71, 0x56, 0x9c, 0xa0, 0x97, 0x2d, 0xed, 0x8e, 0xcd, 0xff, 0x2e, 0x8f, 0x65, 0x5a, 0xda, 0xe4, 12429 0x3b, 0x47, 0x7f, 0x69, 0x05, 0x1d, 0xbb, 0xb0, 0xe8, 0x21, 0xcc, 0xba, 0x6d, 0x8f, 0xd8, 0x30, 12430 0xe8, 0xb2, 0xaa, 0x11, 0xbb, 0x6f, 0x53, 0xd2, 0x2d, 0x8f, 0xf3, 0x6d, 0xf7, 0x7a, 0x3f, 0x70, 12431 0x22, 0x17, 0x4e, 0x91, 0x46, 0x5d, 0xa8, 0xb8, 0x21, 0x83, 0x9d, 0x27, 0x2f, 0x66, 0xdd, 0xb3, 12432 0x5b, 0x8a, 0xe6, 0xbc, 0x03, 0x4c, 0x70, 0x05, 0x2f, 0x1f, 0x1d, 0x56, 0x2a, 0x4b, 0x4f, 0x67, 12433 0xc5, 0x83, 0xb0, 0xd0, 0xfb, 0x50, 0x56, 0xd2, 0xf4, 0x4c, 0x72, 0x3d, 0x2f, 0xb2, 0x38, 0x94, 12434 0xaa, 0x20, 0x55, 0x1a, 0x51, 0x98, 0x54, 0xc2, 0x0d, 0xa8, 0x76, 0x79, 0x2a, 0xd3, 0x45, 0x64, 12435 0xa4, 0x6f, 0xd5, 0xbf, 0x8c, 0x88, 0x10, 0x6c, 0x1c, 0xd3, 0x80, 0xfe, 0x06, 0x90, 0x12, 0xed, 12436 0x99, 0xb5, 0xcb, 0x28, 0x53, 0xfa, 0x89, 0x35, 0xdb, 0xfa, 0x6e, 0x17, 0x23, 0xd9, 0x38, 0x41, 12437 0x0f, 0x5a, 0x85, 0x19, 0x31, 0xba, 0xa5, 0xdb, 0xca, 0x0e, 0x69, 0xf6, 0xed, 0x16, 0xd5, 0xec, 12438 0xf2, 0x34, 0x8f, 0x7d, 0xfc, 0xe1, 0x6b, 0x21, 0x81, 0x8e, 0x13, 0xa5, 0xd0, 0x3b, 0x30, 0xb9, 12439 0x63, 0x58, 0xdb, 0x6a, 0xbb, 0x4d, 0x74, 0x17, 0x69, 0x86, 0x23, 0xcd, 0xb0, 0xd5, 0x58, 0x8e, 12440 0xd0, 0x70, 0x8c, 0x1b, 0xd9, 0x70, 0x4e, 0x20, 0x37, 0x2c, 0xa3, 0xb5, 0x66, 0xf4, 0x74, 0xea, 12441 0x94, 0x44, 0xe7, 0xbc, 0x14, 0x73, 0x6e, 0x21, 0x89, 0xe1, 0xc9, 0x61, 0xe5, 0x52, 0x72, 0x05, 12442 0xec, 0x33, 0xe1, 0x64, 0x6c, 0xb4, 0x0b, 0xc0, 0xe3, 0x82, 0x73, 0xfc, 0x66, 0xf9, 0xf1, 0xbb, 12443 0x93, 0x25, 0xea, 0x24, 0x9e, 0x40, 0xe7, 0x49, 0xce, 0x23, 0xe3, 0x00, 0x36, 0xfb, 0x4a, 0x51, 12444 0x22, 0x6d, 0xd5, 0x76, 0x79, 0x8e, 0xef, 0x75, 0x2d, 0xdb, 0x5e, 0x7b, 0x72, 0x81, 0xa7, 0xa9, 12445 0x28, 0x22, 0x8e, 0x2b, 0xe1, 0x5d, 0x3a, 0xe2, 0xcd, 0xe6, 0x74, 0x3a, 0x9d, 0x8f, 0xd7, 0xa5, 12446 0xe3, 0x9b, 0xf6, 0xcc, 0xba, 0x74, 0x02, 0x90, 0x4f, 0xbf, 0x25, 0xfe, 0x55, 0x0e, 0xa6, 0x7d, 12447 0xe6, 0xcc, 0x5d, 0x3a, 0x09, 0x22, 0x7f, 0xec, 0x76, 0x1e, 0xdc, 0xed, 0xfc, 0xa5, 0x04, 0xe3, 12448 0xfe, 0xd2, 0xfd, 0xfe, 0x75, 0xce, 0xf8, 0xb6, 0xa5, 0xd4, 0xf2, 0xff, 0x9b, 0x0b, 0x4e, 0xe0, 12449 0x0f, 0xbe, 0x7d, 0xe3, 0x87, 0xb7, 0x28, 0xcb, 0x5f, 0xe7, 0x61, 0x32, 0x7a, 0x1a, 0x43, 0xaf, 12450 0xfc, 0xd2, 0xc0, 0x57, 0xfe, 0x06, 0xcc, 0xec, 0xf4, 0x34, 0xad, 0xcf, 0x97, 0x21, 0xf0, 0xd4, 12451 0xef, 0xbc, 0xd2, 0xbd, 0x28, 0x24, 0x67, 0x96, 0x13, 0x78, 0x70, 0xa2, 0x64, 0x4a, 0xc7, 0x42, 12452 0xfe, 0x44, 0x1d, 0x0b, 0xb1, 0x07, 0xf4, 0xc2, 0x31, 0x1e, 0xd0, 0x13, 0xbb, 0x0f, 0x86, 0x4e, 12453 0xd0, 0x7d, 0x70, 0x92, 0x76, 0x81, 0x84, 0x20, 0x36, 0xb0, 0x7b, 0xf5, 0x45, 0x38, 0x2f, 0xc4, 12454 0x28, 0x7f, 0xc9, 0xd7, 0xa9, 0x65, 0x68, 0x1a, 0xb1, 0x96, 0x7a, 0xdd, 0x6e, 0x5f, 0x7e, 0x0b, 12455 0xc6, 0xc3, 0x3d, 0x2a, 0xce, 0x4e, 0x3b, 0x6d, 0x32, 0xe2, 0xad, 0x34, 0xb0, 0xd3, 0xce, 0x38, 12456 0xf6, 0x38, 0xe4, 0xbf, 0x97, 0x60, 0x36, 0xb9, 0x17, 0x15, 0x69, 0x30, 0xde, 0x55, 0x0e, 0x82, 12457 0xfd, 0xc1, 0xd2, 0x09, 0x6f, 0xb1, 0x78, 0x73, 0xc2, 0x5a, 0x08, 0x0b, 0x47, 0xb0, 0xe5, 0xef, 12458 0x25, 0x98, 0x4b, 0x69, 0x0b, 0x38, 0x5d, 0x4b, 0xd0, 0x07, 0x50, 0xea, 0x2a, 0x07, 0xcd, 0x9e, 12459 0xd5, 0x21, 0x27, 0xbe, 0xb7, 0xe3, 0x11, 0x63, 0x4d, 0xa0, 0x60, 0x0f, 0x4f, 0xfe, 0x4f, 0x09, 12460 0x5e, 0x48, 0xad, 0x65, 0xd0, 0xed, 0x50, 0x07, 0x83, 0x1c, 0xe9, 0x60, 0x40, 0x71, 0xc1, 0xe7, 12461 0xd4, 0xc0, 0xf0, 0xb9, 0x04, 0xe5, 0xb4, 0xef, 0x3c, 0x74, 0x2b, 0x64, 0xe4, 0x4b, 0x11, 0x23, 12462 0xa7, 0x62, 0x72, 0xcf, 0xc9, 0xc6, 0xff, 0x91, 0x60, 0x36, 0xf9, 0x7b, 0x17, 0xbd, 0x1e, 0xb2, 12463 0xb0, 0x12, 0xb1, 0x70, 0x22, 0x22, 0x25, 0xec, 0xfb, 0x08, 0xc6, 0xc5, 0x57, 0xb1, 0x80, 0x11, 12464 0x7b, 0x2f, 0x27, 0x45, 0x74, 0x01, 0xe1, 0xd6, 0xa0, 0xdc, 0xab, 0xc2, 0x63, 0x38, 0x82, 0x26, 12465 0xff, 0x43, 0x0e, 0x86, 0x9a, 0x2d, 0x45, 0x23, 0xa7, 0x50, 0x0c, 0xbe, 0x1b, 0x2a, 0x06, 0x07, 12466 0xfd, 0xc7, 0x11, 0xb7, 0x2a, 0xb5, 0x0e, 0xc4, 0x91, 0x3a, 0xf0, 0xd5, 0x4c, 0x68, 0x4f, 0x2f, 12467 0x01, 0xff, 0x0c, 0x46, 0x3c, 0xa5, 0xc7, 0xcb, 0x4c, 0xf2, 0x7f, 0xe4, 0x60, 0x34, 0xa0, 0xe2, 12468 0x98, 0x79, 0x6d, 0x27, 0x54, 0x0f, 0xe4, 0x33, 0x7c, 0x78, 0x04, 0x74, 0x55, 0xdd, 0x0a, 0xc0, 12469 0xe9, 0x98, 0xf5, 0x7b, 0x24, 0xe3, 0x85, 0xc1, 0x5b, 0x30, 0x4e, 0x15, 0xab, 0x43, 0xa8, 0x77, 12470 0x27, 0x9f, 0xe7, 0xbe, 0xe8, 0xf5, 0x59, 0x6f, 0x86, 0xa8, 0x38, 0xc2, 0x7d, 0xfe, 0x2e, 0x8c, 12471 0x85, 0x94, 0x1d, 0xab, 0xe1, 0xf5, 0xff, 0x25, 0x78, 0x69, 0xe0, 0x8d, 0x09, 0xaa, 0x87, 0x0e, 12472 0x49, 0x35, 0x72, 0x48, 0xe6, 0xd3, 0x01, 0x9e, 0x5f, 0xe3, 0x54, 0xfd, 0xda, 0xe3, 0xef, 0xe6, 12473 0xcf, 0x7c, 0xf3, 0xdd, 0xfc, 0x99, 0x6f, 0xbf, 0x9b, 0x3f, 0xf3, 0xb7, 0x47, 0xf3, 0xd2, 0xe3, 12474 0xa3, 0x79, 0xe9, 0x9b, 0xa3, 0x79, 0xe9, 0xdb, 0xa3, 0x79, 0xe9, 0x17, 0x47, 0xf3, 0xd2, 0xbf, 12475 0x7c, 0x3f, 0x7f, 0xe6, 0x83, 0xa2, 0x80, 0xfb, 0x5d, 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0xf0, 12476 0x40, 0xcd, 0xc4, 0x3c, 0x00, 0x00, 12477} 12478