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 RuntimeClassStrategyOptions 79 SELinuxStrategyOptions 80 Scale 81 ScaleSpec 82 ScaleStatus 83 SupplementalGroupsStrategyOptions 84*/ 85package v1beta1 86 87import proto "github.com/gogo/protobuf/proto" 88import fmt "fmt" 89import math "math" 90 91import k8s_io_api_core_v1 "k8s.io/api/core/v1" 92import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" 93 94import k8s_io_apimachinery_pkg_util_intstr "k8s.io/apimachinery/pkg/util/intstr" 95 96import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" 97 98import strings "strings" 99import reflect "reflect" 100 101import io "io" 102 103// Reference imports to suppress errors if they are not otherwise used. 104var _ = proto.Marshal 105var _ = fmt.Errorf 106var _ = math.Inf 107 108// This is a compile-time assertion to ensure that this generated file 109// is compatible with the proto package it is being compiled against. 110// A compilation error at this line likely means your copy of the 111// proto package needs to be updated. 112const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package 113 114func (m *AllowedCSIDriver) Reset() { *m = AllowedCSIDriver{} } 115func (*AllowedCSIDriver) ProtoMessage() {} 116func (*AllowedCSIDriver) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} } 117 118func (m *AllowedFlexVolume) Reset() { *m = AllowedFlexVolume{} } 119func (*AllowedFlexVolume) ProtoMessage() {} 120func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} } 121 122func (m *AllowedHostPath) Reset() { *m = AllowedHostPath{} } 123func (*AllowedHostPath) ProtoMessage() {} 124func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} } 125 126func (m *DaemonSet) Reset() { *m = DaemonSet{} } 127func (*DaemonSet) ProtoMessage() {} 128func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} } 129 130func (m *DaemonSetCondition) Reset() { *m = DaemonSetCondition{} } 131func (*DaemonSetCondition) ProtoMessage() {} 132func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} } 133 134func (m *DaemonSetList) Reset() { *m = DaemonSetList{} } 135func (*DaemonSetList) ProtoMessage() {} 136func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} } 137 138func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} } 139func (*DaemonSetSpec) ProtoMessage() {} 140func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} } 141 142func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} } 143func (*DaemonSetStatus) ProtoMessage() {} 144func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} } 145 146func (m *DaemonSetUpdateStrategy) Reset() { *m = DaemonSetUpdateStrategy{} } 147func (*DaemonSetUpdateStrategy) ProtoMessage() {} 148func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} } 149 150func (m *Deployment) Reset() { *m = Deployment{} } 151func (*Deployment) ProtoMessage() {} 152func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} } 153 154func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} } 155func (*DeploymentCondition) ProtoMessage() {} 156func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} } 157 158func (m *DeploymentList) Reset() { *m = DeploymentList{} } 159func (*DeploymentList) ProtoMessage() {} 160func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} } 161 162func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} } 163func (*DeploymentRollback) ProtoMessage() {} 164func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} } 165 166func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} } 167func (*DeploymentSpec) ProtoMessage() {} 168func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} } 169 170func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} } 171func (*DeploymentStatus) ProtoMessage() {} 172func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} } 173 174func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} } 175func (*DeploymentStrategy) ProtoMessage() {} 176func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} } 177 178func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} } 179func (*FSGroupStrategyOptions) ProtoMessage() {} 180func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} } 181 182func (m *HTTPIngressPath) Reset() { *m = HTTPIngressPath{} } 183func (*HTTPIngressPath) ProtoMessage() {} 184func (*HTTPIngressPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} } 185 186func (m *HTTPIngressRuleValue) Reset() { *m = HTTPIngressRuleValue{} } 187func (*HTTPIngressRuleValue) ProtoMessage() {} 188func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} } 189 190func (m *HostPortRange) Reset() { *m = HostPortRange{} } 191func (*HostPortRange) ProtoMessage() {} 192func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} } 193 194func (m *IDRange) Reset() { *m = IDRange{} } 195func (*IDRange) ProtoMessage() {} 196func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} } 197 198func (m *IPBlock) Reset() { *m = IPBlock{} } 199func (*IPBlock) ProtoMessage() {} 200func (*IPBlock) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} } 201 202func (m *Ingress) Reset() { *m = Ingress{} } 203func (*Ingress) ProtoMessage() {} 204func (*Ingress) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} } 205 206func (m *IngressBackend) Reset() { *m = IngressBackend{} } 207func (*IngressBackend) ProtoMessage() {} 208func (*IngressBackend) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} } 209 210func (m *IngressList) Reset() { *m = IngressList{} } 211func (*IngressList) ProtoMessage() {} 212func (*IngressList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} } 213 214func (m *IngressRule) Reset() { *m = IngressRule{} } 215func (*IngressRule) ProtoMessage() {} 216func (*IngressRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} } 217 218func (m *IngressRuleValue) Reset() { *m = IngressRuleValue{} } 219func (*IngressRuleValue) ProtoMessage() {} 220func (*IngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} } 221 222func (m *IngressSpec) Reset() { *m = IngressSpec{} } 223func (*IngressSpec) ProtoMessage() {} 224func (*IngressSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} } 225 226func (m *IngressStatus) Reset() { *m = IngressStatus{} } 227func (*IngressStatus) ProtoMessage() {} 228func (*IngressStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} } 229 230func (m *IngressTLS) Reset() { *m = IngressTLS{} } 231func (*IngressTLS) ProtoMessage() {} 232func (*IngressTLS) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} } 233 234func (m *NetworkPolicy) Reset() { *m = NetworkPolicy{} } 235func (*NetworkPolicy) ProtoMessage() {} 236func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} } 237 238func (m *NetworkPolicyEgressRule) Reset() { *m = NetworkPolicyEgressRule{} } 239func (*NetworkPolicyEgressRule) ProtoMessage() {} 240func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) { 241 return fileDescriptorGenerated, []int{31} 242} 243 244func (m *NetworkPolicyIngressRule) Reset() { *m = NetworkPolicyIngressRule{} } 245func (*NetworkPolicyIngressRule) ProtoMessage() {} 246func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) { 247 return fileDescriptorGenerated, []int{32} 248} 249 250func (m *NetworkPolicyList) Reset() { *m = NetworkPolicyList{} } 251func (*NetworkPolicyList) ProtoMessage() {} 252func (*NetworkPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} } 253 254func (m *NetworkPolicyPeer) Reset() { *m = NetworkPolicyPeer{} } 255func (*NetworkPolicyPeer) ProtoMessage() {} 256func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} } 257 258func (m *NetworkPolicyPort) Reset() { *m = NetworkPolicyPort{} } 259func (*NetworkPolicyPort) ProtoMessage() {} 260func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} } 261 262func (m *NetworkPolicySpec) Reset() { *m = NetworkPolicySpec{} } 263func (*NetworkPolicySpec) ProtoMessage() {} 264func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} } 265 266func (m *PodSecurityPolicy) Reset() { *m = PodSecurityPolicy{} } 267func (*PodSecurityPolicy) ProtoMessage() {} 268func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} } 269 270func (m *PodSecurityPolicyList) Reset() { *m = PodSecurityPolicyList{} } 271func (*PodSecurityPolicyList) ProtoMessage() {} 272func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} } 273 274func (m *PodSecurityPolicySpec) Reset() { *m = PodSecurityPolicySpec{} } 275func (*PodSecurityPolicySpec) ProtoMessage() {} 276func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} } 277 278func (m *ReplicaSet) Reset() { *m = ReplicaSet{} } 279func (*ReplicaSet) ProtoMessage() {} 280func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} } 281 282func (m *ReplicaSetCondition) Reset() { *m = ReplicaSetCondition{} } 283func (*ReplicaSetCondition) ProtoMessage() {} 284func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} } 285 286func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} } 287func (*ReplicaSetList) ProtoMessage() {} 288func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} } 289 290func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} } 291func (*ReplicaSetSpec) ProtoMessage() {} 292func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} } 293 294func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} } 295func (*ReplicaSetStatus) ProtoMessage() {} 296func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{44} } 297 298func (m *ReplicationControllerDummy) Reset() { *m = ReplicationControllerDummy{} } 299func (*ReplicationControllerDummy) ProtoMessage() {} 300func (*ReplicationControllerDummy) Descriptor() ([]byte, []int) { 301 return fileDescriptorGenerated, []int{45} 302} 303 304func (m *RollbackConfig) Reset() { *m = RollbackConfig{} } 305func (*RollbackConfig) ProtoMessage() {} 306func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{46} } 307 308func (m *RollingUpdateDaemonSet) Reset() { *m = RollingUpdateDaemonSet{} } 309func (*RollingUpdateDaemonSet) ProtoMessage() {} 310func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{47} } 311 312func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} } 313func (*RollingUpdateDeployment) ProtoMessage() {} 314func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) { 315 return fileDescriptorGenerated, []int{48} 316} 317 318func (m *RunAsGroupStrategyOptions) Reset() { *m = RunAsGroupStrategyOptions{} } 319func (*RunAsGroupStrategyOptions) ProtoMessage() {} 320func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) { 321 return fileDescriptorGenerated, []int{49} 322} 323 324func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} } 325func (*RunAsUserStrategyOptions) ProtoMessage() {} 326func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) { 327 return fileDescriptorGenerated, []int{50} 328} 329 330func (m *RuntimeClassStrategyOptions) Reset() { *m = RuntimeClassStrategyOptions{} } 331func (*RuntimeClassStrategyOptions) ProtoMessage() {} 332func (*RuntimeClassStrategyOptions) Descriptor() ([]byte, []int) { 333 return fileDescriptorGenerated, []int{51} 334} 335 336func (m *SELinuxStrategyOptions) Reset() { *m = SELinuxStrategyOptions{} } 337func (*SELinuxStrategyOptions) ProtoMessage() {} 338func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{52} } 339 340func (m *Scale) Reset() { *m = Scale{} } 341func (*Scale) ProtoMessage() {} 342func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{53} } 343 344func (m *ScaleSpec) Reset() { *m = ScaleSpec{} } 345func (*ScaleSpec) ProtoMessage() {} 346func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{54} } 347 348func (m *ScaleStatus) Reset() { *m = ScaleStatus{} } 349func (*ScaleStatus) ProtoMessage() {} 350func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{55} } 351 352func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} } 353func (*SupplementalGroupsStrategyOptions) ProtoMessage() {} 354func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) { 355 return fileDescriptorGenerated, []int{56} 356} 357 358func init() { 359 proto.RegisterType((*AllowedCSIDriver)(nil), "k8s.io.api.extensions.v1beta1.AllowedCSIDriver") 360 proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.extensions.v1beta1.AllowedFlexVolume") 361 proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.extensions.v1beta1.AllowedHostPath") 362 proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet") 363 proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition") 364 proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList") 365 proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec") 366 proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus") 367 proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy") 368 proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment") 369 proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition") 370 proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList") 371 proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback") 372 proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec") 373 proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus") 374 proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy") 375 proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.FSGroupStrategyOptions") 376 proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath") 377 proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue") 378 proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.extensions.v1beta1.HostPortRange") 379 proto.RegisterType((*IDRange)(nil), "k8s.io.api.extensions.v1beta1.IDRange") 380 proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock") 381 proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress") 382 proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend") 383 proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList") 384 proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule") 385 proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue") 386 proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec") 387 proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus") 388 proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS") 389 proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy") 390 proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule") 391 proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule") 392 proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList") 393 proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer") 394 proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort") 395 proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec") 396 proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicy") 397 proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicyList") 398 proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicySpec") 399 proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet") 400 proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition") 401 proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList") 402 proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec") 403 proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus") 404 proto.RegisterType((*ReplicationControllerDummy)(nil), "k8s.io.api.extensions.v1beta1.ReplicationControllerDummy") 405 proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig") 406 proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet") 407 proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment") 408 proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsGroupStrategyOptions") 409 proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsUserStrategyOptions") 410 proto.RegisterType((*RuntimeClassStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RuntimeClassStrategyOptions") 411 proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SELinuxStrategyOptions") 412 proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale") 413 proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec") 414 proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus") 415 proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SupplementalGroupsStrategyOptions") 416} 417func (m *AllowedCSIDriver) Marshal() (dAtA []byte, err error) { 418 size := m.Size() 419 dAtA = make([]byte, size) 420 n, err := m.MarshalTo(dAtA) 421 if err != nil { 422 return nil, err 423 } 424 return dAtA[:n], nil 425} 426 427func (m *AllowedCSIDriver) MarshalTo(dAtA []byte) (int, error) { 428 var i int 429 _ = i 430 var l int 431 _ = l 432 dAtA[i] = 0xa 433 i++ 434 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) 435 i += copy(dAtA[i:], m.Name) 436 return i, nil 437} 438 439func (m *AllowedFlexVolume) Marshal() (dAtA []byte, err error) { 440 size := m.Size() 441 dAtA = make([]byte, size) 442 n, err := m.MarshalTo(dAtA) 443 if err != nil { 444 return nil, err 445 } 446 return dAtA[:n], nil 447} 448 449func (m *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) { 450 var i int 451 _ = i 452 var l int 453 _ = l 454 dAtA[i] = 0xa 455 i++ 456 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver))) 457 i += copy(dAtA[i:], m.Driver) 458 return i, nil 459} 460 461func (m *AllowedHostPath) Marshal() (dAtA []byte, err error) { 462 size := m.Size() 463 dAtA = make([]byte, size) 464 n, err := m.MarshalTo(dAtA) 465 if err != nil { 466 return nil, err 467 } 468 return dAtA[:n], nil 469} 470 471func (m *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) { 472 var i int 473 _ = i 474 var l int 475 _ = l 476 dAtA[i] = 0xa 477 i++ 478 i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix))) 479 i += copy(dAtA[i:], m.PathPrefix) 480 dAtA[i] = 0x10 481 i++ 482 if m.ReadOnly { 483 dAtA[i] = 1 484 } else { 485 dAtA[i] = 0 486 } 487 i++ 488 return i, nil 489} 490 491func (m *DaemonSet) Marshal() (dAtA []byte, err error) { 492 size := m.Size() 493 dAtA = make([]byte, size) 494 n, err := m.MarshalTo(dAtA) 495 if err != nil { 496 return nil, err 497 } 498 return dAtA[:n], nil 499} 500 501func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) { 502 var i int 503 _ = i 504 var l int 505 _ = l 506 dAtA[i] = 0xa 507 i++ 508 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 509 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 510 if err != nil { 511 return 0, err 512 } 513 i += n1 514 dAtA[i] = 0x12 515 i++ 516 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 517 n2, err := m.Spec.MarshalTo(dAtA[i:]) 518 if err != nil { 519 return 0, err 520 } 521 i += n2 522 dAtA[i] = 0x1a 523 i++ 524 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 525 n3, err := m.Status.MarshalTo(dAtA[i:]) 526 if err != nil { 527 return 0, err 528 } 529 i += n3 530 return i, nil 531} 532 533func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) { 534 size := m.Size() 535 dAtA = make([]byte, size) 536 n, err := m.MarshalTo(dAtA) 537 if err != nil { 538 return nil, err 539 } 540 return dAtA[:n], nil 541} 542 543func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) { 544 var i int 545 _ = i 546 var l int 547 _ = l 548 dAtA[i] = 0xa 549 i++ 550 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 551 i += copy(dAtA[i:], m.Type) 552 dAtA[i] = 0x12 553 i++ 554 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) 555 i += copy(dAtA[i:], m.Status) 556 dAtA[i] = 0x1a 557 i++ 558 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size())) 559 n4, err := m.LastTransitionTime.MarshalTo(dAtA[i:]) 560 if err != nil { 561 return 0, err 562 } 563 i += n4 564 dAtA[i] = 0x22 565 i++ 566 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) 567 i += copy(dAtA[i:], m.Reason) 568 dAtA[i] = 0x2a 569 i++ 570 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) 571 i += copy(dAtA[i:], m.Message) 572 return i, nil 573} 574 575func (m *DaemonSetList) Marshal() (dAtA []byte, err error) { 576 size := m.Size() 577 dAtA = make([]byte, size) 578 n, err := m.MarshalTo(dAtA) 579 if err != nil { 580 return nil, err 581 } 582 return dAtA[:n], nil 583} 584 585func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) { 586 var i int 587 _ = i 588 var l int 589 _ = l 590 dAtA[i] = 0xa 591 i++ 592 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 593 n5, err := m.ListMeta.MarshalTo(dAtA[i:]) 594 if err != nil { 595 return 0, err 596 } 597 i += n5 598 if len(m.Items) > 0 { 599 for _, msg := range m.Items { 600 dAtA[i] = 0x12 601 i++ 602 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 603 n, err := msg.MarshalTo(dAtA[i:]) 604 if err != nil { 605 return 0, err 606 } 607 i += n 608 } 609 } 610 return i, nil 611} 612 613func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) { 614 size := m.Size() 615 dAtA = make([]byte, size) 616 n, err := m.MarshalTo(dAtA) 617 if err != nil { 618 return nil, err 619 } 620 return dAtA[:n], nil 621} 622 623func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) { 624 var i int 625 _ = i 626 var l int 627 _ = l 628 if m.Selector != nil { 629 dAtA[i] = 0xa 630 i++ 631 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size())) 632 n6, err := m.Selector.MarshalTo(dAtA[i:]) 633 if err != nil { 634 return 0, err 635 } 636 i += n6 637 } 638 dAtA[i] = 0x12 639 i++ 640 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size())) 641 n7, err := m.Template.MarshalTo(dAtA[i:]) 642 if err != nil { 643 return 0, err 644 } 645 i += n7 646 dAtA[i] = 0x1a 647 i++ 648 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdateStrategy.Size())) 649 n8, err := m.UpdateStrategy.MarshalTo(dAtA[i:]) 650 if err != nil { 651 return 0, err 652 } 653 i += n8 654 dAtA[i] = 0x20 655 i++ 656 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) 657 dAtA[i] = 0x28 658 i++ 659 i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration)) 660 if m.RevisionHistoryLimit != nil { 661 dAtA[i] = 0x30 662 i++ 663 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) 664 } 665 return i, nil 666} 667 668func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) { 669 size := m.Size() 670 dAtA = make([]byte, size) 671 n, err := m.MarshalTo(dAtA) 672 if err != nil { 673 return nil, err 674 } 675 return dAtA[:n], nil 676} 677 678func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) { 679 var i int 680 _ = i 681 var l int 682 _ = l 683 dAtA[i] = 0x8 684 i++ 685 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled)) 686 dAtA[i] = 0x10 687 i++ 688 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled)) 689 dAtA[i] = 0x18 690 i++ 691 i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled)) 692 dAtA[i] = 0x20 693 i++ 694 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady)) 695 dAtA[i] = 0x28 696 i++ 697 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) 698 dAtA[i] = 0x30 699 i++ 700 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled)) 701 dAtA[i] = 0x38 702 i++ 703 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable)) 704 dAtA[i] = 0x40 705 i++ 706 i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable)) 707 if m.CollisionCount != nil { 708 dAtA[i] = 0x48 709 i++ 710 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) 711 } 712 if len(m.Conditions) > 0 { 713 for _, msg := range m.Conditions { 714 dAtA[i] = 0x52 715 i++ 716 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 717 n, err := msg.MarshalTo(dAtA[i:]) 718 if err != nil { 719 return 0, err 720 } 721 i += n 722 } 723 } 724 return i, nil 725} 726 727func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) { 728 size := m.Size() 729 dAtA = make([]byte, size) 730 n, err := m.MarshalTo(dAtA) 731 if err != nil { 732 return nil, err 733 } 734 return dAtA[:n], nil 735} 736 737func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) { 738 var i int 739 _ = i 740 var l int 741 _ = l 742 dAtA[i] = 0xa 743 i++ 744 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 745 i += copy(dAtA[i:], m.Type) 746 if m.RollingUpdate != nil { 747 dAtA[i] = 0x12 748 i++ 749 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size())) 750 n9, err := m.RollingUpdate.MarshalTo(dAtA[i:]) 751 if err != nil { 752 return 0, err 753 } 754 i += n9 755 } 756 return i, nil 757} 758 759func (m *Deployment) Marshal() (dAtA []byte, err error) { 760 size := m.Size() 761 dAtA = make([]byte, size) 762 n, err := m.MarshalTo(dAtA) 763 if err != nil { 764 return nil, err 765 } 766 return dAtA[:n], nil 767} 768 769func (m *Deployment) MarshalTo(dAtA []byte) (int, error) { 770 var i int 771 _ = i 772 var l int 773 _ = l 774 dAtA[i] = 0xa 775 i++ 776 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 777 n10, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 778 if err != nil { 779 return 0, err 780 } 781 i += n10 782 dAtA[i] = 0x12 783 i++ 784 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 785 n11, err := m.Spec.MarshalTo(dAtA[i:]) 786 if err != nil { 787 return 0, err 788 } 789 i += n11 790 dAtA[i] = 0x1a 791 i++ 792 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 793 n12, err := m.Status.MarshalTo(dAtA[i:]) 794 if err != nil { 795 return 0, err 796 } 797 i += n12 798 return i, nil 799} 800 801func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) { 802 size := m.Size() 803 dAtA = make([]byte, size) 804 n, err := m.MarshalTo(dAtA) 805 if err != nil { 806 return nil, err 807 } 808 return dAtA[:n], nil 809} 810 811func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) { 812 var i int 813 _ = i 814 var l int 815 _ = l 816 dAtA[i] = 0xa 817 i++ 818 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 819 i += copy(dAtA[i:], m.Type) 820 dAtA[i] = 0x12 821 i++ 822 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) 823 i += copy(dAtA[i:], m.Status) 824 dAtA[i] = 0x22 825 i++ 826 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) 827 i += copy(dAtA[i:], m.Reason) 828 dAtA[i] = 0x2a 829 i++ 830 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) 831 i += copy(dAtA[i:], m.Message) 832 dAtA[i] = 0x32 833 i++ 834 i = encodeVarintGenerated(dAtA, i, uint64(m.LastUpdateTime.Size())) 835 n13, err := m.LastUpdateTime.MarshalTo(dAtA[i:]) 836 if err != nil { 837 return 0, err 838 } 839 i += n13 840 dAtA[i] = 0x3a 841 i++ 842 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size())) 843 n14, err := m.LastTransitionTime.MarshalTo(dAtA[i:]) 844 if err != nil { 845 return 0, err 846 } 847 i += n14 848 return i, nil 849} 850 851func (m *DeploymentList) Marshal() (dAtA []byte, err error) { 852 size := m.Size() 853 dAtA = make([]byte, size) 854 n, err := m.MarshalTo(dAtA) 855 if err != nil { 856 return nil, err 857 } 858 return dAtA[:n], nil 859} 860 861func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) { 862 var i int 863 _ = i 864 var l int 865 _ = l 866 dAtA[i] = 0xa 867 i++ 868 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 869 n15, err := m.ListMeta.MarshalTo(dAtA[i:]) 870 if err != nil { 871 return 0, err 872 } 873 i += n15 874 if len(m.Items) > 0 { 875 for _, msg := range m.Items { 876 dAtA[i] = 0x12 877 i++ 878 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 879 n, err := msg.MarshalTo(dAtA[i:]) 880 if err != nil { 881 return 0, err 882 } 883 i += n 884 } 885 } 886 return i, nil 887} 888 889func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) { 890 size := m.Size() 891 dAtA = make([]byte, size) 892 n, err := m.MarshalTo(dAtA) 893 if err != nil { 894 return nil, err 895 } 896 return dAtA[:n], nil 897} 898 899func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) { 900 var i int 901 _ = i 902 var l int 903 _ = l 904 dAtA[i] = 0xa 905 i++ 906 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) 907 i += copy(dAtA[i:], m.Name) 908 if len(m.UpdatedAnnotations) > 0 { 909 keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations)) 910 for k := range m.UpdatedAnnotations { 911 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k)) 912 } 913 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations) 914 for _, k := range keysForUpdatedAnnotations { 915 dAtA[i] = 0x12 916 i++ 917 v := m.UpdatedAnnotations[string(k)] 918 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 919 i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) 920 dAtA[i] = 0xa 921 i++ 922 i = encodeVarintGenerated(dAtA, i, uint64(len(k))) 923 i += copy(dAtA[i:], k) 924 dAtA[i] = 0x12 925 i++ 926 i = encodeVarintGenerated(dAtA, i, uint64(len(v))) 927 i += copy(dAtA[i:], v) 928 } 929 } 930 dAtA[i] = 0x1a 931 i++ 932 i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size())) 933 n16, err := m.RollbackTo.MarshalTo(dAtA[i:]) 934 if err != nil { 935 return 0, err 936 } 937 i += n16 938 return i, nil 939} 940 941func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) { 942 size := m.Size() 943 dAtA = make([]byte, size) 944 n, err := m.MarshalTo(dAtA) 945 if err != nil { 946 return nil, err 947 } 948 return dAtA[:n], nil 949} 950 951func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) { 952 var i int 953 _ = i 954 var l int 955 _ = l 956 if m.Replicas != nil { 957 dAtA[i] = 0x8 958 i++ 959 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) 960 } 961 if m.Selector != nil { 962 dAtA[i] = 0x12 963 i++ 964 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size())) 965 n17, err := m.Selector.MarshalTo(dAtA[i:]) 966 if err != nil { 967 return 0, err 968 } 969 i += n17 970 } 971 dAtA[i] = 0x1a 972 i++ 973 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size())) 974 n18, err := m.Template.MarshalTo(dAtA[i:]) 975 if err != nil { 976 return 0, err 977 } 978 i += n18 979 dAtA[i] = 0x22 980 i++ 981 i = encodeVarintGenerated(dAtA, i, uint64(m.Strategy.Size())) 982 n19, err := m.Strategy.MarshalTo(dAtA[i:]) 983 if err != nil { 984 return 0, err 985 } 986 i += n19 987 dAtA[i] = 0x28 988 i++ 989 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) 990 if m.RevisionHistoryLimit != nil { 991 dAtA[i] = 0x30 992 i++ 993 i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) 994 } 995 dAtA[i] = 0x38 996 i++ 997 if m.Paused { 998 dAtA[i] = 1 999 } else { 1000 dAtA[i] = 0 1001 } 1002 i++ 1003 if m.RollbackTo != nil { 1004 dAtA[i] = 0x42 1005 i++ 1006 i = encodeVarintGenerated(dAtA, i, uint64(m.RollbackTo.Size())) 1007 n20, err := m.RollbackTo.MarshalTo(dAtA[i:]) 1008 if err != nil { 1009 return 0, err 1010 } 1011 i += n20 1012 } 1013 if m.ProgressDeadlineSeconds != nil { 1014 dAtA[i] = 0x48 1015 i++ 1016 i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds)) 1017 } 1018 return i, nil 1019} 1020 1021func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) { 1022 size := m.Size() 1023 dAtA = make([]byte, size) 1024 n, err := m.MarshalTo(dAtA) 1025 if err != nil { 1026 return nil, err 1027 } 1028 return dAtA[:n], nil 1029} 1030 1031func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) { 1032 var i int 1033 _ = i 1034 var l int 1035 _ = l 1036 dAtA[i] = 0x8 1037 i++ 1038 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) 1039 dAtA[i] = 0x10 1040 i++ 1041 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 1042 dAtA[i] = 0x18 1043 i++ 1044 i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas)) 1045 dAtA[i] = 0x20 1046 i++ 1047 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) 1048 dAtA[i] = 0x28 1049 i++ 1050 i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas)) 1051 if len(m.Conditions) > 0 { 1052 for _, msg := range m.Conditions { 1053 dAtA[i] = 0x32 1054 i++ 1055 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1056 n, err := msg.MarshalTo(dAtA[i:]) 1057 if err != nil { 1058 return 0, err 1059 } 1060 i += n 1061 } 1062 } 1063 dAtA[i] = 0x38 1064 i++ 1065 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) 1066 if m.CollisionCount != nil { 1067 dAtA[i] = 0x40 1068 i++ 1069 i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) 1070 } 1071 return i, nil 1072} 1073 1074func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) { 1075 size := m.Size() 1076 dAtA = make([]byte, size) 1077 n, err := m.MarshalTo(dAtA) 1078 if err != nil { 1079 return nil, err 1080 } 1081 return dAtA[:n], nil 1082} 1083 1084func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) { 1085 var i int 1086 _ = i 1087 var l int 1088 _ = l 1089 dAtA[i] = 0xa 1090 i++ 1091 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 1092 i += copy(dAtA[i:], m.Type) 1093 if m.RollingUpdate != nil { 1094 dAtA[i] = 0x12 1095 i++ 1096 i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size())) 1097 n21, err := m.RollingUpdate.MarshalTo(dAtA[i:]) 1098 if err != nil { 1099 return 0, err 1100 } 1101 i += n21 1102 } 1103 return i, nil 1104} 1105 1106func (m *FSGroupStrategyOptions) Marshal() (dAtA []byte, err error) { 1107 size := m.Size() 1108 dAtA = make([]byte, size) 1109 n, err := m.MarshalTo(dAtA) 1110 if err != nil { 1111 return nil, err 1112 } 1113 return dAtA[:n], nil 1114} 1115 1116func (m *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 1117 var i int 1118 _ = i 1119 var l int 1120 _ = l 1121 dAtA[i] = 0xa 1122 i++ 1123 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 1124 i += copy(dAtA[i:], m.Rule) 1125 if len(m.Ranges) > 0 { 1126 for _, msg := range m.Ranges { 1127 dAtA[i] = 0x12 1128 i++ 1129 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1130 n, err := msg.MarshalTo(dAtA[i:]) 1131 if err != nil { 1132 return 0, err 1133 } 1134 i += n 1135 } 1136 } 1137 return i, nil 1138} 1139 1140func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) { 1141 size := m.Size() 1142 dAtA = make([]byte, size) 1143 n, err := m.MarshalTo(dAtA) 1144 if err != nil { 1145 return nil, err 1146 } 1147 return dAtA[:n], nil 1148} 1149 1150func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) { 1151 var i int 1152 _ = i 1153 var l int 1154 _ = l 1155 dAtA[i] = 0xa 1156 i++ 1157 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path))) 1158 i += copy(dAtA[i:], m.Path) 1159 dAtA[i] = 0x12 1160 i++ 1161 i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size())) 1162 n22, err := m.Backend.MarshalTo(dAtA[i:]) 1163 if err != nil { 1164 return 0, err 1165 } 1166 i += n22 1167 return i, nil 1168} 1169 1170func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) { 1171 size := m.Size() 1172 dAtA = make([]byte, size) 1173 n, err := m.MarshalTo(dAtA) 1174 if err != nil { 1175 return nil, err 1176 } 1177 return dAtA[:n], nil 1178} 1179 1180func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) { 1181 var i int 1182 _ = i 1183 var l int 1184 _ = l 1185 if len(m.Paths) > 0 { 1186 for _, msg := range m.Paths { 1187 dAtA[i] = 0xa 1188 i++ 1189 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1190 n, err := msg.MarshalTo(dAtA[i:]) 1191 if err != nil { 1192 return 0, err 1193 } 1194 i += n 1195 } 1196 } 1197 return i, nil 1198} 1199 1200func (m *HostPortRange) Marshal() (dAtA []byte, err error) { 1201 size := m.Size() 1202 dAtA = make([]byte, size) 1203 n, err := m.MarshalTo(dAtA) 1204 if err != nil { 1205 return nil, err 1206 } 1207 return dAtA[:n], nil 1208} 1209 1210func (m *HostPortRange) MarshalTo(dAtA []byte) (int, error) { 1211 var i int 1212 _ = i 1213 var l int 1214 _ = l 1215 dAtA[i] = 0x8 1216 i++ 1217 i = encodeVarintGenerated(dAtA, i, uint64(m.Min)) 1218 dAtA[i] = 0x10 1219 i++ 1220 i = encodeVarintGenerated(dAtA, i, uint64(m.Max)) 1221 return i, nil 1222} 1223 1224func (m *IDRange) Marshal() (dAtA []byte, err error) { 1225 size := m.Size() 1226 dAtA = make([]byte, size) 1227 n, err := m.MarshalTo(dAtA) 1228 if err != nil { 1229 return nil, err 1230 } 1231 return dAtA[:n], nil 1232} 1233 1234func (m *IDRange) MarshalTo(dAtA []byte) (int, error) { 1235 var i int 1236 _ = i 1237 var l int 1238 _ = l 1239 dAtA[i] = 0x8 1240 i++ 1241 i = encodeVarintGenerated(dAtA, i, uint64(m.Min)) 1242 dAtA[i] = 0x10 1243 i++ 1244 i = encodeVarintGenerated(dAtA, i, uint64(m.Max)) 1245 return i, nil 1246} 1247 1248func (m *IPBlock) Marshal() (dAtA []byte, err error) { 1249 size := m.Size() 1250 dAtA = make([]byte, size) 1251 n, err := m.MarshalTo(dAtA) 1252 if err != nil { 1253 return nil, err 1254 } 1255 return dAtA[:n], nil 1256} 1257 1258func (m *IPBlock) MarshalTo(dAtA []byte) (int, error) { 1259 var i int 1260 _ = i 1261 var l int 1262 _ = l 1263 dAtA[i] = 0xa 1264 i++ 1265 i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR))) 1266 i += copy(dAtA[i:], m.CIDR) 1267 if len(m.Except) > 0 { 1268 for _, s := range m.Except { 1269 dAtA[i] = 0x12 1270 i++ 1271 l = len(s) 1272 for l >= 1<<7 { 1273 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1274 l >>= 7 1275 i++ 1276 } 1277 dAtA[i] = uint8(l) 1278 i++ 1279 i += copy(dAtA[i:], s) 1280 } 1281 } 1282 return i, nil 1283} 1284 1285func (m *Ingress) Marshal() (dAtA []byte, err error) { 1286 size := m.Size() 1287 dAtA = make([]byte, size) 1288 n, err := m.MarshalTo(dAtA) 1289 if err != nil { 1290 return nil, err 1291 } 1292 return dAtA[:n], nil 1293} 1294 1295func (m *Ingress) MarshalTo(dAtA []byte) (int, error) { 1296 var i int 1297 _ = i 1298 var l int 1299 _ = l 1300 dAtA[i] = 0xa 1301 i++ 1302 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 1303 n23, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 1304 if err != nil { 1305 return 0, err 1306 } 1307 i += n23 1308 dAtA[i] = 0x12 1309 i++ 1310 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 1311 n24, err := m.Spec.MarshalTo(dAtA[i:]) 1312 if err != nil { 1313 return 0, err 1314 } 1315 i += n24 1316 dAtA[i] = 0x1a 1317 i++ 1318 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 1319 n25, err := m.Status.MarshalTo(dAtA[i:]) 1320 if err != nil { 1321 return 0, err 1322 } 1323 i += n25 1324 return i, nil 1325} 1326 1327func (m *IngressBackend) Marshal() (dAtA []byte, err error) { 1328 size := m.Size() 1329 dAtA = make([]byte, size) 1330 n, err := m.MarshalTo(dAtA) 1331 if err != nil { 1332 return nil, err 1333 } 1334 return dAtA[:n], nil 1335} 1336 1337func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) { 1338 var i int 1339 _ = i 1340 var l int 1341 _ = l 1342 dAtA[i] = 0xa 1343 i++ 1344 i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName))) 1345 i += copy(dAtA[i:], m.ServiceName) 1346 dAtA[i] = 0x12 1347 i++ 1348 i = encodeVarintGenerated(dAtA, i, uint64(m.ServicePort.Size())) 1349 n26, err := m.ServicePort.MarshalTo(dAtA[i:]) 1350 if err != nil { 1351 return 0, err 1352 } 1353 i += n26 1354 return i, nil 1355} 1356 1357func (m *IngressList) Marshal() (dAtA []byte, err error) { 1358 size := m.Size() 1359 dAtA = make([]byte, size) 1360 n, err := m.MarshalTo(dAtA) 1361 if err != nil { 1362 return nil, err 1363 } 1364 return dAtA[:n], nil 1365} 1366 1367func (m *IngressList) MarshalTo(dAtA []byte) (int, error) { 1368 var i int 1369 _ = i 1370 var l int 1371 _ = l 1372 dAtA[i] = 0xa 1373 i++ 1374 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 1375 n27, err := m.ListMeta.MarshalTo(dAtA[i:]) 1376 if err != nil { 1377 return 0, err 1378 } 1379 i += n27 1380 if len(m.Items) > 0 { 1381 for _, msg := range m.Items { 1382 dAtA[i] = 0x12 1383 i++ 1384 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1385 n, err := msg.MarshalTo(dAtA[i:]) 1386 if err != nil { 1387 return 0, err 1388 } 1389 i += n 1390 } 1391 } 1392 return i, nil 1393} 1394 1395func (m *IngressRule) Marshal() (dAtA []byte, err error) { 1396 size := m.Size() 1397 dAtA = make([]byte, size) 1398 n, err := m.MarshalTo(dAtA) 1399 if err != nil { 1400 return nil, err 1401 } 1402 return dAtA[:n], nil 1403} 1404 1405func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) { 1406 var i int 1407 _ = i 1408 var l int 1409 _ = l 1410 dAtA[i] = 0xa 1411 i++ 1412 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host))) 1413 i += copy(dAtA[i:], m.Host) 1414 dAtA[i] = 0x12 1415 i++ 1416 i = encodeVarintGenerated(dAtA, i, uint64(m.IngressRuleValue.Size())) 1417 n28, err := m.IngressRuleValue.MarshalTo(dAtA[i:]) 1418 if err != nil { 1419 return 0, err 1420 } 1421 i += n28 1422 return i, nil 1423} 1424 1425func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) { 1426 size := m.Size() 1427 dAtA = make([]byte, size) 1428 n, err := m.MarshalTo(dAtA) 1429 if err != nil { 1430 return nil, err 1431 } 1432 return dAtA[:n], nil 1433} 1434 1435func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) { 1436 var i int 1437 _ = i 1438 var l int 1439 _ = l 1440 if m.HTTP != nil { 1441 dAtA[i] = 0xa 1442 i++ 1443 i = encodeVarintGenerated(dAtA, i, uint64(m.HTTP.Size())) 1444 n29, err := m.HTTP.MarshalTo(dAtA[i:]) 1445 if err != nil { 1446 return 0, err 1447 } 1448 i += n29 1449 } 1450 return i, nil 1451} 1452 1453func (m *IngressSpec) Marshal() (dAtA []byte, err error) { 1454 size := m.Size() 1455 dAtA = make([]byte, size) 1456 n, err := m.MarshalTo(dAtA) 1457 if err != nil { 1458 return nil, err 1459 } 1460 return dAtA[:n], nil 1461} 1462 1463func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) { 1464 var i int 1465 _ = i 1466 var l int 1467 _ = l 1468 if m.Backend != nil { 1469 dAtA[i] = 0xa 1470 i++ 1471 i = encodeVarintGenerated(dAtA, i, uint64(m.Backend.Size())) 1472 n30, err := m.Backend.MarshalTo(dAtA[i:]) 1473 if err != nil { 1474 return 0, err 1475 } 1476 i += n30 1477 } 1478 if len(m.TLS) > 0 { 1479 for _, msg := range m.TLS { 1480 dAtA[i] = 0x12 1481 i++ 1482 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1483 n, err := msg.MarshalTo(dAtA[i:]) 1484 if err != nil { 1485 return 0, err 1486 } 1487 i += n 1488 } 1489 } 1490 if len(m.Rules) > 0 { 1491 for _, msg := range m.Rules { 1492 dAtA[i] = 0x1a 1493 i++ 1494 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1495 n, err := msg.MarshalTo(dAtA[i:]) 1496 if err != nil { 1497 return 0, err 1498 } 1499 i += n 1500 } 1501 } 1502 return i, nil 1503} 1504 1505func (m *IngressStatus) Marshal() (dAtA []byte, err error) { 1506 size := m.Size() 1507 dAtA = make([]byte, size) 1508 n, err := m.MarshalTo(dAtA) 1509 if err != nil { 1510 return nil, err 1511 } 1512 return dAtA[:n], nil 1513} 1514 1515func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) { 1516 var i int 1517 _ = i 1518 var l int 1519 _ = l 1520 dAtA[i] = 0xa 1521 i++ 1522 i = encodeVarintGenerated(dAtA, i, uint64(m.LoadBalancer.Size())) 1523 n31, err := m.LoadBalancer.MarshalTo(dAtA[i:]) 1524 if err != nil { 1525 return 0, err 1526 } 1527 i += n31 1528 return i, nil 1529} 1530 1531func (m *IngressTLS) Marshal() (dAtA []byte, err error) { 1532 size := m.Size() 1533 dAtA = make([]byte, size) 1534 n, err := m.MarshalTo(dAtA) 1535 if err != nil { 1536 return nil, err 1537 } 1538 return dAtA[:n], nil 1539} 1540 1541func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) { 1542 var i int 1543 _ = i 1544 var l int 1545 _ = l 1546 if len(m.Hosts) > 0 { 1547 for _, s := range m.Hosts { 1548 dAtA[i] = 0xa 1549 i++ 1550 l = len(s) 1551 for l >= 1<<7 { 1552 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1553 l >>= 7 1554 i++ 1555 } 1556 dAtA[i] = uint8(l) 1557 i++ 1558 i += copy(dAtA[i:], s) 1559 } 1560 } 1561 dAtA[i] = 0x12 1562 i++ 1563 i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName))) 1564 i += copy(dAtA[i:], m.SecretName) 1565 return i, nil 1566} 1567 1568func (m *NetworkPolicy) Marshal() (dAtA []byte, err error) { 1569 size := m.Size() 1570 dAtA = make([]byte, size) 1571 n, err := m.MarshalTo(dAtA) 1572 if err != nil { 1573 return nil, err 1574 } 1575 return dAtA[:n], nil 1576} 1577 1578func (m *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) { 1579 var i int 1580 _ = i 1581 var l int 1582 _ = l 1583 dAtA[i] = 0xa 1584 i++ 1585 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 1586 n32, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 1587 if err != nil { 1588 return 0, err 1589 } 1590 i += n32 1591 dAtA[i] = 0x12 1592 i++ 1593 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 1594 n33, err := m.Spec.MarshalTo(dAtA[i:]) 1595 if err != nil { 1596 return 0, err 1597 } 1598 i += n33 1599 return i, nil 1600} 1601 1602func (m *NetworkPolicyEgressRule) Marshal() (dAtA []byte, err error) { 1603 size := m.Size() 1604 dAtA = make([]byte, size) 1605 n, err := m.MarshalTo(dAtA) 1606 if err != nil { 1607 return nil, err 1608 } 1609 return dAtA[:n], nil 1610} 1611 1612func (m *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) { 1613 var i int 1614 _ = i 1615 var l int 1616 _ = l 1617 if len(m.Ports) > 0 { 1618 for _, msg := range m.Ports { 1619 dAtA[i] = 0xa 1620 i++ 1621 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1622 n, err := msg.MarshalTo(dAtA[i:]) 1623 if err != nil { 1624 return 0, err 1625 } 1626 i += n 1627 } 1628 } 1629 if len(m.To) > 0 { 1630 for _, msg := range m.To { 1631 dAtA[i] = 0x12 1632 i++ 1633 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1634 n, err := msg.MarshalTo(dAtA[i:]) 1635 if err != nil { 1636 return 0, err 1637 } 1638 i += n 1639 } 1640 } 1641 return i, nil 1642} 1643 1644func (m *NetworkPolicyIngressRule) Marshal() (dAtA []byte, err error) { 1645 size := m.Size() 1646 dAtA = make([]byte, size) 1647 n, err := m.MarshalTo(dAtA) 1648 if err != nil { 1649 return nil, err 1650 } 1651 return dAtA[:n], nil 1652} 1653 1654func (m *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) { 1655 var i int 1656 _ = i 1657 var l int 1658 _ = l 1659 if len(m.Ports) > 0 { 1660 for _, msg := range m.Ports { 1661 dAtA[i] = 0xa 1662 i++ 1663 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1664 n, err := msg.MarshalTo(dAtA[i:]) 1665 if err != nil { 1666 return 0, err 1667 } 1668 i += n 1669 } 1670 } 1671 if len(m.From) > 0 { 1672 for _, msg := range m.From { 1673 dAtA[i] = 0x12 1674 i++ 1675 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1676 n, err := msg.MarshalTo(dAtA[i:]) 1677 if err != nil { 1678 return 0, err 1679 } 1680 i += n 1681 } 1682 } 1683 return i, nil 1684} 1685 1686func (m *NetworkPolicyList) Marshal() (dAtA []byte, err error) { 1687 size := m.Size() 1688 dAtA = make([]byte, size) 1689 n, err := m.MarshalTo(dAtA) 1690 if err != nil { 1691 return nil, err 1692 } 1693 return dAtA[:n], nil 1694} 1695 1696func (m *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) { 1697 var i int 1698 _ = i 1699 var l int 1700 _ = l 1701 dAtA[i] = 0xa 1702 i++ 1703 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 1704 n34, err := m.ListMeta.MarshalTo(dAtA[i:]) 1705 if err != nil { 1706 return 0, err 1707 } 1708 i += n34 1709 if len(m.Items) > 0 { 1710 for _, msg := range m.Items { 1711 dAtA[i] = 0x12 1712 i++ 1713 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1714 n, err := msg.MarshalTo(dAtA[i:]) 1715 if err != nil { 1716 return 0, err 1717 } 1718 i += n 1719 } 1720 } 1721 return i, nil 1722} 1723 1724func (m *NetworkPolicyPeer) Marshal() (dAtA []byte, err error) { 1725 size := m.Size() 1726 dAtA = make([]byte, size) 1727 n, err := m.MarshalTo(dAtA) 1728 if err != nil { 1729 return nil, err 1730 } 1731 return dAtA[:n], nil 1732} 1733 1734func (m *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) { 1735 var i int 1736 _ = i 1737 var l int 1738 _ = l 1739 if m.PodSelector != nil { 1740 dAtA[i] = 0xa 1741 i++ 1742 i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size())) 1743 n35, err := m.PodSelector.MarshalTo(dAtA[i:]) 1744 if err != nil { 1745 return 0, err 1746 } 1747 i += n35 1748 } 1749 if m.NamespaceSelector != nil { 1750 dAtA[i] = 0x12 1751 i++ 1752 i = encodeVarintGenerated(dAtA, i, uint64(m.NamespaceSelector.Size())) 1753 n36, err := m.NamespaceSelector.MarshalTo(dAtA[i:]) 1754 if err != nil { 1755 return 0, err 1756 } 1757 i += n36 1758 } 1759 if m.IPBlock != nil { 1760 dAtA[i] = 0x1a 1761 i++ 1762 i = encodeVarintGenerated(dAtA, i, uint64(m.IPBlock.Size())) 1763 n37, err := m.IPBlock.MarshalTo(dAtA[i:]) 1764 if err != nil { 1765 return 0, err 1766 } 1767 i += n37 1768 } 1769 return i, nil 1770} 1771 1772func (m *NetworkPolicyPort) Marshal() (dAtA []byte, err error) { 1773 size := m.Size() 1774 dAtA = make([]byte, size) 1775 n, err := m.MarshalTo(dAtA) 1776 if err != nil { 1777 return nil, err 1778 } 1779 return dAtA[:n], nil 1780} 1781 1782func (m *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) { 1783 var i int 1784 _ = i 1785 var l int 1786 _ = l 1787 if m.Protocol != nil { 1788 dAtA[i] = 0xa 1789 i++ 1790 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol))) 1791 i += copy(dAtA[i:], *m.Protocol) 1792 } 1793 if m.Port != nil { 1794 dAtA[i] = 0x12 1795 i++ 1796 i = encodeVarintGenerated(dAtA, i, uint64(m.Port.Size())) 1797 n38, err := m.Port.MarshalTo(dAtA[i:]) 1798 if err != nil { 1799 return 0, err 1800 } 1801 i += n38 1802 } 1803 return i, nil 1804} 1805 1806func (m *NetworkPolicySpec) Marshal() (dAtA []byte, err error) { 1807 size := m.Size() 1808 dAtA = make([]byte, size) 1809 n, err := m.MarshalTo(dAtA) 1810 if err != nil { 1811 return nil, err 1812 } 1813 return dAtA[:n], nil 1814} 1815 1816func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) { 1817 var i int 1818 _ = i 1819 var l int 1820 _ = l 1821 dAtA[i] = 0xa 1822 i++ 1823 i = encodeVarintGenerated(dAtA, i, uint64(m.PodSelector.Size())) 1824 n39, err := m.PodSelector.MarshalTo(dAtA[i:]) 1825 if err != nil { 1826 return 0, err 1827 } 1828 i += n39 1829 if len(m.Ingress) > 0 { 1830 for _, msg := range m.Ingress { 1831 dAtA[i] = 0x12 1832 i++ 1833 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1834 n, err := msg.MarshalTo(dAtA[i:]) 1835 if err != nil { 1836 return 0, err 1837 } 1838 i += n 1839 } 1840 } 1841 if len(m.Egress) > 0 { 1842 for _, msg := range m.Egress { 1843 dAtA[i] = 0x1a 1844 i++ 1845 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1846 n, err := msg.MarshalTo(dAtA[i:]) 1847 if err != nil { 1848 return 0, err 1849 } 1850 i += n 1851 } 1852 } 1853 if len(m.PolicyTypes) > 0 { 1854 for _, s := range m.PolicyTypes { 1855 dAtA[i] = 0x22 1856 i++ 1857 l = len(s) 1858 for l >= 1<<7 { 1859 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1860 l >>= 7 1861 i++ 1862 } 1863 dAtA[i] = uint8(l) 1864 i++ 1865 i += copy(dAtA[i:], s) 1866 } 1867 } 1868 return i, nil 1869} 1870 1871func (m *PodSecurityPolicy) Marshal() (dAtA []byte, err error) { 1872 size := m.Size() 1873 dAtA = make([]byte, size) 1874 n, err := m.MarshalTo(dAtA) 1875 if err != nil { 1876 return nil, err 1877 } 1878 return dAtA[:n], nil 1879} 1880 1881func (m *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) { 1882 var i int 1883 _ = i 1884 var l int 1885 _ = l 1886 dAtA[i] = 0xa 1887 i++ 1888 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 1889 n40, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 1890 if err != nil { 1891 return 0, err 1892 } 1893 i += n40 1894 dAtA[i] = 0x12 1895 i++ 1896 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 1897 n41, err := m.Spec.MarshalTo(dAtA[i:]) 1898 if err != nil { 1899 return 0, err 1900 } 1901 i += n41 1902 return i, nil 1903} 1904 1905func (m *PodSecurityPolicyList) Marshal() (dAtA []byte, err error) { 1906 size := m.Size() 1907 dAtA = make([]byte, size) 1908 n, err := m.MarshalTo(dAtA) 1909 if err != nil { 1910 return nil, err 1911 } 1912 return dAtA[:n], nil 1913} 1914 1915func (m *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) { 1916 var i int 1917 _ = i 1918 var l int 1919 _ = l 1920 dAtA[i] = 0xa 1921 i++ 1922 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 1923 n42, err := m.ListMeta.MarshalTo(dAtA[i:]) 1924 if err != nil { 1925 return 0, err 1926 } 1927 i += n42 1928 if len(m.Items) > 0 { 1929 for _, msg := range m.Items { 1930 dAtA[i] = 0x12 1931 i++ 1932 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 1933 n, err := msg.MarshalTo(dAtA[i:]) 1934 if err != nil { 1935 return 0, err 1936 } 1937 i += n 1938 } 1939 } 1940 return i, nil 1941} 1942 1943func (m *PodSecurityPolicySpec) Marshal() (dAtA []byte, err error) { 1944 size := m.Size() 1945 dAtA = make([]byte, size) 1946 n, err := m.MarshalTo(dAtA) 1947 if err != nil { 1948 return nil, err 1949 } 1950 return dAtA[:n], nil 1951} 1952 1953func (m *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) { 1954 var i int 1955 _ = i 1956 var l int 1957 _ = l 1958 dAtA[i] = 0x8 1959 i++ 1960 if m.Privileged { 1961 dAtA[i] = 1 1962 } else { 1963 dAtA[i] = 0 1964 } 1965 i++ 1966 if len(m.DefaultAddCapabilities) > 0 { 1967 for _, s := range m.DefaultAddCapabilities { 1968 dAtA[i] = 0x12 1969 i++ 1970 l = len(s) 1971 for l >= 1<<7 { 1972 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1973 l >>= 7 1974 i++ 1975 } 1976 dAtA[i] = uint8(l) 1977 i++ 1978 i += copy(dAtA[i:], s) 1979 } 1980 } 1981 if len(m.RequiredDropCapabilities) > 0 { 1982 for _, s := range m.RequiredDropCapabilities { 1983 dAtA[i] = 0x1a 1984 i++ 1985 l = len(s) 1986 for l >= 1<<7 { 1987 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 1988 l >>= 7 1989 i++ 1990 } 1991 dAtA[i] = uint8(l) 1992 i++ 1993 i += copy(dAtA[i:], s) 1994 } 1995 } 1996 if len(m.AllowedCapabilities) > 0 { 1997 for _, s := range m.AllowedCapabilities { 1998 dAtA[i] = 0x22 1999 i++ 2000 l = len(s) 2001 for l >= 1<<7 { 2002 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2003 l >>= 7 2004 i++ 2005 } 2006 dAtA[i] = uint8(l) 2007 i++ 2008 i += copy(dAtA[i:], s) 2009 } 2010 } 2011 if len(m.Volumes) > 0 { 2012 for _, s := range m.Volumes { 2013 dAtA[i] = 0x2a 2014 i++ 2015 l = len(s) 2016 for l >= 1<<7 { 2017 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2018 l >>= 7 2019 i++ 2020 } 2021 dAtA[i] = uint8(l) 2022 i++ 2023 i += copy(dAtA[i:], s) 2024 } 2025 } 2026 dAtA[i] = 0x30 2027 i++ 2028 if m.HostNetwork { 2029 dAtA[i] = 1 2030 } else { 2031 dAtA[i] = 0 2032 } 2033 i++ 2034 if len(m.HostPorts) > 0 { 2035 for _, msg := range m.HostPorts { 2036 dAtA[i] = 0x3a 2037 i++ 2038 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2039 n, err := msg.MarshalTo(dAtA[i:]) 2040 if err != nil { 2041 return 0, err 2042 } 2043 i += n 2044 } 2045 } 2046 dAtA[i] = 0x40 2047 i++ 2048 if m.HostPID { 2049 dAtA[i] = 1 2050 } else { 2051 dAtA[i] = 0 2052 } 2053 i++ 2054 dAtA[i] = 0x48 2055 i++ 2056 if m.HostIPC { 2057 dAtA[i] = 1 2058 } else { 2059 dAtA[i] = 0 2060 } 2061 i++ 2062 dAtA[i] = 0x52 2063 i++ 2064 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinux.Size())) 2065 n43, err := m.SELinux.MarshalTo(dAtA[i:]) 2066 if err != nil { 2067 return 0, err 2068 } 2069 i += n43 2070 dAtA[i] = 0x5a 2071 i++ 2072 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsUser.Size())) 2073 n44, err := m.RunAsUser.MarshalTo(dAtA[i:]) 2074 if err != nil { 2075 return 0, err 2076 } 2077 i += n44 2078 dAtA[i] = 0x62 2079 i++ 2080 i = encodeVarintGenerated(dAtA, i, uint64(m.SupplementalGroups.Size())) 2081 n45, err := m.SupplementalGroups.MarshalTo(dAtA[i:]) 2082 if err != nil { 2083 return 0, err 2084 } 2085 i += n45 2086 dAtA[i] = 0x6a 2087 i++ 2088 i = encodeVarintGenerated(dAtA, i, uint64(m.FSGroup.Size())) 2089 n46, err := m.FSGroup.MarshalTo(dAtA[i:]) 2090 if err != nil { 2091 return 0, err 2092 } 2093 i += n46 2094 dAtA[i] = 0x70 2095 i++ 2096 if m.ReadOnlyRootFilesystem { 2097 dAtA[i] = 1 2098 } else { 2099 dAtA[i] = 0 2100 } 2101 i++ 2102 if m.DefaultAllowPrivilegeEscalation != nil { 2103 dAtA[i] = 0x78 2104 i++ 2105 if *m.DefaultAllowPrivilegeEscalation { 2106 dAtA[i] = 1 2107 } else { 2108 dAtA[i] = 0 2109 } 2110 i++ 2111 } 2112 if m.AllowPrivilegeEscalation != nil { 2113 dAtA[i] = 0x80 2114 i++ 2115 dAtA[i] = 0x1 2116 i++ 2117 if *m.AllowPrivilegeEscalation { 2118 dAtA[i] = 1 2119 } else { 2120 dAtA[i] = 0 2121 } 2122 i++ 2123 } 2124 if len(m.AllowedHostPaths) > 0 { 2125 for _, msg := range m.AllowedHostPaths { 2126 dAtA[i] = 0x8a 2127 i++ 2128 dAtA[i] = 0x1 2129 i++ 2130 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2131 n, err := msg.MarshalTo(dAtA[i:]) 2132 if err != nil { 2133 return 0, err 2134 } 2135 i += n 2136 } 2137 } 2138 if len(m.AllowedFlexVolumes) > 0 { 2139 for _, msg := range m.AllowedFlexVolumes { 2140 dAtA[i] = 0x92 2141 i++ 2142 dAtA[i] = 0x1 2143 i++ 2144 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2145 n, err := msg.MarshalTo(dAtA[i:]) 2146 if err != nil { 2147 return 0, err 2148 } 2149 i += n 2150 } 2151 } 2152 if len(m.AllowedUnsafeSysctls) > 0 { 2153 for _, s := range m.AllowedUnsafeSysctls { 2154 dAtA[i] = 0x9a 2155 i++ 2156 dAtA[i] = 0x1 2157 i++ 2158 l = len(s) 2159 for l >= 1<<7 { 2160 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2161 l >>= 7 2162 i++ 2163 } 2164 dAtA[i] = uint8(l) 2165 i++ 2166 i += copy(dAtA[i:], s) 2167 } 2168 } 2169 if len(m.ForbiddenSysctls) > 0 { 2170 for _, s := range m.ForbiddenSysctls { 2171 dAtA[i] = 0xa2 2172 i++ 2173 dAtA[i] = 0x1 2174 i++ 2175 l = len(s) 2176 for l >= 1<<7 { 2177 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2178 l >>= 7 2179 i++ 2180 } 2181 dAtA[i] = uint8(l) 2182 i++ 2183 i += copy(dAtA[i:], s) 2184 } 2185 } 2186 if len(m.AllowedProcMountTypes) > 0 { 2187 for _, s := range m.AllowedProcMountTypes { 2188 dAtA[i] = 0xaa 2189 i++ 2190 dAtA[i] = 0x1 2191 i++ 2192 l = len(s) 2193 for l >= 1<<7 { 2194 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2195 l >>= 7 2196 i++ 2197 } 2198 dAtA[i] = uint8(l) 2199 i++ 2200 i += copy(dAtA[i:], s) 2201 } 2202 } 2203 if m.RunAsGroup != nil { 2204 dAtA[i] = 0xb2 2205 i++ 2206 dAtA[i] = 0x1 2207 i++ 2208 i = encodeVarintGenerated(dAtA, i, uint64(m.RunAsGroup.Size())) 2209 n47, err := m.RunAsGroup.MarshalTo(dAtA[i:]) 2210 if err != nil { 2211 return 0, err 2212 } 2213 i += n47 2214 } 2215 if len(m.AllowedCSIDrivers) > 0 { 2216 for _, msg := range m.AllowedCSIDrivers { 2217 dAtA[i] = 0xba 2218 i++ 2219 dAtA[i] = 0x1 2220 i++ 2221 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2222 n, err := msg.MarshalTo(dAtA[i:]) 2223 if err != nil { 2224 return 0, err 2225 } 2226 i += n 2227 } 2228 } 2229 if m.RuntimeClass != nil { 2230 dAtA[i] = 0xc2 2231 i++ 2232 dAtA[i] = 0x1 2233 i++ 2234 i = encodeVarintGenerated(dAtA, i, uint64(m.RuntimeClass.Size())) 2235 n48, err := m.RuntimeClass.MarshalTo(dAtA[i:]) 2236 if err != nil { 2237 return 0, err 2238 } 2239 i += n48 2240 } 2241 return i, nil 2242} 2243 2244func (m *ReplicaSet) Marshal() (dAtA []byte, err error) { 2245 size := m.Size() 2246 dAtA = make([]byte, size) 2247 n, err := m.MarshalTo(dAtA) 2248 if err != nil { 2249 return nil, err 2250 } 2251 return dAtA[:n], nil 2252} 2253 2254func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) { 2255 var i int 2256 _ = i 2257 var l int 2258 _ = l 2259 dAtA[i] = 0xa 2260 i++ 2261 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 2262 n49, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 2263 if err != nil { 2264 return 0, err 2265 } 2266 i += n49 2267 dAtA[i] = 0x12 2268 i++ 2269 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 2270 n50, err := m.Spec.MarshalTo(dAtA[i:]) 2271 if err != nil { 2272 return 0, err 2273 } 2274 i += n50 2275 dAtA[i] = 0x1a 2276 i++ 2277 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 2278 n51, err := m.Status.MarshalTo(dAtA[i:]) 2279 if err != nil { 2280 return 0, err 2281 } 2282 i += n51 2283 return i, nil 2284} 2285 2286func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) { 2287 size := m.Size() 2288 dAtA = make([]byte, size) 2289 n, err := m.MarshalTo(dAtA) 2290 if err != nil { 2291 return nil, err 2292 } 2293 return dAtA[:n], nil 2294} 2295 2296func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) { 2297 var i int 2298 _ = i 2299 var l int 2300 _ = l 2301 dAtA[i] = 0xa 2302 i++ 2303 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) 2304 i += copy(dAtA[i:], m.Type) 2305 dAtA[i] = 0x12 2306 i++ 2307 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) 2308 i += copy(dAtA[i:], m.Status) 2309 dAtA[i] = 0x1a 2310 i++ 2311 i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size())) 2312 n52, err := m.LastTransitionTime.MarshalTo(dAtA[i:]) 2313 if err != nil { 2314 return 0, err 2315 } 2316 i += n52 2317 dAtA[i] = 0x22 2318 i++ 2319 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) 2320 i += copy(dAtA[i:], m.Reason) 2321 dAtA[i] = 0x2a 2322 i++ 2323 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) 2324 i += copy(dAtA[i:], m.Message) 2325 return i, nil 2326} 2327 2328func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) { 2329 size := m.Size() 2330 dAtA = make([]byte, size) 2331 n, err := m.MarshalTo(dAtA) 2332 if err != nil { 2333 return nil, err 2334 } 2335 return dAtA[:n], nil 2336} 2337 2338func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) { 2339 var i int 2340 _ = i 2341 var l int 2342 _ = l 2343 dAtA[i] = 0xa 2344 i++ 2345 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) 2346 n53, err := m.ListMeta.MarshalTo(dAtA[i:]) 2347 if err != nil { 2348 return 0, err 2349 } 2350 i += n53 2351 if len(m.Items) > 0 { 2352 for _, msg := range m.Items { 2353 dAtA[i] = 0x12 2354 i++ 2355 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2356 n, err := msg.MarshalTo(dAtA[i:]) 2357 if err != nil { 2358 return 0, err 2359 } 2360 i += n 2361 } 2362 } 2363 return i, nil 2364} 2365 2366func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) { 2367 size := m.Size() 2368 dAtA = make([]byte, size) 2369 n, err := m.MarshalTo(dAtA) 2370 if err != nil { 2371 return nil, err 2372 } 2373 return dAtA[:n], nil 2374} 2375 2376func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) { 2377 var i int 2378 _ = i 2379 var l int 2380 _ = l 2381 if m.Replicas != nil { 2382 dAtA[i] = 0x8 2383 i++ 2384 i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) 2385 } 2386 if m.Selector != nil { 2387 dAtA[i] = 0x12 2388 i++ 2389 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size())) 2390 n54, err := m.Selector.MarshalTo(dAtA[i:]) 2391 if err != nil { 2392 return 0, err 2393 } 2394 i += n54 2395 } 2396 dAtA[i] = 0x1a 2397 i++ 2398 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size())) 2399 n55, err := m.Template.MarshalTo(dAtA[i:]) 2400 if err != nil { 2401 return 0, err 2402 } 2403 i += n55 2404 dAtA[i] = 0x20 2405 i++ 2406 i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) 2407 return i, nil 2408} 2409 2410func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) { 2411 size := m.Size() 2412 dAtA = make([]byte, size) 2413 n, err := m.MarshalTo(dAtA) 2414 if err != nil { 2415 return nil, err 2416 } 2417 return dAtA[:n], nil 2418} 2419 2420func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) { 2421 var i int 2422 _ = i 2423 var l int 2424 _ = l 2425 dAtA[i] = 0x8 2426 i++ 2427 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 2428 dAtA[i] = 0x10 2429 i++ 2430 i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas)) 2431 dAtA[i] = 0x18 2432 i++ 2433 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) 2434 dAtA[i] = 0x20 2435 i++ 2436 i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) 2437 dAtA[i] = 0x28 2438 i++ 2439 i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) 2440 if len(m.Conditions) > 0 { 2441 for _, msg := range m.Conditions { 2442 dAtA[i] = 0x32 2443 i++ 2444 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2445 n, err := msg.MarshalTo(dAtA[i:]) 2446 if err != nil { 2447 return 0, err 2448 } 2449 i += n 2450 } 2451 } 2452 return i, nil 2453} 2454 2455func (m *ReplicationControllerDummy) Marshal() (dAtA []byte, err error) { 2456 size := m.Size() 2457 dAtA = make([]byte, size) 2458 n, err := m.MarshalTo(dAtA) 2459 if err != nil { 2460 return nil, err 2461 } 2462 return dAtA[:n], nil 2463} 2464 2465func (m *ReplicationControllerDummy) MarshalTo(dAtA []byte) (int, error) { 2466 var i int 2467 _ = i 2468 var l int 2469 _ = l 2470 return i, nil 2471} 2472 2473func (m *RollbackConfig) Marshal() (dAtA []byte, err error) { 2474 size := m.Size() 2475 dAtA = make([]byte, size) 2476 n, err := m.MarshalTo(dAtA) 2477 if err != nil { 2478 return nil, err 2479 } 2480 return dAtA[:n], nil 2481} 2482 2483func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) { 2484 var i int 2485 _ = i 2486 var l int 2487 _ = l 2488 dAtA[i] = 0x8 2489 i++ 2490 i = encodeVarintGenerated(dAtA, i, uint64(m.Revision)) 2491 return i, nil 2492} 2493 2494func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) { 2495 size := m.Size() 2496 dAtA = make([]byte, size) 2497 n, err := m.MarshalTo(dAtA) 2498 if err != nil { 2499 return nil, err 2500 } 2501 return dAtA[:n], nil 2502} 2503 2504func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) { 2505 var i int 2506 _ = i 2507 var l int 2508 _ = l 2509 if m.MaxUnavailable != nil { 2510 dAtA[i] = 0xa 2511 i++ 2512 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size())) 2513 n56, err := m.MaxUnavailable.MarshalTo(dAtA[i:]) 2514 if err != nil { 2515 return 0, err 2516 } 2517 i += n56 2518 } 2519 return i, nil 2520} 2521 2522func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) { 2523 size := m.Size() 2524 dAtA = make([]byte, size) 2525 n, err := m.MarshalTo(dAtA) 2526 if err != nil { 2527 return nil, err 2528 } 2529 return dAtA[:n], nil 2530} 2531 2532func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) { 2533 var i int 2534 _ = i 2535 var l int 2536 _ = l 2537 if m.MaxUnavailable != nil { 2538 dAtA[i] = 0xa 2539 i++ 2540 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxUnavailable.Size())) 2541 n57, err := m.MaxUnavailable.MarshalTo(dAtA[i:]) 2542 if err != nil { 2543 return 0, err 2544 } 2545 i += n57 2546 } 2547 if m.MaxSurge != nil { 2548 dAtA[i] = 0x12 2549 i++ 2550 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size())) 2551 n58, err := m.MaxSurge.MarshalTo(dAtA[i:]) 2552 if err != nil { 2553 return 0, err 2554 } 2555 i += n58 2556 } 2557 return i, nil 2558} 2559 2560func (m *RunAsGroupStrategyOptions) Marshal() (dAtA []byte, err error) { 2561 size := m.Size() 2562 dAtA = make([]byte, size) 2563 n, err := m.MarshalTo(dAtA) 2564 if err != nil { 2565 return nil, err 2566 } 2567 return dAtA[:n], nil 2568} 2569 2570func (m *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2571 var i int 2572 _ = i 2573 var l int 2574 _ = l 2575 dAtA[i] = 0xa 2576 i++ 2577 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2578 i += copy(dAtA[i:], m.Rule) 2579 if len(m.Ranges) > 0 { 2580 for _, msg := range m.Ranges { 2581 dAtA[i] = 0x12 2582 i++ 2583 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2584 n, err := msg.MarshalTo(dAtA[i:]) 2585 if err != nil { 2586 return 0, err 2587 } 2588 i += n 2589 } 2590 } 2591 return i, nil 2592} 2593 2594func (m *RunAsUserStrategyOptions) Marshal() (dAtA []byte, err error) { 2595 size := m.Size() 2596 dAtA = make([]byte, size) 2597 n, err := m.MarshalTo(dAtA) 2598 if err != nil { 2599 return nil, err 2600 } 2601 return dAtA[:n], nil 2602} 2603 2604func (m *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2605 var i int 2606 _ = i 2607 var l int 2608 _ = l 2609 dAtA[i] = 0xa 2610 i++ 2611 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2612 i += copy(dAtA[i:], m.Rule) 2613 if len(m.Ranges) > 0 { 2614 for _, msg := range m.Ranges { 2615 dAtA[i] = 0x12 2616 i++ 2617 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2618 n, err := msg.MarshalTo(dAtA[i:]) 2619 if err != nil { 2620 return 0, err 2621 } 2622 i += n 2623 } 2624 } 2625 return i, nil 2626} 2627 2628func (m *RuntimeClassStrategyOptions) Marshal() (dAtA []byte, err error) { 2629 size := m.Size() 2630 dAtA = make([]byte, size) 2631 n, err := m.MarshalTo(dAtA) 2632 if err != nil { 2633 return nil, err 2634 } 2635 return dAtA[:n], nil 2636} 2637 2638func (m *RuntimeClassStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2639 var i int 2640 _ = i 2641 var l int 2642 _ = l 2643 if len(m.AllowedRuntimeClassNames) > 0 { 2644 for _, s := range m.AllowedRuntimeClassNames { 2645 dAtA[i] = 0xa 2646 i++ 2647 l = len(s) 2648 for l >= 1<<7 { 2649 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 2650 l >>= 7 2651 i++ 2652 } 2653 dAtA[i] = uint8(l) 2654 i++ 2655 i += copy(dAtA[i:], s) 2656 } 2657 } 2658 if m.DefaultRuntimeClassName != nil { 2659 dAtA[i] = 0x12 2660 i++ 2661 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.DefaultRuntimeClassName))) 2662 i += copy(dAtA[i:], *m.DefaultRuntimeClassName) 2663 } 2664 return i, nil 2665} 2666 2667func (m *SELinuxStrategyOptions) Marshal() (dAtA []byte, err error) { 2668 size := m.Size() 2669 dAtA = make([]byte, size) 2670 n, err := m.MarshalTo(dAtA) 2671 if err != nil { 2672 return nil, err 2673 } 2674 return dAtA[:n], nil 2675} 2676 2677func (m *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2678 var i int 2679 _ = i 2680 var l int 2681 _ = l 2682 dAtA[i] = 0xa 2683 i++ 2684 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2685 i += copy(dAtA[i:], m.Rule) 2686 if m.SELinuxOptions != nil { 2687 dAtA[i] = 0x12 2688 i++ 2689 i = encodeVarintGenerated(dAtA, i, uint64(m.SELinuxOptions.Size())) 2690 n59, err := m.SELinuxOptions.MarshalTo(dAtA[i:]) 2691 if err != nil { 2692 return 0, err 2693 } 2694 i += n59 2695 } 2696 return i, nil 2697} 2698 2699func (m *Scale) Marshal() (dAtA []byte, err error) { 2700 size := m.Size() 2701 dAtA = make([]byte, size) 2702 n, err := m.MarshalTo(dAtA) 2703 if err != nil { 2704 return nil, err 2705 } 2706 return dAtA[:n], nil 2707} 2708 2709func (m *Scale) MarshalTo(dAtA []byte) (int, error) { 2710 var i int 2711 _ = i 2712 var l int 2713 _ = l 2714 dAtA[i] = 0xa 2715 i++ 2716 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size())) 2717 n60, err := m.ObjectMeta.MarshalTo(dAtA[i:]) 2718 if err != nil { 2719 return 0, err 2720 } 2721 i += n60 2722 dAtA[i] = 0x12 2723 i++ 2724 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size())) 2725 n61, err := m.Spec.MarshalTo(dAtA[i:]) 2726 if err != nil { 2727 return 0, err 2728 } 2729 i += n61 2730 dAtA[i] = 0x1a 2731 i++ 2732 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size())) 2733 n62, err := m.Status.MarshalTo(dAtA[i:]) 2734 if err != nil { 2735 return 0, err 2736 } 2737 i += n62 2738 return i, nil 2739} 2740 2741func (m *ScaleSpec) Marshal() (dAtA []byte, err error) { 2742 size := m.Size() 2743 dAtA = make([]byte, size) 2744 n, err := m.MarshalTo(dAtA) 2745 if err != nil { 2746 return nil, err 2747 } 2748 return dAtA[:n], nil 2749} 2750 2751func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) { 2752 var i int 2753 _ = i 2754 var l int 2755 _ = l 2756 dAtA[i] = 0x8 2757 i++ 2758 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 2759 return i, nil 2760} 2761 2762func (m *ScaleStatus) Marshal() (dAtA []byte, err error) { 2763 size := m.Size() 2764 dAtA = make([]byte, size) 2765 n, err := m.MarshalTo(dAtA) 2766 if err != nil { 2767 return nil, err 2768 } 2769 return dAtA[:n], nil 2770} 2771 2772func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) { 2773 var i int 2774 _ = i 2775 var l int 2776 _ = l 2777 dAtA[i] = 0x8 2778 i++ 2779 i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) 2780 if len(m.Selector) > 0 { 2781 keysForSelector := make([]string, 0, len(m.Selector)) 2782 for k := range m.Selector { 2783 keysForSelector = append(keysForSelector, string(k)) 2784 } 2785 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector) 2786 for _, k := range keysForSelector { 2787 dAtA[i] = 0x12 2788 i++ 2789 v := m.Selector[string(k)] 2790 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 2791 i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) 2792 dAtA[i] = 0xa 2793 i++ 2794 i = encodeVarintGenerated(dAtA, i, uint64(len(k))) 2795 i += copy(dAtA[i:], k) 2796 dAtA[i] = 0x12 2797 i++ 2798 i = encodeVarintGenerated(dAtA, i, uint64(len(v))) 2799 i += copy(dAtA[i:], v) 2800 } 2801 } 2802 dAtA[i] = 0x1a 2803 i++ 2804 i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector))) 2805 i += copy(dAtA[i:], m.TargetSelector) 2806 return i, nil 2807} 2808 2809func (m *SupplementalGroupsStrategyOptions) Marshal() (dAtA []byte, err error) { 2810 size := m.Size() 2811 dAtA = make([]byte, size) 2812 n, err := m.MarshalTo(dAtA) 2813 if err != nil { 2814 return nil, err 2815 } 2816 return dAtA[:n], nil 2817} 2818 2819func (m *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) { 2820 var i int 2821 _ = i 2822 var l int 2823 _ = l 2824 dAtA[i] = 0xa 2825 i++ 2826 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) 2827 i += copy(dAtA[i:], m.Rule) 2828 if len(m.Ranges) > 0 { 2829 for _, msg := range m.Ranges { 2830 dAtA[i] = 0x12 2831 i++ 2832 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) 2833 n, err := msg.MarshalTo(dAtA[i:]) 2834 if err != nil { 2835 return 0, err 2836 } 2837 i += n 2838 } 2839 } 2840 return i, nil 2841} 2842 2843func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { 2844 for v >= 1<<7 { 2845 dAtA[offset] = uint8(v&0x7f | 0x80) 2846 v >>= 7 2847 offset++ 2848 } 2849 dAtA[offset] = uint8(v) 2850 return offset + 1 2851} 2852func (m *AllowedCSIDriver) Size() (n int) { 2853 var l int 2854 _ = l 2855 l = len(m.Name) 2856 n += 1 + l + sovGenerated(uint64(l)) 2857 return n 2858} 2859 2860func (m *AllowedFlexVolume) Size() (n int) { 2861 var l int 2862 _ = l 2863 l = len(m.Driver) 2864 n += 1 + l + sovGenerated(uint64(l)) 2865 return n 2866} 2867 2868func (m *AllowedHostPath) Size() (n int) { 2869 var l int 2870 _ = l 2871 l = len(m.PathPrefix) 2872 n += 1 + l + sovGenerated(uint64(l)) 2873 n += 2 2874 return n 2875} 2876 2877func (m *DaemonSet) Size() (n int) { 2878 var l int 2879 _ = l 2880 l = m.ObjectMeta.Size() 2881 n += 1 + l + sovGenerated(uint64(l)) 2882 l = m.Spec.Size() 2883 n += 1 + l + sovGenerated(uint64(l)) 2884 l = m.Status.Size() 2885 n += 1 + l + sovGenerated(uint64(l)) 2886 return n 2887} 2888 2889func (m *DaemonSetCondition) Size() (n int) { 2890 var l int 2891 _ = l 2892 l = len(m.Type) 2893 n += 1 + l + sovGenerated(uint64(l)) 2894 l = len(m.Status) 2895 n += 1 + l + sovGenerated(uint64(l)) 2896 l = m.LastTransitionTime.Size() 2897 n += 1 + l + sovGenerated(uint64(l)) 2898 l = len(m.Reason) 2899 n += 1 + l + sovGenerated(uint64(l)) 2900 l = len(m.Message) 2901 n += 1 + l + sovGenerated(uint64(l)) 2902 return n 2903} 2904 2905func (m *DaemonSetList) Size() (n int) { 2906 var l int 2907 _ = l 2908 l = m.ListMeta.Size() 2909 n += 1 + l + sovGenerated(uint64(l)) 2910 if len(m.Items) > 0 { 2911 for _, e := range m.Items { 2912 l = e.Size() 2913 n += 1 + l + sovGenerated(uint64(l)) 2914 } 2915 } 2916 return n 2917} 2918 2919func (m *DaemonSetSpec) Size() (n int) { 2920 var l int 2921 _ = l 2922 if m.Selector != nil { 2923 l = m.Selector.Size() 2924 n += 1 + l + sovGenerated(uint64(l)) 2925 } 2926 l = m.Template.Size() 2927 n += 1 + l + sovGenerated(uint64(l)) 2928 l = m.UpdateStrategy.Size() 2929 n += 1 + l + sovGenerated(uint64(l)) 2930 n += 1 + sovGenerated(uint64(m.MinReadySeconds)) 2931 n += 1 + sovGenerated(uint64(m.TemplateGeneration)) 2932 if m.RevisionHistoryLimit != nil { 2933 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) 2934 } 2935 return n 2936} 2937 2938func (m *DaemonSetStatus) Size() (n int) { 2939 var l int 2940 _ = l 2941 n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled)) 2942 n += 1 + sovGenerated(uint64(m.NumberMisscheduled)) 2943 n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled)) 2944 n += 1 + sovGenerated(uint64(m.NumberReady)) 2945 n += 1 + sovGenerated(uint64(m.ObservedGeneration)) 2946 n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled)) 2947 n += 1 + sovGenerated(uint64(m.NumberAvailable)) 2948 n += 1 + sovGenerated(uint64(m.NumberUnavailable)) 2949 if m.CollisionCount != nil { 2950 n += 1 + sovGenerated(uint64(*m.CollisionCount)) 2951 } 2952 if len(m.Conditions) > 0 { 2953 for _, e := range m.Conditions { 2954 l = e.Size() 2955 n += 1 + l + sovGenerated(uint64(l)) 2956 } 2957 } 2958 return n 2959} 2960 2961func (m *DaemonSetUpdateStrategy) Size() (n int) { 2962 var l int 2963 _ = l 2964 l = len(m.Type) 2965 n += 1 + l + sovGenerated(uint64(l)) 2966 if m.RollingUpdate != nil { 2967 l = m.RollingUpdate.Size() 2968 n += 1 + l + sovGenerated(uint64(l)) 2969 } 2970 return n 2971} 2972 2973func (m *Deployment) Size() (n int) { 2974 var l int 2975 _ = l 2976 l = m.ObjectMeta.Size() 2977 n += 1 + l + sovGenerated(uint64(l)) 2978 l = m.Spec.Size() 2979 n += 1 + l + sovGenerated(uint64(l)) 2980 l = m.Status.Size() 2981 n += 1 + l + sovGenerated(uint64(l)) 2982 return n 2983} 2984 2985func (m *DeploymentCondition) Size() (n int) { 2986 var l int 2987 _ = l 2988 l = len(m.Type) 2989 n += 1 + l + sovGenerated(uint64(l)) 2990 l = len(m.Status) 2991 n += 1 + l + sovGenerated(uint64(l)) 2992 l = len(m.Reason) 2993 n += 1 + l + sovGenerated(uint64(l)) 2994 l = len(m.Message) 2995 n += 1 + l + sovGenerated(uint64(l)) 2996 l = m.LastUpdateTime.Size() 2997 n += 1 + l + sovGenerated(uint64(l)) 2998 l = m.LastTransitionTime.Size() 2999 n += 1 + l + sovGenerated(uint64(l)) 3000 return n 3001} 3002 3003func (m *DeploymentList) Size() (n int) { 3004 var l int 3005 _ = l 3006 l = m.ListMeta.Size() 3007 n += 1 + l + sovGenerated(uint64(l)) 3008 if len(m.Items) > 0 { 3009 for _, e := range m.Items { 3010 l = e.Size() 3011 n += 1 + l + sovGenerated(uint64(l)) 3012 } 3013 } 3014 return n 3015} 3016 3017func (m *DeploymentRollback) Size() (n int) { 3018 var l int 3019 _ = l 3020 l = len(m.Name) 3021 n += 1 + l + sovGenerated(uint64(l)) 3022 if len(m.UpdatedAnnotations) > 0 { 3023 for k, v := range m.UpdatedAnnotations { 3024 _ = k 3025 _ = v 3026 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 3027 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) 3028 } 3029 } 3030 l = m.RollbackTo.Size() 3031 n += 1 + l + sovGenerated(uint64(l)) 3032 return n 3033} 3034 3035func (m *DeploymentSpec) Size() (n int) { 3036 var l int 3037 _ = l 3038 if m.Replicas != nil { 3039 n += 1 + sovGenerated(uint64(*m.Replicas)) 3040 } 3041 if m.Selector != nil { 3042 l = m.Selector.Size() 3043 n += 1 + l + sovGenerated(uint64(l)) 3044 } 3045 l = m.Template.Size() 3046 n += 1 + l + sovGenerated(uint64(l)) 3047 l = m.Strategy.Size() 3048 n += 1 + l + sovGenerated(uint64(l)) 3049 n += 1 + sovGenerated(uint64(m.MinReadySeconds)) 3050 if m.RevisionHistoryLimit != nil { 3051 n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) 3052 } 3053 n += 2 3054 if m.RollbackTo != nil { 3055 l = m.RollbackTo.Size() 3056 n += 1 + l + sovGenerated(uint64(l)) 3057 } 3058 if m.ProgressDeadlineSeconds != nil { 3059 n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds)) 3060 } 3061 return n 3062} 3063 3064func (m *DeploymentStatus) Size() (n int) { 3065 var l int 3066 _ = l 3067 n += 1 + sovGenerated(uint64(m.ObservedGeneration)) 3068 n += 1 + sovGenerated(uint64(m.Replicas)) 3069 n += 1 + sovGenerated(uint64(m.UpdatedReplicas)) 3070 n += 1 + sovGenerated(uint64(m.AvailableReplicas)) 3071 n += 1 + sovGenerated(uint64(m.UnavailableReplicas)) 3072 if len(m.Conditions) > 0 { 3073 for _, e := range m.Conditions { 3074 l = e.Size() 3075 n += 1 + l + sovGenerated(uint64(l)) 3076 } 3077 } 3078 n += 1 + sovGenerated(uint64(m.ReadyReplicas)) 3079 if m.CollisionCount != nil { 3080 n += 1 + sovGenerated(uint64(*m.CollisionCount)) 3081 } 3082 return n 3083} 3084 3085func (m *DeploymentStrategy) Size() (n int) { 3086 var l int 3087 _ = l 3088 l = len(m.Type) 3089 n += 1 + l + sovGenerated(uint64(l)) 3090 if m.RollingUpdate != nil { 3091 l = m.RollingUpdate.Size() 3092 n += 1 + l + sovGenerated(uint64(l)) 3093 } 3094 return n 3095} 3096 3097func (m *FSGroupStrategyOptions) Size() (n int) { 3098 var l int 3099 _ = l 3100 l = len(m.Rule) 3101 n += 1 + l + sovGenerated(uint64(l)) 3102 if len(m.Ranges) > 0 { 3103 for _, e := range m.Ranges { 3104 l = e.Size() 3105 n += 1 + l + sovGenerated(uint64(l)) 3106 } 3107 } 3108 return n 3109} 3110 3111func (m *HTTPIngressPath) Size() (n int) { 3112 var l int 3113 _ = l 3114 l = len(m.Path) 3115 n += 1 + l + sovGenerated(uint64(l)) 3116 l = m.Backend.Size() 3117 n += 1 + l + sovGenerated(uint64(l)) 3118 return n 3119} 3120 3121func (m *HTTPIngressRuleValue) Size() (n int) { 3122 var l int 3123 _ = l 3124 if len(m.Paths) > 0 { 3125 for _, e := range m.Paths { 3126 l = e.Size() 3127 n += 1 + l + sovGenerated(uint64(l)) 3128 } 3129 } 3130 return n 3131} 3132 3133func (m *HostPortRange) Size() (n int) { 3134 var l int 3135 _ = l 3136 n += 1 + sovGenerated(uint64(m.Min)) 3137 n += 1 + sovGenerated(uint64(m.Max)) 3138 return n 3139} 3140 3141func (m *IDRange) Size() (n int) { 3142 var l int 3143 _ = l 3144 n += 1 + sovGenerated(uint64(m.Min)) 3145 n += 1 + sovGenerated(uint64(m.Max)) 3146 return n 3147} 3148 3149func (m *IPBlock) Size() (n int) { 3150 var l int 3151 _ = l 3152 l = len(m.CIDR) 3153 n += 1 + l + sovGenerated(uint64(l)) 3154 if len(m.Except) > 0 { 3155 for _, s := range m.Except { 3156 l = len(s) 3157 n += 1 + l + sovGenerated(uint64(l)) 3158 } 3159 } 3160 return n 3161} 3162 3163func (m *Ingress) Size() (n int) { 3164 var l int 3165 _ = l 3166 l = m.ObjectMeta.Size() 3167 n += 1 + l + sovGenerated(uint64(l)) 3168 l = m.Spec.Size() 3169 n += 1 + l + sovGenerated(uint64(l)) 3170 l = m.Status.Size() 3171 n += 1 + l + sovGenerated(uint64(l)) 3172 return n 3173} 3174 3175func (m *IngressBackend) Size() (n int) { 3176 var l int 3177 _ = l 3178 l = len(m.ServiceName) 3179 n += 1 + l + sovGenerated(uint64(l)) 3180 l = m.ServicePort.Size() 3181 n += 1 + l + sovGenerated(uint64(l)) 3182 return n 3183} 3184 3185func (m *IngressList) Size() (n int) { 3186 var l int 3187 _ = l 3188 l = m.ListMeta.Size() 3189 n += 1 + l + sovGenerated(uint64(l)) 3190 if len(m.Items) > 0 { 3191 for _, e := range m.Items { 3192 l = e.Size() 3193 n += 1 + l + sovGenerated(uint64(l)) 3194 } 3195 } 3196 return n 3197} 3198 3199func (m *IngressRule) Size() (n int) { 3200 var l int 3201 _ = l 3202 l = len(m.Host) 3203 n += 1 + l + sovGenerated(uint64(l)) 3204 l = m.IngressRuleValue.Size() 3205 n += 1 + l + sovGenerated(uint64(l)) 3206 return n 3207} 3208 3209func (m *IngressRuleValue) Size() (n int) { 3210 var l int 3211 _ = l 3212 if m.HTTP != nil { 3213 l = m.HTTP.Size() 3214 n += 1 + l + sovGenerated(uint64(l)) 3215 } 3216 return n 3217} 3218 3219func (m *IngressSpec) Size() (n int) { 3220 var l int 3221 _ = l 3222 if m.Backend != nil { 3223 l = m.Backend.Size() 3224 n += 1 + l + sovGenerated(uint64(l)) 3225 } 3226 if len(m.TLS) > 0 { 3227 for _, e := range m.TLS { 3228 l = e.Size() 3229 n += 1 + l + sovGenerated(uint64(l)) 3230 } 3231 } 3232 if len(m.Rules) > 0 { 3233 for _, e := range m.Rules { 3234 l = e.Size() 3235 n += 1 + l + sovGenerated(uint64(l)) 3236 } 3237 } 3238 return n 3239} 3240 3241func (m *IngressStatus) Size() (n int) { 3242 var l int 3243 _ = l 3244 l = m.LoadBalancer.Size() 3245 n += 1 + l + sovGenerated(uint64(l)) 3246 return n 3247} 3248 3249func (m *IngressTLS) Size() (n int) { 3250 var l int 3251 _ = l 3252 if len(m.Hosts) > 0 { 3253 for _, s := range m.Hosts { 3254 l = len(s) 3255 n += 1 + l + sovGenerated(uint64(l)) 3256 } 3257 } 3258 l = len(m.SecretName) 3259 n += 1 + l + sovGenerated(uint64(l)) 3260 return n 3261} 3262 3263func (m *NetworkPolicy) Size() (n int) { 3264 var l int 3265 _ = l 3266 l = m.ObjectMeta.Size() 3267 n += 1 + l + sovGenerated(uint64(l)) 3268 l = m.Spec.Size() 3269 n += 1 + l + sovGenerated(uint64(l)) 3270 return n 3271} 3272 3273func (m *NetworkPolicyEgressRule) Size() (n int) { 3274 var l int 3275 _ = l 3276 if len(m.Ports) > 0 { 3277 for _, e := range m.Ports { 3278 l = e.Size() 3279 n += 1 + l + sovGenerated(uint64(l)) 3280 } 3281 } 3282 if len(m.To) > 0 { 3283 for _, e := range m.To { 3284 l = e.Size() 3285 n += 1 + l + sovGenerated(uint64(l)) 3286 } 3287 } 3288 return n 3289} 3290 3291func (m *NetworkPolicyIngressRule) Size() (n int) { 3292 var l int 3293 _ = l 3294 if len(m.Ports) > 0 { 3295 for _, e := range m.Ports { 3296 l = e.Size() 3297 n += 1 + l + sovGenerated(uint64(l)) 3298 } 3299 } 3300 if len(m.From) > 0 { 3301 for _, e := range m.From { 3302 l = e.Size() 3303 n += 1 + l + sovGenerated(uint64(l)) 3304 } 3305 } 3306 return n 3307} 3308 3309func (m *NetworkPolicyList) Size() (n int) { 3310 var l int 3311 _ = l 3312 l = m.ListMeta.Size() 3313 n += 1 + l + sovGenerated(uint64(l)) 3314 if len(m.Items) > 0 { 3315 for _, e := range m.Items { 3316 l = e.Size() 3317 n += 1 + l + sovGenerated(uint64(l)) 3318 } 3319 } 3320 return n 3321} 3322 3323func (m *NetworkPolicyPeer) Size() (n int) { 3324 var l int 3325 _ = l 3326 if m.PodSelector != nil { 3327 l = m.PodSelector.Size() 3328 n += 1 + l + sovGenerated(uint64(l)) 3329 } 3330 if m.NamespaceSelector != nil { 3331 l = m.NamespaceSelector.Size() 3332 n += 1 + l + sovGenerated(uint64(l)) 3333 } 3334 if m.IPBlock != nil { 3335 l = m.IPBlock.Size() 3336 n += 1 + l + sovGenerated(uint64(l)) 3337 } 3338 return n 3339} 3340 3341func (m *NetworkPolicyPort) Size() (n int) { 3342 var l int 3343 _ = l 3344 if m.Protocol != nil { 3345 l = len(*m.Protocol) 3346 n += 1 + l + sovGenerated(uint64(l)) 3347 } 3348 if m.Port != nil { 3349 l = m.Port.Size() 3350 n += 1 + l + sovGenerated(uint64(l)) 3351 } 3352 return n 3353} 3354 3355func (m *NetworkPolicySpec) Size() (n int) { 3356 var l int 3357 _ = l 3358 l = m.PodSelector.Size() 3359 n += 1 + l + sovGenerated(uint64(l)) 3360 if len(m.Ingress) > 0 { 3361 for _, e := range m.Ingress { 3362 l = e.Size() 3363 n += 1 + l + sovGenerated(uint64(l)) 3364 } 3365 } 3366 if len(m.Egress) > 0 { 3367 for _, e := range m.Egress { 3368 l = e.Size() 3369 n += 1 + l + sovGenerated(uint64(l)) 3370 } 3371 } 3372 if len(m.PolicyTypes) > 0 { 3373 for _, s := range m.PolicyTypes { 3374 l = len(s) 3375 n += 1 + l + sovGenerated(uint64(l)) 3376 } 3377 } 3378 return n 3379} 3380 3381func (m *PodSecurityPolicy) Size() (n int) { 3382 var l int 3383 _ = l 3384 l = m.ObjectMeta.Size() 3385 n += 1 + l + sovGenerated(uint64(l)) 3386 l = m.Spec.Size() 3387 n += 1 + l + sovGenerated(uint64(l)) 3388 return n 3389} 3390 3391func (m *PodSecurityPolicyList) Size() (n int) { 3392 var l int 3393 _ = l 3394 l = m.ListMeta.Size() 3395 n += 1 + l + sovGenerated(uint64(l)) 3396 if len(m.Items) > 0 { 3397 for _, e := range m.Items { 3398 l = e.Size() 3399 n += 1 + l + sovGenerated(uint64(l)) 3400 } 3401 } 3402 return n 3403} 3404 3405func (m *PodSecurityPolicySpec) Size() (n int) { 3406 var l int 3407 _ = l 3408 n += 2 3409 if len(m.DefaultAddCapabilities) > 0 { 3410 for _, s := range m.DefaultAddCapabilities { 3411 l = len(s) 3412 n += 1 + l + sovGenerated(uint64(l)) 3413 } 3414 } 3415 if len(m.RequiredDropCapabilities) > 0 { 3416 for _, s := range m.RequiredDropCapabilities { 3417 l = len(s) 3418 n += 1 + l + sovGenerated(uint64(l)) 3419 } 3420 } 3421 if len(m.AllowedCapabilities) > 0 { 3422 for _, s := range m.AllowedCapabilities { 3423 l = len(s) 3424 n += 1 + l + sovGenerated(uint64(l)) 3425 } 3426 } 3427 if len(m.Volumes) > 0 { 3428 for _, s := range m.Volumes { 3429 l = len(s) 3430 n += 1 + l + sovGenerated(uint64(l)) 3431 } 3432 } 3433 n += 2 3434 if len(m.HostPorts) > 0 { 3435 for _, e := range m.HostPorts { 3436 l = e.Size() 3437 n += 1 + l + sovGenerated(uint64(l)) 3438 } 3439 } 3440 n += 2 3441 n += 2 3442 l = m.SELinux.Size() 3443 n += 1 + l + sovGenerated(uint64(l)) 3444 l = m.RunAsUser.Size() 3445 n += 1 + l + sovGenerated(uint64(l)) 3446 l = m.SupplementalGroups.Size() 3447 n += 1 + l + sovGenerated(uint64(l)) 3448 l = m.FSGroup.Size() 3449 n += 1 + l + sovGenerated(uint64(l)) 3450 n += 2 3451 if m.DefaultAllowPrivilegeEscalation != nil { 3452 n += 2 3453 } 3454 if m.AllowPrivilegeEscalation != nil { 3455 n += 3 3456 } 3457 if len(m.AllowedHostPaths) > 0 { 3458 for _, e := range m.AllowedHostPaths { 3459 l = e.Size() 3460 n += 2 + l + sovGenerated(uint64(l)) 3461 } 3462 } 3463 if len(m.AllowedFlexVolumes) > 0 { 3464 for _, e := range m.AllowedFlexVolumes { 3465 l = e.Size() 3466 n += 2 + l + sovGenerated(uint64(l)) 3467 } 3468 } 3469 if len(m.AllowedUnsafeSysctls) > 0 { 3470 for _, s := range m.AllowedUnsafeSysctls { 3471 l = len(s) 3472 n += 2 + l + sovGenerated(uint64(l)) 3473 } 3474 } 3475 if len(m.ForbiddenSysctls) > 0 { 3476 for _, s := range m.ForbiddenSysctls { 3477 l = len(s) 3478 n += 2 + l + sovGenerated(uint64(l)) 3479 } 3480 } 3481 if len(m.AllowedProcMountTypes) > 0 { 3482 for _, s := range m.AllowedProcMountTypes { 3483 l = len(s) 3484 n += 2 + l + sovGenerated(uint64(l)) 3485 } 3486 } 3487 if m.RunAsGroup != nil { 3488 l = m.RunAsGroup.Size() 3489 n += 2 + l + sovGenerated(uint64(l)) 3490 } 3491 if len(m.AllowedCSIDrivers) > 0 { 3492 for _, e := range m.AllowedCSIDrivers { 3493 l = e.Size() 3494 n += 2 + l + sovGenerated(uint64(l)) 3495 } 3496 } 3497 if m.RuntimeClass != nil { 3498 l = m.RuntimeClass.Size() 3499 n += 2 + l + sovGenerated(uint64(l)) 3500 } 3501 return n 3502} 3503 3504func (m *ReplicaSet) Size() (n int) { 3505 var l int 3506 _ = l 3507 l = m.ObjectMeta.Size() 3508 n += 1 + l + sovGenerated(uint64(l)) 3509 l = m.Spec.Size() 3510 n += 1 + l + sovGenerated(uint64(l)) 3511 l = m.Status.Size() 3512 n += 1 + l + sovGenerated(uint64(l)) 3513 return n 3514} 3515 3516func (m *ReplicaSetCondition) Size() (n int) { 3517 var l int 3518 _ = l 3519 l = len(m.Type) 3520 n += 1 + l + sovGenerated(uint64(l)) 3521 l = len(m.Status) 3522 n += 1 + l + sovGenerated(uint64(l)) 3523 l = m.LastTransitionTime.Size() 3524 n += 1 + l + sovGenerated(uint64(l)) 3525 l = len(m.Reason) 3526 n += 1 + l + sovGenerated(uint64(l)) 3527 l = len(m.Message) 3528 n += 1 + l + sovGenerated(uint64(l)) 3529 return n 3530} 3531 3532func (m *ReplicaSetList) Size() (n int) { 3533 var l int 3534 _ = l 3535 l = m.ListMeta.Size() 3536 n += 1 + l + sovGenerated(uint64(l)) 3537 if len(m.Items) > 0 { 3538 for _, e := range m.Items { 3539 l = e.Size() 3540 n += 1 + l + sovGenerated(uint64(l)) 3541 } 3542 } 3543 return n 3544} 3545 3546func (m *ReplicaSetSpec) Size() (n int) { 3547 var l int 3548 _ = l 3549 if m.Replicas != nil { 3550 n += 1 + sovGenerated(uint64(*m.Replicas)) 3551 } 3552 if m.Selector != nil { 3553 l = m.Selector.Size() 3554 n += 1 + l + sovGenerated(uint64(l)) 3555 } 3556 l = m.Template.Size() 3557 n += 1 + l + sovGenerated(uint64(l)) 3558 n += 1 + sovGenerated(uint64(m.MinReadySeconds)) 3559 return n 3560} 3561 3562func (m *ReplicaSetStatus) Size() (n int) { 3563 var l int 3564 _ = l 3565 n += 1 + sovGenerated(uint64(m.Replicas)) 3566 n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas)) 3567 n += 1 + sovGenerated(uint64(m.ObservedGeneration)) 3568 n += 1 + sovGenerated(uint64(m.ReadyReplicas)) 3569 n += 1 + sovGenerated(uint64(m.AvailableReplicas)) 3570 if len(m.Conditions) > 0 { 3571 for _, e := range m.Conditions { 3572 l = e.Size() 3573 n += 1 + l + sovGenerated(uint64(l)) 3574 } 3575 } 3576 return n 3577} 3578 3579func (m *ReplicationControllerDummy) Size() (n int) { 3580 var l int 3581 _ = l 3582 return n 3583} 3584 3585func (m *RollbackConfig) Size() (n int) { 3586 var l int 3587 _ = l 3588 n += 1 + sovGenerated(uint64(m.Revision)) 3589 return n 3590} 3591 3592func (m *RollingUpdateDaemonSet) Size() (n int) { 3593 var l int 3594 _ = l 3595 if m.MaxUnavailable != nil { 3596 l = m.MaxUnavailable.Size() 3597 n += 1 + l + sovGenerated(uint64(l)) 3598 } 3599 return n 3600} 3601 3602func (m *RollingUpdateDeployment) Size() (n int) { 3603 var l int 3604 _ = l 3605 if m.MaxUnavailable != nil { 3606 l = m.MaxUnavailable.Size() 3607 n += 1 + l + sovGenerated(uint64(l)) 3608 } 3609 if m.MaxSurge != nil { 3610 l = m.MaxSurge.Size() 3611 n += 1 + l + sovGenerated(uint64(l)) 3612 } 3613 return n 3614} 3615 3616func (m *RunAsGroupStrategyOptions) Size() (n int) { 3617 var l int 3618 _ = l 3619 l = len(m.Rule) 3620 n += 1 + l + sovGenerated(uint64(l)) 3621 if len(m.Ranges) > 0 { 3622 for _, e := range m.Ranges { 3623 l = e.Size() 3624 n += 1 + l + sovGenerated(uint64(l)) 3625 } 3626 } 3627 return n 3628} 3629 3630func (m *RunAsUserStrategyOptions) Size() (n int) { 3631 var l int 3632 _ = l 3633 l = len(m.Rule) 3634 n += 1 + l + sovGenerated(uint64(l)) 3635 if len(m.Ranges) > 0 { 3636 for _, e := range m.Ranges { 3637 l = e.Size() 3638 n += 1 + l + sovGenerated(uint64(l)) 3639 } 3640 } 3641 return n 3642} 3643 3644func (m *RuntimeClassStrategyOptions) Size() (n int) { 3645 var l int 3646 _ = l 3647 if len(m.AllowedRuntimeClassNames) > 0 { 3648 for _, s := range m.AllowedRuntimeClassNames { 3649 l = len(s) 3650 n += 1 + l + sovGenerated(uint64(l)) 3651 } 3652 } 3653 if m.DefaultRuntimeClassName != nil { 3654 l = len(*m.DefaultRuntimeClassName) 3655 n += 1 + l + sovGenerated(uint64(l)) 3656 } 3657 return n 3658} 3659 3660func (m *SELinuxStrategyOptions) Size() (n int) { 3661 var l int 3662 _ = l 3663 l = len(m.Rule) 3664 n += 1 + l + sovGenerated(uint64(l)) 3665 if m.SELinuxOptions != nil { 3666 l = m.SELinuxOptions.Size() 3667 n += 1 + l + sovGenerated(uint64(l)) 3668 } 3669 return n 3670} 3671 3672func (m *Scale) Size() (n int) { 3673 var l int 3674 _ = l 3675 l = m.ObjectMeta.Size() 3676 n += 1 + l + sovGenerated(uint64(l)) 3677 l = m.Spec.Size() 3678 n += 1 + l + sovGenerated(uint64(l)) 3679 l = m.Status.Size() 3680 n += 1 + l + sovGenerated(uint64(l)) 3681 return n 3682} 3683 3684func (m *ScaleSpec) Size() (n int) { 3685 var l int 3686 _ = l 3687 n += 1 + sovGenerated(uint64(m.Replicas)) 3688 return n 3689} 3690 3691func (m *ScaleStatus) Size() (n int) { 3692 var l int 3693 _ = l 3694 n += 1 + sovGenerated(uint64(m.Replicas)) 3695 if len(m.Selector) > 0 { 3696 for k, v := range m.Selector { 3697 _ = k 3698 _ = v 3699 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) 3700 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) 3701 } 3702 } 3703 l = len(m.TargetSelector) 3704 n += 1 + l + sovGenerated(uint64(l)) 3705 return n 3706} 3707 3708func (m *SupplementalGroupsStrategyOptions) Size() (n int) { 3709 var l int 3710 _ = l 3711 l = len(m.Rule) 3712 n += 1 + l + sovGenerated(uint64(l)) 3713 if len(m.Ranges) > 0 { 3714 for _, e := range m.Ranges { 3715 l = e.Size() 3716 n += 1 + l + sovGenerated(uint64(l)) 3717 } 3718 } 3719 return n 3720} 3721 3722func sovGenerated(x uint64) (n int) { 3723 for { 3724 n++ 3725 x >>= 7 3726 if x == 0 { 3727 break 3728 } 3729 } 3730 return n 3731} 3732func sozGenerated(x uint64) (n int) { 3733 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 3734} 3735func (this *AllowedCSIDriver) String() string { 3736 if this == nil { 3737 return "nil" 3738 } 3739 s := strings.Join([]string{`&AllowedCSIDriver{`, 3740 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 3741 `}`, 3742 }, "") 3743 return s 3744} 3745func (this *AllowedFlexVolume) String() string { 3746 if this == nil { 3747 return "nil" 3748 } 3749 s := strings.Join([]string{`&AllowedFlexVolume{`, 3750 `Driver:` + fmt.Sprintf("%v", this.Driver) + `,`, 3751 `}`, 3752 }, "") 3753 return s 3754} 3755func (this *AllowedHostPath) String() string { 3756 if this == nil { 3757 return "nil" 3758 } 3759 s := strings.Join([]string{`&AllowedHostPath{`, 3760 `PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`, 3761 `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`, 3762 `}`, 3763 }, "") 3764 return s 3765} 3766func (this *DaemonSet) String() string { 3767 if this == nil { 3768 return "nil" 3769 } 3770 s := strings.Join([]string{`&DaemonSet{`, 3771 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 3772 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`, 3773 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`, 3774 `}`, 3775 }, "") 3776 return s 3777} 3778func (this *DaemonSetCondition) String() string { 3779 if this == nil { 3780 return "nil" 3781 } 3782 s := strings.Join([]string{`&DaemonSetCondition{`, 3783 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3784 `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 3785 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 3786 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, 3787 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 3788 `}`, 3789 }, "") 3790 return s 3791} 3792func (this *DaemonSetList) String() string { 3793 if this == nil { 3794 return "nil" 3795 } 3796 s := strings.Join([]string{`&DaemonSetList{`, 3797 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 3798 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + `,`, 3799 `}`, 3800 }, "") 3801 return s 3802} 3803func (this *DaemonSetSpec) String() string { 3804 if this == nil { 3805 return "nil" 3806 } 3807 s := strings.Join([]string{`&DaemonSetSpec{`, 3808 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 3809 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`, 3810 `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`, 3811 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, 3812 `TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`, 3813 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, 3814 `}`, 3815 }, "") 3816 return s 3817} 3818func (this *DaemonSetStatus) String() string { 3819 if this == nil { 3820 return "nil" 3821 } 3822 s := strings.Join([]string{`&DaemonSetStatus{`, 3823 `CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`, 3824 `NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`, 3825 `DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`, 3826 `NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`, 3827 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, 3828 `UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`, 3829 `NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`, 3830 `NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`, 3831 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, 3832 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + `,`, 3833 `}`, 3834 }, "") 3835 return s 3836} 3837func (this *DaemonSetUpdateStrategy) String() string { 3838 if this == nil { 3839 return "nil" 3840 } 3841 s := strings.Join([]string{`&DaemonSetUpdateStrategy{`, 3842 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3843 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`, 3844 `}`, 3845 }, "") 3846 return s 3847} 3848func (this *Deployment) String() string { 3849 if this == nil { 3850 return "nil" 3851 } 3852 s := strings.Join([]string{`&Deployment{`, 3853 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 3854 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`, 3855 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`, 3856 `}`, 3857 }, "") 3858 return s 3859} 3860func (this *DeploymentCondition) String() string { 3861 if this == nil { 3862 return "nil" 3863 } 3864 s := strings.Join([]string{`&DeploymentCondition{`, 3865 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3866 `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 3867 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, 3868 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 3869 `LastUpdateTime:` + strings.Replace(strings.Replace(this.LastUpdateTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 3870 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 3871 `}`, 3872 }, "") 3873 return s 3874} 3875func (this *DeploymentList) String() string { 3876 if this == nil { 3877 return "nil" 3878 } 3879 s := strings.Join([]string{`&DeploymentList{`, 3880 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 3881 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Deployment", "Deployment", 1), `&`, ``, 1) + `,`, 3882 `}`, 3883 }, "") 3884 return s 3885} 3886func (this *DeploymentRollback) String() string { 3887 if this == nil { 3888 return "nil" 3889 } 3890 keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations)) 3891 for k := range this.UpdatedAnnotations { 3892 keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k) 3893 } 3894 github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations) 3895 mapStringForUpdatedAnnotations := "map[string]string{" 3896 for _, k := range keysForUpdatedAnnotations { 3897 mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k]) 3898 } 3899 mapStringForUpdatedAnnotations += "}" 3900 s := strings.Join([]string{`&DeploymentRollback{`, 3901 `Name:` + fmt.Sprintf("%v", this.Name) + `,`, 3902 `UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`, 3903 `RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`, 3904 `}`, 3905 }, "") 3906 return s 3907} 3908func (this *DeploymentSpec) String() string { 3909 if this == nil { 3910 return "nil" 3911 } 3912 s := strings.Join([]string{`&DeploymentSpec{`, 3913 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, 3914 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 3915 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`, 3916 `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`, 3917 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, 3918 `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, 3919 `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`, 3920 `RollbackTo:` + strings.Replace(fmt.Sprintf("%v", this.RollbackTo), "RollbackConfig", "RollbackConfig", 1) + `,`, 3921 `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`, 3922 `}`, 3923 }, "") 3924 return s 3925} 3926func (this *DeploymentStatus) String() string { 3927 if this == nil { 3928 return "nil" 3929 } 3930 s := strings.Join([]string{`&DeploymentStatus{`, 3931 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, 3932 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 3933 `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`, 3934 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, 3935 `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`, 3936 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + `,`, 3937 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, 3938 `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, 3939 `}`, 3940 }, "") 3941 return s 3942} 3943func (this *DeploymentStrategy) String() string { 3944 if this == nil { 3945 return "nil" 3946 } 3947 s := strings.Join([]string{`&DeploymentStrategy{`, 3948 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 3949 `RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`, 3950 `}`, 3951 }, "") 3952 return s 3953} 3954func (this *FSGroupStrategyOptions) String() string { 3955 if this == nil { 3956 return "nil" 3957 } 3958 s := strings.Join([]string{`&FSGroupStrategyOptions{`, 3959 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 3960 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 3961 `}`, 3962 }, "") 3963 return s 3964} 3965func (this *HTTPIngressPath) String() string { 3966 if this == nil { 3967 return "nil" 3968 } 3969 s := strings.Join([]string{`&HTTPIngressPath{`, 3970 `Path:` + fmt.Sprintf("%v", this.Path) + `,`, 3971 `Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`, 3972 `}`, 3973 }, "") 3974 return s 3975} 3976func (this *HTTPIngressRuleValue) String() string { 3977 if this == nil { 3978 return "nil" 3979 } 3980 s := strings.Join([]string{`&HTTPIngressRuleValue{`, 3981 `Paths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Paths), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + `,`, 3982 `}`, 3983 }, "") 3984 return s 3985} 3986func (this *HostPortRange) String() string { 3987 if this == nil { 3988 return "nil" 3989 } 3990 s := strings.Join([]string{`&HostPortRange{`, 3991 `Min:` + fmt.Sprintf("%v", this.Min) + `,`, 3992 `Max:` + fmt.Sprintf("%v", this.Max) + `,`, 3993 `}`, 3994 }, "") 3995 return s 3996} 3997func (this *IDRange) String() string { 3998 if this == nil { 3999 return "nil" 4000 } 4001 s := strings.Join([]string{`&IDRange{`, 4002 `Min:` + fmt.Sprintf("%v", this.Min) + `,`, 4003 `Max:` + fmt.Sprintf("%v", this.Max) + `,`, 4004 `}`, 4005 }, "") 4006 return s 4007} 4008func (this *IPBlock) String() string { 4009 if this == nil { 4010 return "nil" 4011 } 4012 s := strings.Join([]string{`&IPBlock{`, 4013 `CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`, 4014 `Except:` + fmt.Sprintf("%v", this.Except) + `,`, 4015 `}`, 4016 }, "") 4017 return s 4018} 4019func (this *Ingress) String() string { 4020 if this == nil { 4021 return "nil" 4022 } 4023 s := strings.Join([]string{`&Ingress{`, 4024 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4025 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`, 4026 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`, 4027 `}`, 4028 }, "") 4029 return s 4030} 4031func (this *IngressBackend) String() string { 4032 if this == nil { 4033 return "nil" 4034 } 4035 s := strings.Join([]string{`&IngressBackend{`, 4036 `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`, 4037 `ServicePort:` + strings.Replace(strings.Replace(this.ServicePort.String(), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1), `&`, ``, 1) + `,`, 4038 `}`, 4039 }, "") 4040 return s 4041} 4042func (this *IngressList) String() string { 4043 if this == nil { 4044 return "nil" 4045 } 4046 s := strings.Join([]string{`&IngressList{`, 4047 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4048 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Ingress", "Ingress", 1), `&`, ``, 1) + `,`, 4049 `}`, 4050 }, "") 4051 return s 4052} 4053func (this *IngressRule) String() string { 4054 if this == nil { 4055 return "nil" 4056 } 4057 s := strings.Join([]string{`&IngressRule{`, 4058 `Host:` + fmt.Sprintf("%v", this.Host) + `,`, 4059 `IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`, 4060 `}`, 4061 }, "") 4062 return s 4063} 4064func (this *IngressRuleValue) String() string { 4065 if this == nil { 4066 return "nil" 4067 } 4068 s := strings.Join([]string{`&IngressRuleValue{`, 4069 `HTTP:` + strings.Replace(fmt.Sprintf("%v", this.HTTP), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`, 4070 `}`, 4071 }, "") 4072 return s 4073} 4074func (this *IngressSpec) String() string { 4075 if this == nil { 4076 return "nil" 4077 } 4078 s := strings.Join([]string{`&IngressSpec{`, 4079 `Backend:` + strings.Replace(fmt.Sprintf("%v", this.Backend), "IngressBackend", "IngressBackend", 1) + `,`, 4080 `TLS:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.TLS), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + `,`, 4081 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "IngressRule", "IngressRule", 1), `&`, ``, 1) + `,`, 4082 `}`, 4083 }, "") 4084 return s 4085} 4086func (this *IngressStatus) String() string { 4087 if this == nil { 4088 return "nil" 4089 } 4090 s := strings.Join([]string{`&IngressStatus{`, 4091 `LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "LoadBalancerStatus", "k8s_io_api_core_v1.LoadBalancerStatus", 1), `&`, ``, 1) + `,`, 4092 `}`, 4093 }, "") 4094 return s 4095} 4096func (this *IngressTLS) String() string { 4097 if this == nil { 4098 return "nil" 4099 } 4100 s := strings.Join([]string{`&IngressTLS{`, 4101 `Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`, 4102 `SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`, 4103 `}`, 4104 }, "") 4105 return s 4106} 4107func (this *NetworkPolicy) String() string { 4108 if this == nil { 4109 return "nil" 4110 } 4111 s := strings.Join([]string{`&NetworkPolicy{`, 4112 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4113 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`, 4114 `}`, 4115 }, "") 4116 return s 4117} 4118func (this *NetworkPolicyEgressRule) String() string { 4119 if this == nil { 4120 return "nil" 4121 } 4122 s := strings.Join([]string{`&NetworkPolicyEgressRule{`, 4123 `Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`, 4124 `To:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.To), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`, 4125 `}`, 4126 }, "") 4127 return s 4128} 4129func (this *NetworkPolicyIngressRule) String() string { 4130 if this == nil { 4131 return "nil" 4132 } 4133 s := strings.Join([]string{`&NetworkPolicyIngressRule{`, 4134 `Ports:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ports), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + `,`, 4135 `From:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.From), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + `,`, 4136 `}`, 4137 }, "") 4138 return s 4139} 4140func (this *NetworkPolicyList) String() string { 4141 if this == nil { 4142 return "nil" 4143 } 4144 s := strings.Join([]string{`&NetworkPolicyList{`, 4145 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4146 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + `,`, 4147 `}`, 4148 }, "") 4149 return s 4150} 4151func (this *NetworkPolicyPeer) String() string { 4152 if this == nil { 4153 return "nil" 4154 } 4155 s := strings.Join([]string{`&NetworkPolicyPeer{`, 4156 `PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 4157 `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 4158 `IPBlock:` + strings.Replace(fmt.Sprintf("%v", this.IPBlock), "IPBlock", "IPBlock", 1) + `,`, 4159 `}`, 4160 }, "") 4161 return s 4162} 4163func (this *NetworkPolicyPort) String() string { 4164 if this == nil { 4165 return "nil" 4166 } 4167 s := strings.Join([]string{`&NetworkPolicyPort{`, 4168 `Protocol:` + valueToStringGenerated(this.Protocol) + `,`, 4169 `Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4170 `}`, 4171 }, "") 4172 return s 4173} 4174func (this *NetworkPolicySpec) String() string { 4175 if this == nil { 4176 return "nil" 4177 } 4178 s := strings.Join([]string{`&NetworkPolicySpec{`, 4179 `PodSelector:` + strings.Replace(strings.Replace(this.PodSelector.String(), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1), `&`, ``, 1) + `,`, 4180 `Ingress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ingress), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + `,`, 4181 `Egress:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Egress), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + `,`, 4182 `PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`, 4183 `}`, 4184 }, "") 4185 return s 4186} 4187func (this *PodSecurityPolicy) String() string { 4188 if this == nil { 4189 return "nil" 4190 } 4191 s := strings.Join([]string{`&PodSecurityPolicy{`, 4192 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4193 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`, 4194 `}`, 4195 }, "") 4196 return s 4197} 4198func (this *PodSecurityPolicyList) String() string { 4199 if this == nil { 4200 return "nil" 4201 } 4202 s := strings.Join([]string{`&PodSecurityPolicyList{`, 4203 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4204 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + `,`, 4205 `}`, 4206 }, "") 4207 return s 4208} 4209func (this *PodSecurityPolicySpec) String() string { 4210 if this == nil { 4211 return "nil" 4212 } 4213 s := strings.Join([]string{`&PodSecurityPolicySpec{`, 4214 `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`, 4215 `DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`, 4216 `RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`, 4217 `AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`, 4218 `Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`, 4219 `HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`, 4220 `HostPorts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.HostPorts), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + `,`, 4221 `HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`, 4222 `HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`, 4223 `SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`, 4224 `RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`, 4225 `SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`, 4226 `FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`, 4227 `ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`, 4228 `DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`, 4229 `AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`, 4230 `AllowedHostPaths:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedHostPaths), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + `,`, 4231 `AllowedFlexVolumes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedFlexVolumes), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + `,`, 4232 `AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`, 4233 `ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`, 4234 `AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`, 4235 `RunAsGroup:` + strings.Replace(fmt.Sprintf("%v", this.RunAsGroup), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`, 4236 `AllowedCSIDrivers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedCSIDrivers), "AllowedCSIDriver", "AllowedCSIDriver", 1), `&`, ``, 1) + `,`, 4237 `RuntimeClass:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeClass), "RuntimeClassStrategyOptions", "RuntimeClassStrategyOptions", 1) + `,`, 4238 `}`, 4239 }, "") 4240 return s 4241} 4242func (this *ReplicaSet) String() string { 4243 if this == nil { 4244 return "nil" 4245 } 4246 s := strings.Join([]string{`&ReplicaSet{`, 4247 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4248 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`, 4249 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`, 4250 `}`, 4251 }, "") 4252 return s 4253} 4254func (this *ReplicaSetCondition) String() string { 4255 if this == nil { 4256 return "nil" 4257 } 4258 s := strings.Join([]string{`&ReplicaSetCondition{`, 4259 `Type:` + fmt.Sprintf("%v", this.Type) + `,`, 4260 `Status:` + fmt.Sprintf("%v", this.Status) + `,`, 4261 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, 4262 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, 4263 `Message:` + fmt.Sprintf("%v", this.Message) + `,`, 4264 `}`, 4265 }, "") 4266 return s 4267} 4268func (this *ReplicaSetList) String() string { 4269 if this == nil { 4270 return "nil" 4271 } 4272 s := strings.Join([]string{`&ReplicaSetList{`, 4273 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, 4274 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + `,`, 4275 `}`, 4276 }, "") 4277 return s 4278} 4279func (this *ReplicaSetSpec) String() string { 4280 if this == nil { 4281 return "nil" 4282 } 4283 s := strings.Join([]string{`&ReplicaSetSpec{`, 4284 `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, 4285 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`, 4286 `Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_api_core_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`, 4287 `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, 4288 `}`, 4289 }, "") 4290 return s 4291} 4292func (this *ReplicaSetStatus) String() string { 4293 if this == nil { 4294 return "nil" 4295 } 4296 s := strings.Join([]string{`&ReplicaSetStatus{`, 4297 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 4298 `FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`, 4299 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, 4300 `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, 4301 `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, 4302 `Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + `,`, 4303 `}`, 4304 }, "") 4305 return s 4306} 4307func (this *ReplicationControllerDummy) String() string { 4308 if this == nil { 4309 return "nil" 4310 } 4311 s := strings.Join([]string{`&ReplicationControllerDummy{`, 4312 `}`, 4313 }, "") 4314 return s 4315} 4316func (this *RollbackConfig) String() string { 4317 if this == nil { 4318 return "nil" 4319 } 4320 s := strings.Join([]string{`&RollbackConfig{`, 4321 `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, 4322 `}`, 4323 }, "") 4324 return s 4325} 4326func (this *RollingUpdateDaemonSet) String() string { 4327 if this == nil { 4328 return "nil" 4329 } 4330 s := strings.Join([]string{`&RollingUpdateDaemonSet{`, 4331 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4332 `}`, 4333 }, "") 4334 return s 4335} 4336func (this *RollingUpdateDeployment) String() string { 4337 if this == nil { 4338 return "nil" 4339 } 4340 s := strings.Join([]string{`&RollingUpdateDeployment{`, 4341 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4342 `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "k8s_io_apimachinery_pkg_util_intstr.IntOrString", 1) + `,`, 4343 `}`, 4344 }, "") 4345 return s 4346} 4347func (this *RunAsGroupStrategyOptions) String() string { 4348 if this == nil { 4349 return "nil" 4350 } 4351 s := strings.Join([]string{`&RunAsGroupStrategyOptions{`, 4352 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4353 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 4354 `}`, 4355 }, "") 4356 return s 4357} 4358func (this *RunAsUserStrategyOptions) String() string { 4359 if this == nil { 4360 return "nil" 4361 } 4362 s := strings.Join([]string{`&RunAsUserStrategyOptions{`, 4363 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4364 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 4365 `}`, 4366 }, "") 4367 return s 4368} 4369func (this *RuntimeClassStrategyOptions) String() string { 4370 if this == nil { 4371 return "nil" 4372 } 4373 s := strings.Join([]string{`&RuntimeClassStrategyOptions{`, 4374 `AllowedRuntimeClassNames:` + fmt.Sprintf("%v", this.AllowedRuntimeClassNames) + `,`, 4375 `DefaultRuntimeClassName:` + valueToStringGenerated(this.DefaultRuntimeClassName) + `,`, 4376 `}`, 4377 }, "") 4378 return s 4379} 4380func (this *SELinuxStrategyOptions) String() string { 4381 if this == nil { 4382 return "nil" 4383 } 4384 s := strings.Join([]string{`&SELinuxStrategyOptions{`, 4385 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4386 `SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "k8s_io_api_core_v1.SELinuxOptions", 1) + `,`, 4387 `}`, 4388 }, "") 4389 return s 4390} 4391func (this *Scale) String() string { 4392 if this == nil { 4393 return "nil" 4394 } 4395 s := strings.Join([]string{`&Scale{`, 4396 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`, 4397 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`, 4398 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`, 4399 `}`, 4400 }, "") 4401 return s 4402} 4403func (this *ScaleSpec) String() string { 4404 if this == nil { 4405 return "nil" 4406 } 4407 s := strings.Join([]string{`&ScaleSpec{`, 4408 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 4409 `}`, 4410 }, "") 4411 return s 4412} 4413func (this *ScaleStatus) String() string { 4414 if this == nil { 4415 return "nil" 4416 } 4417 keysForSelector := make([]string, 0, len(this.Selector)) 4418 for k := range this.Selector { 4419 keysForSelector = append(keysForSelector, k) 4420 } 4421 github_com_gogo_protobuf_sortkeys.Strings(keysForSelector) 4422 mapStringForSelector := "map[string]string{" 4423 for _, k := range keysForSelector { 4424 mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k]) 4425 } 4426 mapStringForSelector += "}" 4427 s := strings.Join([]string{`&ScaleStatus{`, 4428 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, 4429 `Selector:` + mapStringForSelector + `,`, 4430 `TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`, 4431 `}`, 4432 }, "") 4433 return s 4434} 4435func (this *SupplementalGroupsStrategyOptions) String() string { 4436 if this == nil { 4437 return "nil" 4438 } 4439 s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`, 4440 `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, 4441 `Ranges:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Ranges), "IDRange", "IDRange", 1), `&`, ``, 1) + `,`, 4442 `}`, 4443 }, "") 4444 return s 4445} 4446func valueToStringGenerated(v interface{}) string { 4447 rv := reflect.ValueOf(v) 4448 if rv.IsNil() { 4449 return "nil" 4450 } 4451 pv := reflect.Indirect(rv).Interface() 4452 return fmt.Sprintf("*%v", pv) 4453} 4454func (m *AllowedCSIDriver) Unmarshal(dAtA []byte) error { 4455 l := len(dAtA) 4456 iNdEx := 0 4457 for iNdEx < l { 4458 preIndex := iNdEx 4459 var wire uint64 4460 for shift := uint(0); ; shift += 7 { 4461 if shift >= 64 { 4462 return ErrIntOverflowGenerated 4463 } 4464 if iNdEx >= l { 4465 return io.ErrUnexpectedEOF 4466 } 4467 b := dAtA[iNdEx] 4468 iNdEx++ 4469 wire |= (uint64(b) & 0x7F) << shift 4470 if b < 0x80 { 4471 break 4472 } 4473 } 4474 fieldNum := int32(wire >> 3) 4475 wireType := int(wire & 0x7) 4476 if wireType == 4 { 4477 return fmt.Errorf("proto: AllowedCSIDriver: wiretype end group for non-group") 4478 } 4479 if fieldNum <= 0 { 4480 return fmt.Errorf("proto: AllowedCSIDriver: illegal tag %d (wire type %d)", fieldNum, wire) 4481 } 4482 switch fieldNum { 4483 case 1: 4484 if wireType != 2 { 4485 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 4486 } 4487 var stringLen uint64 4488 for shift := uint(0); ; shift += 7 { 4489 if shift >= 64 { 4490 return ErrIntOverflowGenerated 4491 } 4492 if iNdEx >= l { 4493 return io.ErrUnexpectedEOF 4494 } 4495 b := dAtA[iNdEx] 4496 iNdEx++ 4497 stringLen |= (uint64(b) & 0x7F) << shift 4498 if b < 0x80 { 4499 break 4500 } 4501 } 4502 intStringLen := int(stringLen) 4503 if intStringLen < 0 { 4504 return ErrInvalidLengthGenerated 4505 } 4506 postIndex := iNdEx + intStringLen 4507 if postIndex > l { 4508 return io.ErrUnexpectedEOF 4509 } 4510 m.Name = string(dAtA[iNdEx:postIndex]) 4511 iNdEx = postIndex 4512 default: 4513 iNdEx = preIndex 4514 skippy, err := skipGenerated(dAtA[iNdEx:]) 4515 if err != nil { 4516 return err 4517 } 4518 if skippy < 0 { 4519 return ErrInvalidLengthGenerated 4520 } 4521 if (iNdEx + skippy) > l { 4522 return io.ErrUnexpectedEOF 4523 } 4524 iNdEx += skippy 4525 } 4526 } 4527 4528 if iNdEx > l { 4529 return io.ErrUnexpectedEOF 4530 } 4531 return nil 4532} 4533func (m *AllowedFlexVolume) Unmarshal(dAtA []byte) error { 4534 l := len(dAtA) 4535 iNdEx := 0 4536 for iNdEx < l { 4537 preIndex := iNdEx 4538 var wire uint64 4539 for shift := uint(0); ; shift += 7 { 4540 if shift >= 64 { 4541 return ErrIntOverflowGenerated 4542 } 4543 if iNdEx >= l { 4544 return io.ErrUnexpectedEOF 4545 } 4546 b := dAtA[iNdEx] 4547 iNdEx++ 4548 wire |= (uint64(b) & 0x7F) << shift 4549 if b < 0x80 { 4550 break 4551 } 4552 } 4553 fieldNum := int32(wire >> 3) 4554 wireType := int(wire & 0x7) 4555 if wireType == 4 { 4556 return fmt.Errorf("proto: AllowedFlexVolume: wiretype end group for non-group") 4557 } 4558 if fieldNum <= 0 { 4559 return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire) 4560 } 4561 switch fieldNum { 4562 case 1: 4563 if wireType != 2 { 4564 return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType) 4565 } 4566 var stringLen uint64 4567 for shift := uint(0); ; shift += 7 { 4568 if shift >= 64 { 4569 return ErrIntOverflowGenerated 4570 } 4571 if iNdEx >= l { 4572 return io.ErrUnexpectedEOF 4573 } 4574 b := dAtA[iNdEx] 4575 iNdEx++ 4576 stringLen |= (uint64(b) & 0x7F) << shift 4577 if b < 0x80 { 4578 break 4579 } 4580 } 4581 intStringLen := int(stringLen) 4582 if intStringLen < 0 { 4583 return ErrInvalidLengthGenerated 4584 } 4585 postIndex := iNdEx + intStringLen 4586 if postIndex > l { 4587 return io.ErrUnexpectedEOF 4588 } 4589 m.Driver = string(dAtA[iNdEx:postIndex]) 4590 iNdEx = postIndex 4591 default: 4592 iNdEx = preIndex 4593 skippy, err := skipGenerated(dAtA[iNdEx:]) 4594 if err != nil { 4595 return err 4596 } 4597 if skippy < 0 { 4598 return ErrInvalidLengthGenerated 4599 } 4600 if (iNdEx + skippy) > l { 4601 return io.ErrUnexpectedEOF 4602 } 4603 iNdEx += skippy 4604 } 4605 } 4606 4607 if iNdEx > l { 4608 return io.ErrUnexpectedEOF 4609 } 4610 return nil 4611} 4612func (m *AllowedHostPath) Unmarshal(dAtA []byte) error { 4613 l := len(dAtA) 4614 iNdEx := 0 4615 for iNdEx < l { 4616 preIndex := iNdEx 4617 var wire uint64 4618 for shift := uint(0); ; shift += 7 { 4619 if shift >= 64 { 4620 return ErrIntOverflowGenerated 4621 } 4622 if iNdEx >= l { 4623 return io.ErrUnexpectedEOF 4624 } 4625 b := dAtA[iNdEx] 4626 iNdEx++ 4627 wire |= (uint64(b) & 0x7F) << shift 4628 if b < 0x80 { 4629 break 4630 } 4631 } 4632 fieldNum := int32(wire >> 3) 4633 wireType := int(wire & 0x7) 4634 if wireType == 4 { 4635 return fmt.Errorf("proto: AllowedHostPath: wiretype end group for non-group") 4636 } 4637 if fieldNum <= 0 { 4638 return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire) 4639 } 4640 switch fieldNum { 4641 case 1: 4642 if wireType != 2 { 4643 return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType) 4644 } 4645 var stringLen uint64 4646 for shift := uint(0); ; shift += 7 { 4647 if shift >= 64 { 4648 return ErrIntOverflowGenerated 4649 } 4650 if iNdEx >= l { 4651 return io.ErrUnexpectedEOF 4652 } 4653 b := dAtA[iNdEx] 4654 iNdEx++ 4655 stringLen |= (uint64(b) & 0x7F) << shift 4656 if b < 0x80 { 4657 break 4658 } 4659 } 4660 intStringLen := int(stringLen) 4661 if intStringLen < 0 { 4662 return ErrInvalidLengthGenerated 4663 } 4664 postIndex := iNdEx + intStringLen 4665 if postIndex > l { 4666 return io.ErrUnexpectedEOF 4667 } 4668 m.PathPrefix = string(dAtA[iNdEx:postIndex]) 4669 iNdEx = postIndex 4670 case 2: 4671 if wireType != 0 { 4672 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType) 4673 } 4674 var v int 4675 for shift := uint(0); ; shift += 7 { 4676 if shift >= 64 { 4677 return ErrIntOverflowGenerated 4678 } 4679 if iNdEx >= l { 4680 return io.ErrUnexpectedEOF 4681 } 4682 b := dAtA[iNdEx] 4683 iNdEx++ 4684 v |= (int(b) & 0x7F) << shift 4685 if b < 0x80 { 4686 break 4687 } 4688 } 4689 m.ReadOnly = bool(v != 0) 4690 default: 4691 iNdEx = preIndex 4692 skippy, err := skipGenerated(dAtA[iNdEx:]) 4693 if err != nil { 4694 return err 4695 } 4696 if skippy < 0 { 4697 return ErrInvalidLengthGenerated 4698 } 4699 if (iNdEx + skippy) > l { 4700 return io.ErrUnexpectedEOF 4701 } 4702 iNdEx += skippy 4703 } 4704 } 4705 4706 if iNdEx > l { 4707 return io.ErrUnexpectedEOF 4708 } 4709 return nil 4710} 4711func (m *DaemonSet) Unmarshal(dAtA []byte) error { 4712 l := len(dAtA) 4713 iNdEx := 0 4714 for iNdEx < l { 4715 preIndex := iNdEx 4716 var wire uint64 4717 for shift := uint(0); ; shift += 7 { 4718 if shift >= 64 { 4719 return ErrIntOverflowGenerated 4720 } 4721 if iNdEx >= l { 4722 return io.ErrUnexpectedEOF 4723 } 4724 b := dAtA[iNdEx] 4725 iNdEx++ 4726 wire |= (uint64(b) & 0x7F) << shift 4727 if b < 0x80 { 4728 break 4729 } 4730 } 4731 fieldNum := int32(wire >> 3) 4732 wireType := int(wire & 0x7) 4733 if wireType == 4 { 4734 return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group") 4735 } 4736 if fieldNum <= 0 { 4737 return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire) 4738 } 4739 switch fieldNum { 4740 case 1: 4741 if wireType != 2 { 4742 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 4743 } 4744 var msglen int 4745 for shift := uint(0); ; shift += 7 { 4746 if shift >= 64 { 4747 return ErrIntOverflowGenerated 4748 } 4749 if iNdEx >= l { 4750 return io.ErrUnexpectedEOF 4751 } 4752 b := dAtA[iNdEx] 4753 iNdEx++ 4754 msglen |= (int(b) & 0x7F) << shift 4755 if b < 0x80 { 4756 break 4757 } 4758 } 4759 if msglen < 0 { 4760 return ErrInvalidLengthGenerated 4761 } 4762 postIndex := iNdEx + msglen 4763 if postIndex > l { 4764 return io.ErrUnexpectedEOF 4765 } 4766 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4767 return err 4768 } 4769 iNdEx = postIndex 4770 case 2: 4771 if wireType != 2 { 4772 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 4773 } 4774 var msglen int 4775 for shift := uint(0); ; shift += 7 { 4776 if shift >= 64 { 4777 return ErrIntOverflowGenerated 4778 } 4779 if iNdEx >= l { 4780 return io.ErrUnexpectedEOF 4781 } 4782 b := dAtA[iNdEx] 4783 iNdEx++ 4784 msglen |= (int(b) & 0x7F) << shift 4785 if b < 0x80 { 4786 break 4787 } 4788 } 4789 if msglen < 0 { 4790 return ErrInvalidLengthGenerated 4791 } 4792 postIndex := iNdEx + msglen 4793 if postIndex > l { 4794 return io.ErrUnexpectedEOF 4795 } 4796 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4797 return err 4798 } 4799 iNdEx = postIndex 4800 case 3: 4801 if wireType != 2 { 4802 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 4803 } 4804 var msglen int 4805 for shift := uint(0); ; shift += 7 { 4806 if shift >= 64 { 4807 return ErrIntOverflowGenerated 4808 } 4809 if iNdEx >= l { 4810 return io.ErrUnexpectedEOF 4811 } 4812 b := dAtA[iNdEx] 4813 iNdEx++ 4814 msglen |= (int(b) & 0x7F) << shift 4815 if b < 0x80 { 4816 break 4817 } 4818 } 4819 if msglen < 0 { 4820 return ErrInvalidLengthGenerated 4821 } 4822 postIndex := iNdEx + msglen 4823 if postIndex > l { 4824 return io.ErrUnexpectedEOF 4825 } 4826 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4827 return err 4828 } 4829 iNdEx = postIndex 4830 default: 4831 iNdEx = preIndex 4832 skippy, err := skipGenerated(dAtA[iNdEx:]) 4833 if err != nil { 4834 return err 4835 } 4836 if skippy < 0 { 4837 return ErrInvalidLengthGenerated 4838 } 4839 if (iNdEx + skippy) > l { 4840 return io.ErrUnexpectedEOF 4841 } 4842 iNdEx += skippy 4843 } 4844 } 4845 4846 if iNdEx > l { 4847 return io.ErrUnexpectedEOF 4848 } 4849 return nil 4850} 4851func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error { 4852 l := len(dAtA) 4853 iNdEx := 0 4854 for iNdEx < l { 4855 preIndex := iNdEx 4856 var wire uint64 4857 for shift := uint(0); ; shift += 7 { 4858 if shift >= 64 { 4859 return ErrIntOverflowGenerated 4860 } 4861 if iNdEx >= l { 4862 return io.ErrUnexpectedEOF 4863 } 4864 b := dAtA[iNdEx] 4865 iNdEx++ 4866 wire |= (uint64(b) & 0x7F) << shift 4867 if b < 0x80 { 4868 break 4869 } 4870 } 4871 fieldNum := int32(wire >> 3) 4872 wireType := int(wire & 0x7) 4873 if wireType == 4 { 4874 return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group") 4875 } 4876 if fieldNum <= 0 { 4877 return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) 4878 } 4879 switch fieldNum { 4880 case 1: 4881 if wireType != 2 { 4882 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 4883 } 4884 var stringLen uint64 4885 for shift := uint(0); ; shift += 7 { 4886 if shift >= 64 { 4887 return ErrIntOverflowGenerated 4888 } 4889 if iNdEx >= l { 4890 return io.ErrUnexpectedEOF 4891 } 4892 b := dAtA[iNdEx] 4893 iNdEx++ 4894 stringLen |= (uint64(b) & 0x7F) << shift 4895 if b < 0x80 { 4896 break 4897 } 4898 } 4899 intStringLen := int(stringLen) 4900 if intStringLen < 0 { 4901 return ErrInvalidLengthGenerated 4902 } 4903 postIndex := iNdEx + intStringLen 4904 if postIndex > l { 4905 return io.ErrUnexpectedEOF 4906 } 4907 m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex]) 4908 iNdEx = postIndex 4909 case 2: 4910 if wireType != 2 { 4911 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 4912 } 4913 var stringLen uint64 4914 for shift := uint(0); ; shift += 7 { 4915 if shift >= 64 { 4916 return ErrIntOverflowGenerated 4917 } 4918 if iNdEx >= l { 4919 return io.ErrUnexpectedEOF 4920 } 4921 b := dAtA[iNdEx] 4922 iNdEx++ 4923 stringLen |= (uint64(b) & 0x7F) << shift 4924 if b < 0x80 { 4925 break 4926 } 4927 } 4928 intStringLen := int(stringLen) 4929 if intStringLen < 0 { 4930 return ErrInvalidLengthGenerated 4931 } 4932 postIndex := iNdEx + intStringLen 4933 if postIndex > l { 4934 return io.ErrUnexpectedEOF 4935 } 4936 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) 4937 iNdEx = postIndex 4938 case 3: 4939 if wireType != 2 { 4940 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) 4941 } 4942 var msglen int 4943 for shift := uint(0); ; shift += 7 { 4944 if shift >= 64 { 4945 return ErrIntOverflowGenerated 4946 } 4947 if iNdEx >= l { 4948 return io.ErrUnexpectedEOF 4949 } 4950 b := dAtA[iNdEx] 4951 iNdEx++ 4952 msglen |= (int(b) & 0x7F) << shift 4953 if b < 0x80 { 4954 break 4955 } 4956 } 4957 if msglen < 0 { 4958 return ErrInvalidLengthGenerated 4959 } 4960 postIndex := iNdEx + msglen 4961 if postIndex > l { 4962 return io.ErrUnexpectedEOF 4963 } 4964 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 4965 return err 4966 } 4967 iNdEx = postIndex 4968 case 4: 4969 if wireType != 2 { 4970 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) 4971 } 4972 var stringLen uint64 4973 for shift := uint(0); ; shift += 7 { 4974 if shift >= 64 { 4975 return ErrIntOverflowGenerated 4976 } 4977 if iNdEx >= l { 4978 return io.ErrUnexpectedEOF 4979 } 4980 b := dAtA[iNdEx] 4981 iNdEx++ 4982 stringLen |= (uint64(b) & 0x7F) << shift 4983 if b < 0x80 { 4984 break 4985 } 4986 } 4987 intStringLen := int(stringLen) 4988 if intStringLen < 0 { 4989 return ErrInvalidLengthGenerated 4990 } 4991 postIndex := iNdEx + intStringLen 4992 if postIndex > l { 4993 return io.ErrUnexpectedEOF 4994 } 4995 m.Reason = string(dAtA[iNdEx:postIndex]) 4996 iNdEx = postIndex 4997 case 5: 4998 if wireType != 2 { 4999 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 5000 } 5001 var stringLen uint64 5002 for shift := uint(0); ; shift += 7 { 5003 if shift >= 64 { 5004 return ErrIntOverflowGenerated 5005 } 5006 if iNdEx >= l { 5007 return io.ErrUnexpectedEOF 5008 } 5009 b := dAtA[iNdEx] 5010 iNdEx++ 5011 stringLen |= (uint64(b) & 0x7F) << shift 5012 if b < 0x80 { 5013 break 5014 } 5015 } 5016 intStringLen := int(stringLen) 5017 if intStringLen < 0 { 5018 return ErrInvalidLengthGenerated 5019 } 5020 postIndex := iNdEx + intStringLen 5021 if postIndex > l { 5022 return io.ErrUnexpectedEOF 5023 } 5024 m.Message = string(dAtA[iNdEx:postIndex]) 5025 iNdEx = postIndex 5026 default: 5027 iNdEx = preIndex 5028 skippy, err := skipGenerated(dAtA[iNdEx:]) 5029 if err != nil { 5030 return err 5031 } 5032 if skippy < 0 { 5033 return ErrInvalidLengthGenerated 5034 } 5035 if (iNdEx + skippy) > l { 5036 return io.ErrUnexpectedEOF 5037 } 5038 iNdEx += skippy 5039 } 5040 } 5041 5042 if iNdEx > l { 5043 return io.ErrUnexpectedEOF 5044 } 5045 return nil 5046} 5047func (m *DaemonSetList) Unmarshal(dAtA []byte) error { 5048 l := len(dAtA) 5049 iNdEx := 0 5050 for iNdEx < l { 5051 preIndex := iNdEx 5052 var wire uint64 5053 for shift := uint(0); ; shift += 7 { 5054 if shift >= 64 { 5055 return ErrIntOverflowGenerated 5056 } 5057 if iNdEx >= l { 5058 return io.ErrUnexpectedEOF 5059 } 5060 b := dAtA[iNdEx] 5061 iNdEx++ 5062 wire |= (uint64(b) & 0x7F) << shift 5063 if b < 0x80 { 5064 break 5065 } 5066 } 5067 fieldNum := int32(wire >> 3) 5068 wireType := int(wire & 0x7) 5069 if wireType == 4 { 5070 return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group") 5071 } 5072 if fieldNum <= 0 { 5073 return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire) 5074 } 5075 switch fieldNum { 5076 case 1: 5077 if wireType != 2 { 5078 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 5079 } 5080 var msglen int 5081 for shift := uint(0); ; shift += 7 { 5082 if shift >= 64 { 5083 return ErrIntOverflowGenerated 5084 } 5085 if iNdEx >= l { 5086 return io.ErrUnexpectedEOF 5087 } 5088 b := dAtA[iNdEx] 5089 iNdEx++ 5090 msglen |= (int(b) & 0x7F) << shift 5091 if b < 0x80 { 5092 break 5093 } 5094 } 5095 if msglen < 0 { 5096 return ErrInvalidLengthGenerated 5097 } 5098 postIndex := iNdEx + msglen 5099 if postIndex > l { 5100 return io.ErrUnexpectedEOF 5101 } 5102 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5103 return err 5104 } 5105 iNdEx = postIndex 5106 case 2: 5107 if wireType != 2 { 5108 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 5109 } 5110 var msglen int 5111 for shift := uint(0); ; shift += 7 { 5112 if shift >= 64 { 5113 return ErrIntOverflowGenerated 5114 } 5115 if iNdEx >= l { 5116 return io.ErrUnexpectedEOF 5117 } 5118 b := dAtA[iNdEx] 5119 iNdEx++ 5120 msglen |= (int(b) & 0x7F) << shift 5121 if b < 0x80 { 5122 break 5123 } 5124 } 5125 if msglen < 0 { 5126 return ErrInvalidLengthGenerated 5127 } 5128 postIndex := iNdEx + msglen 5129 if postIndex > l { 5130 return io.ErrUnexpectedEOF 5131 } 5132 m.Items = append(m.Items, DaemonSet{}) 5133 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5134 return err 5135 } 5136 iNdEx = postIndex 5137 default: 5138 iNdEx = preIndex 5139 skippy, err := skipGenerated(dAtA[iNdEx:]) 5140 if err != nil { 5141 return err 5142 } 5143 if skippy < 0 { 5144 return ErrInvalidLengthGenerated 5145 } 5146 if (iNdEx + skippy) > l { 5147 return io.ErrUnexpectedEOF 5148 } 5149 iNdEx += skippy 5150 } 5151 } 5152 5153 if iNdEx > l { 5154 return io.ErrUnexpectedEOF 5155 } 5156 return nil 5157} 5158func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error { 5159 l := len(dAtA) 5160 iNdEx := 0 5161 for iNdEx < l { 5162 preIndex := iNdEx 5163 var wire uint64 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 wire |= (uint64(b) & 0x7F) << shift 5174 if b < 0x80 { 5175 break 5176 } 5177 } 5178 fieldNum := int32(wire >> 3) 5179 wireType := int(wire & 0x7) 5180 if wireType == 4 { 5181 return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group") 5182 } 5183 if fieldNum <= 0 { 5184 return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) 5185 } 5186 switch fieldNum { 5187 case 1: 5188 if wireType != 2 { 5189 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 5190 } 5191 var msglen int 5192 for shift := uint(0); ; shift += 7 { 5193 if shift >= 64 { 5194 return ErrIntOverflowGenerated 5195 } 5196 if iNdEx >= l { 5197 return io.ErrUnexpectedEOF 5198 } 5199 b := dAtA[iNdEx] 5200 iNdEx++ 5201 msglen |= (int(b) & 0x7F) << shift 5202 if b < 0x80 { 5203 break 5204 } 5205 } 5206 if msglen < 0 { 5207 return ErrInvalidLengthGenerated 5208 } 5209 postIndex := iNdEx + msglen 5210 if postIndex > l { 5211 return io.ErrUnexpectedEOF 5212 } 5213 if m.Selector == nil { 5214 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 5215 } 5216 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5217 return err 5218 } 5219 iNdEx = postIndex 5220 case 2: 5221 if wireType != 2 { 5222 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) 5223 } 5224 var msglen int 5225 for shift := uint(0); ; shift += 7 { 5226 if shift >= 64 { 5227 return ErrIntOverflowGenerated 5228 } 5229 if iNdEx >= l { 5230 return io.ErrUnexpectedEOF 5231 } 5232 b := dAtA[iNdEx] 5233 iNdEx++ 5234 msglen |= (int(b) & 0x7F) << shift 5235 if b < 0x80 { 5236 break 5237 } 5238 } 5239 if msglen < 0 { 5240 return ErrInvalidLengthGenerated 5241 } 5242 postIndex := iNdEx + msglen 5243 if postIndex > l { 5244 return io.ErrUnexpectedEOF 5245 } 5246 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5247 return err 5248 } 5249 iNdEx = postIndex 5250 case 3: 5251 if wireType != 2 { 5252 return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType) 5253 } 5254 var msglen int 5255 for shift := uint(0); ; shift += 7 { 5256 if shift >= 64 { 5257 return ErrIntOverflowGenerated 5258 } 5259 if iNdEx >= l { 5260 return io.ErrUnexpectedEOF 5261 } 5262 b := dAtA[iNdEx] 5263 iNdEx++ 5264 msglen |= (int(b) & 0x7F) << shift 5265 if b < 0x80 { 5266 break 5267 } 5268 } 5269 if msglen < 0 { 5270 return ErrInvalidLengthGenerated 5271 } 5272 postIndex := iNdEx + msglen 5273 if postIndex > l { 5274 return io.ErrUnexpectedEOF 5275 } 5276 if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5277 return err 5278 } 5279 iNdEx = postIndex 5280 case 4: 5281 if wireType != 0 { 5282 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) 5283 } 5284 m.MinReadySeconds = 0 5285 for shift := uint(0); ; shift += 7 { 5286 if shift >= 64 { 5287 return ErrIntOverflowGenerated 5288 } 5289 if iNdEx >= l { 5290 return io.ErrUnexpectedEOF 5291 } 5292 b := dAtA[iNdEx] 5293 iNdEx++ 5294 m.MinReadySeconds |= (int32(b) & 0x7F) << shift 5295 if b < 0x80 { 5296 break 5297 } 5298 } 5299 case 5: 5300 if wireType != 0 { 5301 return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType) 5302 } 5303 m.TemplateGeneration = 0 5304 for shift := uint(0); ; shift += 7 { 5305 if shift >= 64 { 5306 return ErrIntOverflowGenerated 5307 } 5308 if iNdEx >= l { 5309 return io.ErrUnexpectedEOF 5310 } 5311 b := dAtA[iNdEx] 5312 iNdEx++ 5313 m.TemplateGeneration |= (int64(b) & 0x7F) << shift 5314 if b < 0x80 { 5315 break 5316 } 5317 } 5318 case 6: 5319 if wireType != 0 { 5320 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType) 5321 } 5322 var v int32 5323 for shift := uint(0); ; shift += 7 { 5324 if shift >= 64 { 5325 return ErrIntOverflowGenerated 5326 } 5327 if iNdEx >= l { 5328 return io.ErrUnexpectedEOF 5329 } 5330 b := dAtA[iNdEx] 5331 iNdEx++ 5332 v |= (int32(b) & 0x7F) << shift 5333 if b < 0x80 { 5334 break 5335 } 5336 } 5337 m.RevisionHistoryLimit = &v 5338 default: 5339 iNdEx = preIndex 5340 skippy, err := skipGenerated(dAtA[iNdEx:]) 5341 if err != nil { 5342 return err 5343 } 5344 if skippy < 0 { 5345 return ErrInvalidLengthGenerated 5346 } 5347 if (iNdEx + skippy) > l { 5348 return io.ErrUnexpectedEOF 5349 } 5350 iNdEx += skippy 5351 } 5352 } 5353 5354 if iNdEx > l { 5355 return io.ErrUnexpectedEOF 5356 } 5357 return nil 5358} 5359func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error { 5360 l := len(dAtA) 5361 iNdEx := 0 5362 for iNdEx < l { 5363 preIndex := iNdEx 5364 var wire uint64 5365 for shift := uint(0); ; shift += 7 { 5366 if shift >= 64 { 5367 return ErrIntOverflowGenerated 5368 } 5369 if iNdEx >= l { 5370 return io.ErrUnexpectedEOF 5371 } 5372 b := dAtA[iNdEx] 5373 iNdEx++ 5374 wire |= (uint64(b) & 0x7F) << shift 5375 if b < 0x80 { 5376 break 5377 } 5378 } 5379 fieldNum := int32(wire >> 3) 5380 wireType := int(wire & 0x7) 5381 if wireType == 4 { 5382 return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group") 5383 } 5384 if fieldNum <= 0 { 5385 return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) 5386 } 5387 switch fieldNum { 5388 case 1: 5389 if wireType != 0 { 5390 return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType) 5391 } 5392 m.CurrentNumberScheduled = 0 5393 for shift := uint(0); ; shift += 7 { 5394 if shift >= 64 { 5395 return ErrIntOverflowGenerated 5396 } 5397 if iNdEx >= l { 5398 return io.ErrUnexpectedEOF 5399 } 5400 b := dAtA[iNdEx] 5401 iNdEx++ 5402 m.CurrentNumberScheduled |= (int32(b) & 0x7F) << shift 5403 if b < 0x80 { 5404 break 5405 } 5406 } 5407 case 2: 5408 if wireType != 0 { 5409 return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType) 5410 } 5411 m.NumberMisscheduled = 0 5412 for shift := uint(0); ; shift += 7 { 5413 if shift >= 64 { 5414 return ErrIntOverflowGenerated 5415 } 5416 if iNdEx >= l { 5417 return io.ErrUnexpectedEOF 5418 } 5419 b := dAtA[iNdEx] 5420 iNdEx++ 5421 m.NumberMisscheduled |= (int32(b) & 0x7F) << shift 5422 if b < 0x80 { 5423 break 5424 } 5425 } 5426 case 3: 5427 if wireType != 0 { 5428 return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType) 5429 } 5430 m.DesiredNumberScheduled = 0 5431 for shift := uint(0); ; shift += 7 { 5432 if shift >= 64 { 5433 return ErrIntOverflowGenerated 5434 } 5435 if iNdEx >= l { 5436 return io.ErrUnexpectedEOF 5437 } 5438 b := dAtA[iNdEx] 5439 iNdEx++ 5440 m.DesiredNumberScheduled |= (int32(b) & 0x7F) << shift 5441 if b < 0x80 { 5442 break 5443 } 5444 } 5445 case 4: 5446 if wireType != 0 { 5447 return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType) 5448 } 5449 m.NumberReady = 0 5450 for shift := uint(0); ; shift += 7 { 5451 if shift >= 64 { 5452 return ErrIntOverflowGenerated 5453 } 5454 if iNdEx >= l { 5455 return io.ErrUnexpectedEOF 5456 } 5457 b := dAtA[iNdEx] 5458 iNdEx++ 5459 m.NumberReady |= (int32(b) & 0x7F) << shift 5460 if b < 0x80 { 5461 break 5462 } 5463 } 5464 case 5: 5465 if wireType != 0 { 5466 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) 5467 } 5468 m.ObservedGeneration = 0 5469 for shift := uint(0); ; shift += 7 { 5470 if shift >= 64 { 5471 return ErrIntOverflowGenerated 5472 } 5473 if iNdEx >= l { 5474 return io.ErrUnexpectedEOF 5475 } 5476 b := dAtA[iNdEx] 5477 iNdEx++ 5478 m.ObservedGeneration |= (int64(b) & 0x7F) << shift 5479 if b < 0x80 { 5480 break 5481 } 5482 } 5483 case 6: 5484 if wireType != 0 { 5485 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType) 5486 } 5487 m.UpdatedNumberScheduled = 0 5488 for shift := uint(0); ; shift += 7 { 5489 if shift >= 64 { 5490 return ErrIntOverflowGenerated 5491 } 5492 if iNdEx >= l { 5493 return io.ErrUnexpectedEOF 5494 } 5495 b := dAtA[iNdEx] 5496 iNdEx++ 5497 m.UpdatedNumberScheduled |= (int32(b) & 0x7F) << shift 5498 if b < 0x80 { 5499 break 5500 } 5501 } 5502 case 7: 5503 if wireType != 0 { 5504 return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType) 5505 } 5506 m.NumberAvailable = 0 5507 for shift := uint(0); ; shift += 7 { 5508 if shift >= 64 { 5509 return ErrIntOverflowGenerated 5510 } 5511 if iNdEx >= l { 5512 return io.ErrUnexpectedEOF 5513 } 5514 b := dAtA[iNdEx] 5515 iNdEx++ 5516 m.NumberAvailable |= (int32(b) & 0x7F) << shift 5517 if b < 0x80 { 5518 break 5519 } 5520 } 5521 case 8: 5522 if wireType != 0 { 5523 return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType) 5524 } 5525 m.NumberUnavailable = 0 5526 for shift := uint(0); ; shift += 7 { 5527 if shift >= 64 { 5528 return ErrIntOverflowGenerated 5529 } 5530 if iNdEx >= l { 5531 return io.ErrUnexpectedEOF 5532 } 5533 b := dAtA[iNdEx] 5534 iNdEx++ 5535 m.NumberUnavailable |= (int32(b) & 0x7F) << shift 5536 if b < 0x80 { 5537 break 5538 } 5539 } 5540 case 9: 5541 if wireType != 0 { 5542 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType) 5543 } 5544 var v int32 5545 for shift := uint(0); ; shift += 7 { 5546 if shift >= 64 { 5547 return ErrIntOverflowGenerated 5548 } 5549 if iNdEx >= l { 5550 return io.ErrUnexpectedEOF 5551 } 5552 b := dAtA[iNdEx] 5553 iNdEx++ 5554 v |= (int32(b) & 0x7F) << shift 5555 if b < 0x80 { 5556 break 5557 } 5558 } 5559 m.CollisionCount = &v 5560 case 10: 5561 if wireType != 2 { 5562 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 5563 } 5564 var msglen int 5565 for shift := uint(0); ; shift += 7 { 5566 if shift >= 64 { 5567 return ErrIntOverflowGenerated 5568 } 5569 if iNdEx >= l { 5570 return io.ErrUnexpectedEOF 5571 } 5572 b := dAtA[iNdEx] 5573 iNdEx++ 5574 msglen |= (int(b) & 0x7F) << shift 5575 if b < 0x80 { 5576 break 5577 } 5578 } 5579 if msglen < 0 { 5580 return ErrInvalidLengthGenerated 5581 } 5582 postIndex := iNdEx + msglen 5583 if postIndex > l { 5584 return io.ErrUnexpectedEOF 5585 } 5586 m.Conditions = append(m.Conditions, DaemonSetCondition{}) 5587 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5588 return err 5589 } 5590 iNdEx = postIndex 5591 default: 5592 iNdEx = preIndex 5593 skippy, err := skipGenerated(dAtA[iNdEx:]) 5594 if err != nil { 5595 return err 5596 } 5597 if skippy < 0 { 5598 return ErrInvalidLengthGenerated 5599 } 5600 if (iNdEx + skippy) > l { 5601 return io.ErrUnexpectedEOF 5602 } 5603 iNdEx += skippy 5604 } 5605 } 5606 5607 if iNdEx > l { 5608 return io.ErrUnexpectedEOF 5609 } 5610 return nil 5611} 5612func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error { 5613 l := len(dAtA) 5614 iNdEx := 0 5615 for iNdEx < l { 5616 preIndex := iNdEx 5617 var wire uint64 5618 for shift := uint(0); ; shift += 7 { 5619 if shift >= 64 { 5620 return ErrIntOverflowGenerated 5621 } 5622 if iNdEx >= l { 5623 return io.ErrUnexpectedEOF 5624 } 5625 b := dAtA[iNdEx] 5626 iNdEx++ 5627 wire |= (uint64(b) & 0x7F) << shift 5628 if b < 0x80 { 5629 break 5630 } 5631 } 5632 fieldNum := int32(wire >> 3) 5633 wireType := int(wire & 0x7) 5634 if wireType == 4 { 5635 return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group") 5636 } 5637 if fieldNum <= 0 { 5638 return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire) 5639 } 5640 switch fieldNum { 5641 case 1: 5642 if wireType != 2 { 5643 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 5644 } 5645 var stringLen uint64 5646 for shift := uint(0); ; shift += 7 { 5647 if shift >= 64 { 5648 return ErrIntOverflowGenerated 5649 } 5650 if iNdEx >= l { 5651 return io.ErrUnexpectedEOF 5652 } 5653 b := dAtA[iNdEx] 5654 iNdEx++ 5655 stringLen |= (uint64(b) & 0x7F) << shift 5656 if b < 0x80 { 5657 break 5658 } 5659 } 5660 intStringLen := int(stringLen) 5661 if intStringLen < 0 { 5662 return ErrInvalidLengthGenerated 5663 } 5664 postIndex := iNdEx + intStringLen 5665 if postIndex > l { 5666 return io.ErrUnexpectedEOF 5667 } 5668 m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex]) 5669 iNdEx = postIndex 5670 case 2: 5671 if wireType != 2 { 5672 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType) 5673 } 5674 var msglen int 5675 for shift := uint(0); ; shift += 7 { 5676 if shift >= 64 { 5677 return ErrIntOverflowGenerated 5678 } 5679 if iNdEx >= l { 5680 return io.ErrUnexpectedEOF 5681 } 5682 b := dAtA[iNdEx] 5683 iNdEx++ 5684 msglen |= (int(b) & 0x7F) << shift 5685 if b < 0x80 { 5686 break 5687 } 5688 } 5689 if msglen < 0 { 5690 return ErrInvalidLengthGenerated 5691 } 5692 postIndex := iNdEx + msglen 5693 if postIndex > l { 5694 return io.ErrUnexpectedEOF 5695 } 5696 if m.RollingUpdate == nil { 5697 m.RollingUpdate = &RollingUpdateDaemonSet{} 5698 } 5699 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5700 return err 5701 } 5702 iNdEx = postIndex 5703 default: 5704 iNdEx = preIndex 5705 skippy, err := skipGenerated(dAtA[iNdEx:]) 5706 if err != nil { 5707 return err 5708 } 5709 if skippy < 0 { 5710 return ErrInvalidLengthGenerated 5711 } 5712 if (iNdEx + skippy) > l { 5713 return io.ErrUnexpectedEOF 5714 } 5715 iNdEx += skippy 5716 } 5717 } 5718 5719 if iNdEx > l { 5720 return io.ErrUnexpectedEOF 5721 } 5722 return nil 5723} 5724func (m *Deployment) Unmarshal(dAtA []byte) error { 5725 l := len(dAtA) 5726 iNdEx := 0 5727 for iNdEx < l { 5728 preIndex := iNdEx 5729 var wire uint64 5730 for shift := uint(0); ; shift += 7 { 5731 if shift >= 64 { 5732 return ErrIntOverflowGenerated 5733 } 5734 if iNdEx >= l { 5735 return io.ErrUnexpectedEOF 5736 } 5737 b := dAtA[iNdEx] 5738 iNdEx++ 5739 wire |= (uint64(b) & 0x7F) << shift 5740 if b < 0x80 { 5741 break 5742 } 5743 } 5744 fieldNum := int32(wire >> 3) 5745 wireType := int(wire & 0x7) 5746 if wireType == 4 { 5747 return fmt.Errorf("proto: Deployment: wiretype end group for non-group") 5748 } 5749 if fieldNum <= 0 { 5750 return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire) 5751 } 5752 switch fieldNum { 5753 case 1: 5754 if wireType != 2 { 5755 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 5756 } 5757 var msglen int 5758 for shift := uint(0); ; shift += 7 { 5759 if shift >= 64 { 5760 return ErrIntOverflowGenerated 5761 } 5762 if iNdEx >= l { 5763 return io.ErrUnexpectedEOF 5764 } 5765 b := dAtA[iNdEx] 5766 iNdEx++ 5767 msglen |= (int(b) & 0x7F) << shift 5768 if b < 0x80 { 5769 break 5770 } 5771 } 5772 if msglen < 0 { 5773 return ErrInvalidLengthGenerated 5774 } 5775 postIndex := iNdEx + msglen 5776 if postIndex > l { 5777 return io.ErrUnexpectedEOF 5778 } 5779 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5780 return err 5781 } 5782 iNdEx = postIndex 5783 case 2: 5784 if wireType != 2 { 5785 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 5786 } 5787 var msglen int 5788 for shift := uint(0); ; shift += 7 { 5789 if shift >= 64 { 5790 return ErrIntOverflowGenerated 5791 } 5792 if iNdEx >= l { 5793 return io.ErrUnexpectedEOF 5794 } 5795 b := dAtA[iNdEx] 5796 iNdEx++ 5797 msglen |= (int(b) & 0x7F) << shift 5798 if b < 0x80 { 5799 break 5800 } 5801 } 5802 if msglen < 0 { 5803 return ErrInvalidLengthGenerated 5804 } 5805 postIndex := iNdEx + msglen 5806 if postIndex > l { 5807 return io.ErrUnexpectedEOF 5808 } 5809 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5810 return err 5811 } 5812 iNdEx = postIndex 5813 case 3: 5814 if wireType != 2 { 5815 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 5816 } 5817 var msglen int 5818 for shift := uint(0); ; shift += 7 { 5819 if shift >= 64 { 5820 return ErrIntOverflowGenerated 5821 } 5822 if iNdEx >= l { 5823 return io.ErrUnexpectedEOF 5824 } 5825 b := dAtA[iNdEx] 5826 iNdEx++ 5827 msglen |= (int(b) & 0x7F) << shift 5828 if b < 0x80 { 5829 break 5830 } 5831 } 5832 if msglen < 0 { 5833 return ErrInvalidLengthGenerated 5834 } 5835 postIndex := iNdEx + msglen 5836 if postIndex > l { 5837 return io.ErrUnexpectedEOF 5838 } 5839 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 5840 return err 5841 } 5842 iNdEx = postIndex 5843 default: 5844 iNdEx = preIndex 5845 skippy, err := skipGenerated(dAtA[iNdEx:]) 5846 if err != nil { 5847 return err 5848 } 5849 if skippy < 0 { 5850 return ErrInvalidLengthGenerated 5851 } 5852 if (iNdEx + skippy) > l { 5853 return io.ErrUnexpectedEOF 5854 } 5855 iNdEx += skippy 5856 } 5857 } 5858 5859 if iNdEx > l { 5860 return io.ErrUnexpectedEOF 5861 } 5862 return nil 5863} 5864func (m *DeploymentCondition) Unmarshal(dAtA []byte) error { 5865 l := len(dAtA) 5866 iNdEx := 0 5867 for iNdEx < l { 5868 preIndex := iNdEx 5869 var wire uint64 5870 for shift := uint(0); ; shift += 7 { 5871 if shift >= 64 { 5872 return ErrIntOverflowGenerated 5873 } 5874 if iNdEx >= l { 5875 return io.ErrUnexpectedEOF 5876 } 5877 b := dAtA[iNdEx] 5878 iNdEx++ 5879 wire |= (uint64(b) & 0x7F) << shift 5880 if b < 0x80 { 5881 break 5882 } 5883 } 5884 fieldNum := int32(wire >> 3) 5885 wireType := int(wire & 0x7) 5886 if wireType == 4 { 5887 return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group") 5888 } 5889 if fieldNum <= 0 { 5890 return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire) 5891 } 5892 switch fieldNum { 5893 case 1: 5894 if wireType != 2 { 5895 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 5896 } 5897 var stringLen uint64 5898 for shift := uint(0); ; shift += 7 { 5899 if shift >= 64 { 5900 return ErrIntOverflowGenerated 5901 } 5902 if iNdEx >= l { 5903 return io.ErrUnexpectedEOF 5904 } 5905 b := dAtA[iNdEx] 5906 iNdEx++ 5907 stringLen |= (uint64(b) & 0x7F) << shift 5908 if b < 0x80 { 5909 break 5910 } 5911 } 5912 intStringLen := int(stringLen) 5913 if intStringLen < 0 { 5914 return ErrInvalidLengthGenerated 5915 } 5916 postIndex := iNdEx + intStringLen 5917 if postIndex > l { 5918 return io.ErrUnexpectedEOF 5919 } 5920 m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex]) 5921 iNdEx = postIndex 5922 case 2: 5923 if wireType != 2 { 5924 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 5925 } 5926 var stringLen uint64 5927 for shift := uint(0); ; shift += 7 { 5928 if shift >= 64 { 5929 return ErrIntOverflowGenerated 5930 } 5931 if iNdEx >= l { 5932 return io.ErrUnexpectedEOF 5933 } 5934 b := dAtA[iNdEx] 5935 iNdEx++ 5936 stringLen |= (uint64(b) & 0x7F) << shift 5937 if b < 0x80 { 5938 break 5939 } 5940 } 5941 intStringLen := int(stringLen) 5942 if intStringLen < 0 { 5943 return ErrInvalidLengthGenerated 5944 } 5945 postIndex := iNdEx + intStringLen 5946 if postIndex > l { 5947 return io.ErrUnexpectedEOF 5948 } 5949 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) 5950 iNdEx = postIndex 5951 case 4: 5952 if wireType != 2 { 5953 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) 5954 } 5955 var stringLen uint64 5956 for shift := uint(0); ; shift += 7 { 5957 if shift >= 64 { 5958 return ErrIntOverflowGenerated 5959 } 5960 if iNdEx >= l { 5961 return io.ErrUnexpectedEOF 5962 } 5963 b := dAtA[iNdEx] 5964 iNdEx++ 5965 stringLen |= (uint64(b) & 0x7F) << shift 5966 if b < 0x80 { 5967 break 5968 } 5969 } 5970 intStringLen := int(stringLen) 5971 if intStringLen < 0 { 5972 return ErrInvalidLengthGenerated 5973 } 5974 postIndex := iNdEx + intStringLen 5975 if postIndex > l { 5976 return io.ErrUnexpectedEOF 5977 } 5978 m.Reason = string(dAtA[iNdEx:postIndex]) 5979 iNdEx = postIndex 5980 case 5: 5981 if wireType != 2 { 5982 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 5983 } 5984 var stringLen uint64 5985 for shift := uint(0); ; shift += 7 { 5986 if shift >= 64 { 5987 return ErrIntOverflowGenerated 5988 } 5989 if iNdEx >= l { 5990 return io.ErrUnexpectedEOF 5991 } 5992 b := dAtA[iNdEx] 5993 iNdEx++ 5994 stringLen |= (uint64(b) & 0x7F) << shift 5995 if b < 0x80 { 5996 break 5997 } 5998 } 5999 intStringLen := int(stringLen) 6000 if intStringLen < 0 { 6001 return ErrInvalidLengthGenerated 6002 } 6003 postIndex := iNdEx + intStringLen 6004 if postIndex > l { 6005 return io.ErrUnexpectedEOF 6006 } 6007 m.Message = string(dAtA[iNdEx:postIndex]) 6008 iNdEx = postIndex 6009 case 6: 6010 if wireType != 2 { 6011 return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType) 6012 } 6013 var msglen int 6014 for shift := uint(0); ; shift += 7 { 6015 if shift >= 64 { 6016 return ErrIntOverflowGenerated 6017 } 6018 if iNdEx >= l { 6019 return io.ErrUnexpectedEOF 6020 } 6021 b := dAtA[iNdEx] 6022 iNdEx++ 6023 msglen |= (int(b) & 0x7F) << shift 6024 if b < 0x80 { 6025 break 6026 } 6027 } 6028 if msglen < 0 { 6029 return ErrInvalidLengthGenerated 6030 } 6031 postIndex := iNdEx + msglen 6032 if postIndex > l { 6033 return io.ErrUnexpectedEOF 6034 } 6035 if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6036 return err 6037 } 6038 iNdEx = postIndex 6039 case 7: 6040 if wireType != 2 { 6041 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) 6042 } 6043 var msglen int 6044 for shift := uint(0); ; shift += 7 { 6045 if shift >= 64 { 6046 return ErrIntOverflowGenerated 6047 } 6048 if iNdEx >= l { 6049 return io.ErrUnexpectedEOF 6050 } 6051 b := dAtA[iNdEx] 6052 iNdEx++ 6053 msglen |= (int(b) & 0x7F) << shift 6054 if b < 0x80 { 6055 break 6056 } 6057 } 6058 if msglen < 0 { 6059 return ErrInvalidLengthGenerated 6060 } 6061 postIndex := iNdEx + msglen 6062 if postIndex > l { 6063 return io.ErrUnexpectedEOF 6064 } 6065 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6066 return err 6067 } 6068 iNdEx = postIndex 6069 default: 6070 iNdEx = preIndex 6071 skippy, err := skipGenerated(dAtA[iNdEx:]) 6072 if err != nil { 6073 return err 6074 } 6075 if skippy < 0 { 6076 return ErrInvalidLengthGenerated 6077 } 6078 if (iNdEx + skippy) > l { 6079 return io.ErrUnexpectedEOF 6080 } 6081 iNdEx += skippy 6082 } 6083 } 6084 6085 if iNdEx > l { 6086 return io.ErrUnexpectedEOF 6087 } 6088 return nil 6089} 6090func (m *DeploymentList) Unmarshal(dAtA []byte) error { 6091 l := len(dAtA) 6092 iNdEx := 0 6093 for iNdEx < l { 6094 preIndex := iNdEx 6095 var wire uint64 6096 for shift := uint(0); ; shift += 7 { 6097 if shift >= 64 { 6098 return ErrIntOverflowGenerated 6099 } 6100 if iNdEx >= l { 6101 return io.ErrUnexpectedEOF 6102 } 6103 b := dAtA[iNdEx] 6104 iNdEx++ 6105 wire |= (uint64(b) & 0x7F) << shift 6106 if b < 0x80 { 6107 break 6108 } 6109 } 6110 fieldNum := int32(wire >> 3) 6111 wireType := int(wire & 0x7) 6112 if wireType == 4 { 6113 return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group") 6114 } 6115 if fieldNum <= 0 { 6116 return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire) 6117 } 6118 switch fieldNum { 6119 case 1: 6120 if wireType != 2 { 6121 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 6122 } 6123 var msglen int 6124 for shift := uint(0); ; shift += 7 { 6125 if shift >= 64 { 6126 return ErrIntOverflowGenerated 6127 } 6128 if iNdEx >= l { 6129 return io.ErrUnexpectedEOF 6130 } 6131 b := dAtA[iNdEx] 6132 iNdEx++ 6133 msglen |= (int(b) & 0x7F) << shift 6134 if b < 0x80 { 6135 break 6136 } 6137 } 6138 if msglen < 0 { 6139 return ErrInvalidLengthGenerated 6140 } 6141 postIndex := iNdEx + msglen 6142 if postIndex > l { 6143 return io.ErrUnexpectedEOF 6144 } 6145 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6146 return err 6147 } 6148 iNdEx = postIndex 6149 case 2: 6150 if wireType != 2 { 6151 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 6152 } 6153 var msglen int 6154 for shift := uint(0); ; shift += 7 { 6155 if shift >= 64 { 6156 return ErrIntOverflowGenerated 6157 } 6158 if iNdEx >= l { 6159 return io.ErrUnexpectedEOF 6160 } 6161 b := dAtA[iNdEx] 6162 iNdEx++ 6163 msglen |= (int(b) & 0x7F) << shift 6164 if b < 0x80 { 6165 break 6166 } 6167 } 6168 if msglen < 0 { 6169 return ErrInvalidLengthGenerated 6170 } 6171 postIndex := iNdEx + msglen 6172 if postIndex > l { 6173 return io.ErrUnexpectedEOF 6174 } 6175 m.Items = append(m.Items, Deployment{}) 6176 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6177 return err 6178 } 6179 iNdEx = postIndex 6180 default: 6181 iNdEx = preIndex 6182 skippy, err := skipGenerated(dAtA[iNdEx:]) 6183 if err != nil { 6184 return err 6185 } 6186 if skippy < 0 { 6187 return ErrInvalidLengthGenerated 6188 } 6189 if (iNdEx + skippy) > l { 6190 return io.ErrUnexpectedEOF 6191 } 6192 iNdEx += skippy 6193 } 6194 } 6195 6196 if iNdEx > l { 6197 return io.ErrUnexpectedEOF 6198 } 6199 return nil 6200} 6201func (m *DeploymentRollback) Unmarshal(dAtA []byte) error { 6202 l := len(dAtA) 6203 iNdEx := 0 6204 for iNdEx < l { 6205 preIndex := iNdEx 6206 var wire uint64 6207 for shift := uint(0); ; shift += 7 { 6208 if shift >= 64 { 6209 return ErrIntOverflowGenerated 6210 } 6211 if iNdEx >= l { 6212 return io.ErrUnexpectedEOF 6213 } 6214 b := dAtA[iNdEx] 6215 iNdEx++ 6216 wire |= (uint64(b) & 0x7F) << shift 6217 if b < 0x80 { 6218 break 6219 } 6220 } 6221 fieldNum := int32(wire >> 3) 6222 wireType := int(wire & 0x7) 6223 if wireType == 4 { 6224 return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group") 6225 } 6226 if fieldNum <= 0 { 6227 return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire) 6228 } 6229 switch fieldNum { 6230 case 1: 6231 if wireType != 2 { 6232 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 6233 } 6234 var stringLen uint64 6235 for shift := uint(0); ; shift += 7 { 6236 if shift >= 64 { 6237 return ErrIntOverflowGenerated 6238 } 6239 if iNdEx >= l { 6240 return io.ErrUnexpectedEOF 6241 } 6242 b := dAtA[iNdEx] 6243 iNdEx++ 6244 stringLen |= (uint64(b) & 0x7F) << shift 6245 if b < 0x80 { 6246 break 6247 } 6248 } 6249 intStringLen := int(stringLen) 6250 if intStringLen < 0 { 6251 return ErrInvalidLengthGenerated 6252 } 6253 postIndex := iNdEx + intStringLen 6254 if postIndex > l { 6255 return io.ErrUnexpectedEOF 6256 } 6257 m.Name = string(dAtA[iNdEx:postIndex]) 6258 iNdEx = postIndex 6259 case 2: 6260 if wireType != 2 { 6261 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType) 6262 } 6263 var msglen int 6264 for shift := uint(0); ; shift += 7 { 6265 if shift >= 64 { 6266 return ErrIntOverflowGenerated 6267 } 6268 if iNdEx >= l { 6269 return io.ErrUnexpectedEOF 6270 } 6271 b := dAtA[iNdEx] 6272 iNdEx++ 6273 msglen |= (int(b) & 0x7F) << shift 6274 if b < 0x80 { 6275 break 6276 } 6277 } 6278 if msglen < 0 { 6279 return ErrInvalidLengthGenerated 6280 } 6281 postIndex := iNdEx + msglen 6282 if postIndex > l { 6283 return io.ErrUnexpectedEOF 6284 } 6285 if m.UpdatedAnnotations == nil { 6286 m.UpdatedAnnotations = make(map[string]string) 6287 } 6288 var mapkey string 6289 var mapvalue string 6290 for iNdEx < postIndex { 6291 entryPreIndex := iNdEx 6292 var wire uint64 6293 for shift := uint(0); ; shift += 7 { 6294 if shift >= 64 { 6295 return ErrIntOverflowGenerated 6296 } 6297 if iNdEx >= l { 6298 return io.ErrUnexpectedEOF 6299 } 6300 b := dAtA[iNdEx] 6301 iNdEx++ 6302 wire |= (uint64(b) & 0x7F) << shift 6303 if b < 0x80 { 6304 break 6305 } 6306 } 6307 fieldNum := int32(wire >> 3) 6308 if fieldNum == 1 { 6309 var stringLenmapkey uint64 6310 for shift := uint(0); ; shift += 7 { 6311 if shift >= 64 { 6312 return ErrIntOverflowGenerated 6313 } 6314 if iNdEx >= l { 6315 return io.ErrUnexpectedEOF 6316 } 6317 b := dAtA[iNdEx] 6318 iNdEx++ 6319 stringLenmapkey |= (uint64(b) & 0x7F) << shift 6320 if b < 0x80 { 6321 break 6322 } 6323 } 6324 intStringLenmapkey := int(stringLenmapkey) 6325 if intStringLenmapkey < 0 { 6326 return ErrInvalidLengthGenerated 6327 } 6328 postStringIndexmapkey := iNdEx + intStringLenmapkey 6329 if postStringIndexmapkey > l { 6330 return io.ErrUnexpectedEOF 6331 } 6332 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 6333 iNdEx = postStringIndexmapkey 6334 } else if fieldNum == 2 { 6335 var stringLenmapvalue uint64 6336 for shift := uint(0); ; shift += 7 { 6337 if shift >= 64 { 6338 return ErrIntOverflowGenerated 6339 } 6340 if iNdEx >= l { 6341 return io.ErrUnexpectedEOF 6342 } 6343 b := dAtA[iNdEx] 6344 iNdEx++ 6345 stringLenmapvalue |= (uint64(b) & 0x7F) << shift 6346 if b < 0x80 { 6347 break 6348 } 6349 } 6350 intStringLenmapvalue := int(stringLenmapvalue) 6351 if intStringLenmapvalue < 0 { 6352 return ErrInvalidLengthGenerated 6353 } 6354 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 6355 if postStringIndexmapvalue > l { 6356 return io.ErrUnexpectedEOF 6357 } 6358 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 6359 iNdEx = postStringIndexmapvalue 6360 } else { 6361 iNdEx = entryPreIndex 6362 skippy, err := skipGenerated(dAtA[iNdEx:]) 6363 if err != nil { 6364 return err 6365 } 6366 if skippy < 0 { 6367 return ErrInvalidLengthGenerated 6368 } 6369 if (iNdEx + skippy) > postIndex { 6370 return io.ErrUnexpectedEOF 6371 } 6372 iNdEx += skippy 6373 } 6374 } 6375 m.UpdatedAnnotations[mapkey] = mapvalue 6376 iNdEx = postIndex 6377 case 3: 6378 if wireType != 2 { 6379 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType) 6380 } 6381 var msglen int 6382 for shift := uint(0); ; shift += 7 { 6383 if shift >= 64 { 6384 return ErrIntOverflowGenerated 6385 } 6386 if iNdEx >= l { 6387 return io.ErrUnexpectedEOF 6388 } 6389 b := dAtA[iNdEx] 6390 iNdEx++ 6391 msglen |= (int(b) & 0x7F) << shift 6392 if b < 0x80 { 6393 break 6394 } 6395 } 6396 if msglen < 0 { 6397 return ErrInvalidLengthGenerated 6398 } 6399 postIndex := iNdEx + msglen 6400 if postIndex > l { 6401 return io.ErrUnexpectedEOF 6402 } 6403 if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6404 return err 6405 } 6406 iNdEx = postIndex 6407 default: 6408 iNdEx = preIndex 6409 skippy, err := skipGenerated(dAtA[iNdEx:]) 6410 if err != nil { 6411 return err 6412 } 6413 if skippy < 0 { 6414 return ErrInvalidLengthGenerated 6415 } 6416 if (iNdEx + skippy) > l { 6417 return io.ErrUnexpectedEOF 6418 } 6419 iNdEx += skippy 6420 } 6421 } 6422 6423 if iNdEx > l { 6424 return io.ErrUnexpectedEOF 6425 } 6426 return nil 6427} 6428func (m *DeploymentSpec) Unmarshal(dAtA []byte) error { 6429 l := len(dAtA) 6430 iNdEx := 0 6431 for iNdEx < l { 6432 preIndex := iNdEx 6433 var wire uint64 6434 for shift := uint(0); ; shift += 7 { 6435 if shift >= 64 { 6436 return ErrIntOverflowGenerated 6437 } 6438 if iNdEx >= l { 6439 return io.ErrUnexpectedEOF 6440 } 6441 b := dAtA[iNdEx] 6442 iNdEx++ 6443 wire |= (uint64(b) & 0x7F) << shift 6444 if b < 0x80 { 6445 break 6446 } 6447 } 6448 fieldNum := int32(wire >> 3) 6449 wireType := int(wire & 0x7) 6450 if wireType == 4 { 6451 return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group") 6452 } 6453 if fieldNum <= 0 { 6454 return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire) 6455 } 6456 switch fieldNum { 6457 case 1: 6458 if wireType != 0 { 6459 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 6460 } 6461 var v int32 6462 for shift := uint(0); ; shift += 7 { 6463 if shift >= 64 { 6464 return ErrIntOverflowGenerated 6465 } 6466 if iNdEx >= l { 6467 return io.ErrUnexpectedEOF 6468 } 6469 b := dAtA[iNdEx] 6470 iNdEx++ 6471 v |= (int32(b) & 0x7F) << shift 6472 if b < 0x80 { 6473 break 6474 } 6475 } 6476 m.Replicas = &v 6477 case 2: 6478 if wireType != 2 { 6479 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 6480 } 6481 var msglen int 6482 for shift := uint(0); ; shift += 7 { 6483 if shift >= 64 { 6484 return ErrIntOverflowGenerated 6485 } 6486 if iNdEx >= l { 6487 return io.ErrUnexpectedEOF 6488 } 6489 b := dAtA[iNdEx] 6490 iNdEx++ 6491 msglen |= (int(b) & 0x7F) << shift 6492 if b < 0x80 { 6493 break 6494 } 6495 } 6496 if msglen < 0 { 6497 return ErrInvalidLengthGenerated 6498 } 6499 postIndex := iNdEx + msglen 6500 if postIndex > l { 6501 return io.ErrUnexpectedEOF 6502 } 6503 if m.Selector == nil { 6504 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 6505 } 6506 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6507 return err 6508 } 6509 iNdEx = postIndex 6510 case 3: 6511 if wireType != 2 { 6512 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) 6513 } 6514 var msglen int 6515 for shift := uint(0); ; shift += 7 { 6516 if shift >= 64 { 6517 return ErrIntOverflowGenerated 6518 } 6519 if iNdEx >= l { 6520 return io.ErrUnexpectedEOF 6521 } 6522 b := dAtA[iNdEx] 6523 iNdEx++ 6524 msglen |= (int(b) & 0x7F) << shift 6525 if b < 0x80 { 6526 break 6527 } 6528 } 6529 if msglen < 0 { 6530 return ErrInvalidLengthGenerated 6531 } 6532 postIndex := iNdEx + msglen 6533 if postIndex > l { 6534 return io.ErrUnexpectedEOF 6535 } 6536 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6537 return err 6538 } 6539 iNdEx = postIndex 6540 case 4: 6541 if wireType != 2 { 6542 return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType) 6543 } 6544 var msglen int 6545 for shift := uint(0); ; shift += 7 { 6546 if shift >= 64 { 6547 return ErrIntOverflowGenerated 6548 } 6549 if iNdEx >= l { 6550 return io.ErrUnexpectedEOF 6551 } 6552 b := dAtA[iNdEx] 6553 iNdEx++ 6554 msglen |= (int(b) & 0x7F) << shift 6555 if b < 0x80 { 6556 break 6557 } 6558 } 6559 if msglen < 0 { 6560 return ErrInvalidLengthGenerated 6561 } 6562 postIndex := iNdEx + msglen 6563 if postIndex > l { 6564 return io.ErrUnexpectedEOF 6565 } 6566 if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6567 return err 6568 } 6569 iNdEx = postIndex 6570 case 5: 6571 if wireType != 0 { 6572 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) 6573 } 6574 m.MinReadySeconds = 0 6575 for shift := uint(0); ; shift += 7 { 6576 if shift >= 64 { 6577 return ErrIntOverflowGenerated 6578 } 6579 if iNdEx >= l { 6580 return io.ErrUnexpectedEOF 6581 } 6582 b := dAtA[iNdEx] 6583 iNdEx++ 6584 m.MinReadySeconds |= (int32(b) & 0x7F) << shift 6585 if b < 0x80 { 6586 break 6587 } 6588 } 6589 case 6: 6590 if wireType != 0 { 6591 return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType) 6592 } 6593 var v int32 6594 for shift := uint(0); ; shift += 7 { 6595 if shift >= 64 { 6596 return ErrIntOverflowGenerated 6597 } 6598 if iNdEx >= l { 6599 return io.ErrUnexpectedEOF 6600 } 6601 b := dAtA[iNdEx] 6602 iNdEx++ 6603 v |= (int32(b) & 0x7F) << shift 6604 if b < 0x80 { 6605 break 6606 } 6607 } 6608 m.RevisionHistoryLimit = &v 6609 case 7: 6610 if wireType != 0 { 6611 return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType) 6612 } 6613 var v int 6614 for shift := uint(0); ; shift += 7 { 6615 if shift >= 64 { 6616 return ErrIntOverflowGenerated 6617 } 6618 if iNdEx >= l { 6619 return io.ErrUnexpectedEOF 6620 } 6621 b := dAtA[iNdEx] 6622 iNdEx++ 6623 v |= (int(b) & 0x7F) << shift 6624 if b < 0x80 { 6625 break 6626 } 6627 } 6628 m.Paused = bool(v != 0) 6629 case 8: 6630 if wireType != 2 { 6631 return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType) 6632 } 6633 var msglen int 6634 for shift := uint(0); ; shift += 7 { 6635 if shift >= 64 { 6636 return ErrIntOverflowGenerated 6637 } 6638 if iNdEx >= l { 6639 return io.ErrUnexpectedEOF 6640 } 6641 b := dAtA[iNdEx] 6642 iNdEx++ 6643 msglen |= (int(b) & 0x7F) << shift 6644 if b < 0x80 { 6645 break 6646 } 6647 } 6648 if msglen < 0 { 6649 return ErrInvalidLengthGenerated 6650 } 6651 postIndex := iNdEx + msglen 6652 if postIndex > l { 6653 return io.ErrUnexpectedEOF 6654 } 6655 if m.RollbackTo == nil { 6656 m.RollbackTo = &RollbackConfig{} 6657 } 6658 if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6659 return err 6660 } 6661 iNdEx = postIndex 6662 case 9: 6663 if wireType != 0 { 6664 return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType) 6665 } 6666 var v int32 6667 for shift := uint(0); ; shift += 7 { 6668 if shift >= 64 { 6669 return ErrIntOverflowGenerated 6670 } 6671 if iNdEx >= l { 6672 return io.ErrUnexpectedEOF 6673 } 6674 b := dAtA[iNdEx] 6675 iNdEx++ 6676 v |= (int32(b) & 0x7F) << shift 6677 if b < 0x80 { 6678 break 6679 } 6680 } 6681 m.ProgressDeadlineSeconds = &v 6682 default: 6683 iNdEx = preIndex 6684 skippy, err := skipGenerated(dAtA[iNdEx:]) 6685 if err != nil { 6686 return err 6687 } 6688 if skippy < 0 { 6689 return ErrInvalidLengthGenerated 6690 } 6691 if (iNdEx + skippy) > l { 6692 return io.ErrUnexpectedEOF 6693 } 6694 iNdEx += skippy 6695 } 6696 } 6697 6698 if iNdEx > l { 6699 return io.ErrUnexpectedEOF 6700 } 6701 return nil 6702} 6703func (m *DeploymentStatus) Unmarshal(dAtA []byte) error { 6704 l := len(dAtA) 6705 iNdEx := 0 6706 for iNdEx < l { 6707 preIndex := iNdEx 6708 var wire uint64 6709 for shift := uint(0); ; shift += 7 { 6710 if shift >= 64 { 6711 return ErrIntOverflowGenerated 6712 } 6713 if iNdEx >= l { 6714 return io.ErrUnexpectedEOF 6715 } 6716 b := dAtA[iNdEx] 6717 iNdEx++ 6718 wire |= (uint64(b) & 0x7F) << shift 6719 if b < 0x80 { 6720 break 6721 } 6722 } 6723 fieldNum := int32(wire >> 3) 6724 wireType := int(wire & 0x7) 6725 if wireType == 4 { 6726 return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group") 6727 } 6728 if fieldNum <= 0 { 6729 return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire) 6730 } 6731 switch fieldNum { 6732 case 1: 6733 if wireType != 0 { 6734 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) 6735 } 6736 m.ObservedGeneration = 0 6737 for shift := uint(0); ; shift += 7 { 6738 if shift >= 64 { 6739 return ErrIntOverflowGenerated 6740 } 6741 if iNdEx >= l { 6742 return io.ErrUnexpectedEOF 6743 } 6744 b := dAtA[iNdEx] 6745 iNdEx++ 6746 m.ObservedGeneration |= (int64(b) & 0x7F) << shift 6747 if b < 0x80 { 6748 break 6749 } 6750 } 6751 case 2: 6752 if wireType != 0 { 6753 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 6754 } 6755 m.Replicas = 0 6756 for shift := uint(0); ; shift += 7 { 6757 if shift >= 64 { 6758 return ErrIntOverflowGenerated 6759 } 6760 if iNdEx >= l { 6761 return io.ErrUnexpectedEOF 6762 } 6763 b := dAtA[iNdEx] 6764 iNdEx++ 6765 m.Replicas |= (int32(b) & 0x7F) << shift 6766 if b < 0x80 { 6767 break 6768 } 6769 } 6770 case 3: 6771 if wireType != 0 { 6772 return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType) 6773 } 6774 m.UpdatedReplicas = 0 6775 for shift := uint(0); ; shift += 7 { 6776 if shift >= 64 { 6777 return ErrIntOverflowGenerated 6778 } 6779 if iNdEx >= l { 6780 return io.ErrUnexpectedEOF 6781 } 6782 b := dAtA[iNdEx] 6783 iNdEx++ 6784 m.UpdatedReplicas |= (int32(b) & 0x7F) << shift 6785 if b < 0x80 { 6786 break 6787 } 6788 } 6789 case 4: 6790 if wireType != 0 { 6791 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) 6792 } 6793 m.AvailableReplicas = 0 6794 for shift := uint(0); ; shift += 7 { 6795 if shift >= 64 { 6796 return ErrIntOverflowGenerated 6797 } 6798 if iNdEx >= l { 6799 return io.ErrUnexpectedEOF 6800 } 6801 b := dAtA[iNdEx] 6802 iNdEx++ 6803 m.AvailableReplicas |= (int32(b) & 0x7F) << shift 6804 if b < 0x80 { 6805 break 6806 } 6807 } 6808 case 5: 6809 if wireType != 0 { 6810 return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType) 6811 } 6812 m.UnavailableReplicas = 0 6813 for shift := uint(0); ; shift += 7 { 6814 if shift >= 64 { 6815 return ErrIntOverflowGenerated 6816 } 6817 if iNdEx >= l { 6818 return io.ErrUnexpectedEOF 6819 } 6820 b := dAtA[iNdEx] 6821 iNdEx++ 6822 m.UnavailableReplicas |= (int32(b) & 0x7F) << shift 6823 if b < 0x80 { 6824 break 6825 } 6826 } 6827 case 6: 6828 if wireType != 2 { 6829 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 6830 } 6831 var msglen int 6832 for shift := uint(0); ; shift += 7 { 6833 if shift >= 64 { 6834 return ErrIntOverflowGenerated 6835 } 6836 if iNdEx >= l { 6837 return io.ErrUnexpectedEOF 6838 } 6839 b := dAtA[iNdEx] 6840 iNdEx++ 6841 msglen |= (int(b) & 0x7F) << shift 6842 if b < 0x80 { 6843 break 6844 } 6845 } 6846 if msglen < 0 { 6847 return ErrInvalidLengthGenerated 6848 } 6849 postIndex := iNdEx + msglen 6850 if postIndex > l { 6851 return io.ErrUnexpectedEOF 6852 } 6853 m.Conditions = append(m.Conditions, DeploymentCondition{}) 6854 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 6855 return err 6856 } 6857 iNdEx = postIndex 6858 case 7: 6859 if wireType != 0 { 6860 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) 6861 } 6862 m.ReadyReplicas = 0 6863 for shift := uint(0); ; shift += 7 { 6864 if shift >= 64 { 6865 return ErrIntOverflowGenerated 6866 } 6867 if iNdEx >= l { 6868 return io.ErrUnexpectedEOF 6869 } 6870 b := dAtA[iNdEx] 6871 iNdEx++ 6872 m.ReadyReplicas |= (int32(b) & 0x7F) << shift 6873 if b < 0x80 { 6874 break 6875 } 6876 } 6877 case 8: 6878 if wireType != 0 { 6879 return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType) 6880 } 6881 var v int32 6882 for shift := uint(0); ; shift += 7 { 6883 if shift >= 64 { 6884 return ErrIntOverflowGenerated 6885 } 6886 if iNdEx >= l { 6887 return io.ErrUnexpectedEOF 6888 } 6889 b := dAtA[iNdEx] 6890 iNdEx++ 6891 v |= (int32(b) & 0x7F) << shift 6892 if b < 0x80 { 6893 break 6894 } 6895 } 6896 m.CollisionCount = &v 6897 default: 6898 iNdEx = preIndex 6899 skippy, err := skipGenerated(dAtA[iNdEx:]) 6900 if err != nil { 6901 return err 6902 } 6903 if skippy < 0 { 6904 return ErrInvalidLengthGenerated 6905 } 6906 if (iNdEx + skippy) > l { 6907 return io.ErrUnexpectedEOF 6908 } 6909 iNdEx += skippy 6910 } 6911 } 6912 6913 if iNdEx > l { 6914 return io.ErrUnexpectedEOF 6915 } 6916 return nil 6917} 6918func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error { 6919 l := len(dAtA) 6920 iNdEx := 0 6921 for iNdEx < l { 6922 preIndex := iNdEx 6923 var wire uint64 6924 for shift := uint(0); ; shift += 7 { 6925 if shift >= 64 { 6926 return ErrIntOverflowGenerated 6927 } 6928 if iNdEx >= l { 6929 return io.ErrUnexpectedEOF 6930 } 6931 b := dAtA[iNdEx] 6932 iNdEx++ 6933 wire |= (uint64(b) & 0x7F) << shift 6934 if b < 0x80 { 6935 break 6936 } 6937 } 6938 fieldNum := int32(wire >> 3) 6939 wireType := int(wire & 0x7) 6940 if wireType == 4 { 6941 return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group") 6942 } 6943 if fieldNum <= 0 { 6944 return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire) 6945 } 6946 switch fieldNum { 6947 case 1: 6948 if wireType != 2 { 6949 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 6950 } 6951 var stringLen uint64 6952 for shift := uint(0); ; shift += 7 { 6953 if shift >= 64 { 6954 return ErrIntOverflowGenerated 6955 } 6956 if iNdEx >= l { 6957 return io.ErrUnexpectedEOF 6958 } 6959 b := dAtA[iNdEx] 6960 iNdEx++ 6961 stringLen |= (uint64(b) & 0x7F) << shift 6962 if b < 0x80 { 6963 break 6964 } 6965 } 6966 intStringLen := int(stringLen) 6967 if intStringLen < 0 { 6968 return ErrInvalidLengthGenerated 6969 } 6970 postIndex := iNdEx + intStringLen 6971 if postIndex > l { 6972 return io.ErrUnexpectedEOF 6973 } 6974 m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex]) 6975 iNdEx = postIndex 6976 case 2: 6977 if wireType != 2 { 6978 return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType) 6979 } 6980 var msglen int 6981 for shift := uint(0); ; shift += 7 { 6982 if shift >= 64 { 6983 return ErrIntOverflowGenerated 6984 } 6985 if iNdEx >= l { 6986 return io.ErrUnexpectedEOF 6987 } 6988 b := dAtA[iNdEx] 6989 iNdEx++ 6990 msglen |= (int(b) & 0x7F) << shift 6991 if b < 0x80 { 6992 break 6993 } 6994 } 6995 if msglen < 0 { 6996 return ErrInvalidLengthGenerated 6997 } 6998 postIndex := iNdEx + msglen 6999 if postIndex > l { 7000 return io.ErrUnexpectedEOF 7001 } 7002 if m.RollingUpdate == nil { 7003 m.RollingUpdate = &RollingUpdateDeployment{} 7004 } 7005 if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7006 return err 7007 } 7008 iNdEx = postIndex 7009 default: 7010 iNdEx = preIndex 7011 skippy, err := skipGenerated(dAtA[iNdEx:]) 7012 if err != nil { 7013 return err 7014 } 7015 if skippy < 0 { 7016 return ErrInvalidLengthGenerated 7017 } 7018 if (iNdEx + skippy) > l { 7019 return io.ErrUnexpectedEOF 7020 } 7021 iNdEx += skippy 7022 } 7023 } 7024 7025 if iNdEx > l { 7026 return io.ErrUnexpectedEOF 7027 } 7028 return nil 7029} 7030func (m *FSGroupStrategyOptions) Unmarshal(dAtA []byte) error { 7031 l := len(dAtA) 7032 iNdEx := 0 7033 for iNdEx < l { 7034 preIndex := iNdEx 7035 var wire uint64 7036 for shift := uint(0); ; shift += 7 { 7037 if shift >= 64 { 7038 return ErrIntOverflowGenerated 7039 } 7040 if iNdEx >= l { 7041 return io.ErrUnexpectedEOF 7042 } 7043 b := dAtA[iNdEx] 7044 iNdEx++ 7045 wire |= (uint64(b) & 0x7F) << shift 7046 if b < 0x80 { 7047 break 7048 } 7049 } 7050 fieldNum := int32(wire >> 3) 7051 wireType := int(wire & 0x7) 7052 if wireType == 4 { 7053 return fmt.Errorf("proto: FSGroupStrategyOptions: wiretype end group for non-group") 7054 } 7055 if fieldNum <= 0 { 7056 return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 7057 } 7058 switch fieldNum { 7059 case 1: 7060 if wireType != 2 { 7061 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 7062 } 7063 var stringLen uint64 7064 for shift := uint(0); ; shift += 7 { 7065 if shift >= 64 { 7066 return ErrIntOverflowGenerated 7067 } 7068 if iNdEx >= l { 7069 return io.ErrUnexpectedEOF 7070 } 7071 b := dAtA[iNdEx] 7072 iNdEx++ 7073 stringLen |= (uint64(b) & 0x7F) << shift 7074 if b < 0x80 { 7075 break 7076 } 7077 } 7078 intStringLen := int(stringLen) 7079 if intStringLen < 0 { 7080 return ErrInvalidLengthGenerated 7081 } 7082 postIndex := iNdEx + intStringLen 7083 if postIndex > l { 7084 return io.ErrUnexpectedEOF 7085 } 7086 m.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex]) 7087 iNdEx = postIndex 7088 case 2: 7089 if wireType != 2 { 7090 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 7091 } 7092 var msglen int 7093 for shift := uint(0); ; shift += 7 { 7094 if shift >= 64 { 7095 return ErrIntOverflowGenerated 7096 } 7097 if iNdEx >= l { 7098 return io.ErrUnexpectedEOF 7099 } 7100 b := dAtA[iNdEx] 7101 iNdEx++ 7102 msglen |= (int(b) & 0x7F) << shift 7103 if b < 0x80 { 7104 break 7105 } 7106 } 7107 if msglen < 0 { 7108 return ErrInvalidLengthGenerated 7109 } 7110 postIndex := iNdEx + msglen 7111 if postIndex > l { 7112 return io.ErrUnexpectedEOF 7113 } 7114 m.Ranges = append(m.Ranges, IDRange{}) 7115 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7116 return err 7117 } 7118 iNdEx = postIndex 7119 default: 7120 iNdEx = preIndex 7121 skippy, err := skipGenerated(dAtA[iNdEx:]) 7122 if err != nil { 7123 return err 7124 } 7125 if skippy < 0 { 7126 return ErrInvalidLengthGenerated 7127 } 7128 if (iNdEx + skippy) > l { 7129 return io.ErrUnexpectedEOF 7130 } 7131 iNdEx += skippy 7132 } 7133 } 7134 7135 if iNdEx > l { 7136 return io.ErrUnexpectedEOF 7137 } 7138 return nil 7139} 7140func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error { 7141 l := len(dAtA) 7142 iNdEx := 0 7143 for iNdEx < l { 7144 preIndex := iNdEx 7145 var wire uint64 7146 for shift := uint(0); ; shift += 7 { 7147 if shift >= 64 { 7148 return ErrIntOverflowGenerated 7149 } 7150 if iNdEx >= l { 7151 return io.ErrUnexpectedEOF 7152 } 7153 b := dAtA[iNdEx] 7154 iNdEx++ 7155 wire |= (uint64(b) & 0x7F) << shift 7156 if b < 0x80 { 7157 break 7158 } 7159 } 7160 fieldNum := int32(wire >> 3) 7161 wireType := int(wire & 0x7) 7162 if wireType == 4 { 7163 return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group") 7164 } 7165 if fieldNum <= 0 { 7166 return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire) 7167 } 7168 switch fieldNum { 7169 case 1: 7170 if wireType != 2 { 7171 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) 7172 } 7173 var stringLen uint64 7174 for shift := uint(0); ; shift += 7 { 7175 if shift >= 64 { 7176 return ErrIntOverflowGenerated 7177 } 7178 if iNdEx >= l { 7179 return io.ErrUnexpectedEOF 7180 } 7181 b := dAtA[iNdEx] 7182 iNdEx++ 7183 stringLen |= (uint64(b) & 0x7F) << shift 7184 if b < 0x80 { 7185 break 7186 } 7187 } 7188 intStringLen := int(stringLen) 7189 if intStringLen < 0 { 7190 return ErrInvalidLengthGenerated 7191 } 7192 postIndex := iNdEx + intStringLen 7193 if postIndex > l { 7194 return io.ErrUnexpectedEOF 7195 } 7196 m.Path = string(dAtA[iNdEx:postIndex]) 7197 iNdEx = postIndex 7198 case 2: 7199 if wireType != 2 { 7200 return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType) 7201 } 7202 var msglen int 7203 for shift := uint(0); ; shift += 7 { 7204 if shift >= 64 { 7205 return ErrIntOverflowGenerated 7206 } 7207 if iNdEx >= l { 7208 return io.ErrUnexpectedEOF 7209 } 7210 b := dAtA[iNdEx] 7211 iNdEx++ 7212 msglen |= (int(b) & 0x7F) << shift 7213 if b < 0x80 { 7214 break 7215 } 7216 } 7217 if msglen < 0 { 7218 return ErrInvalidLengthGenerated 7219 } 7220 postIndex := iNdEx + msglen 7221 if postIndex > l { 7222 return io.ErrUnexpectedEOF 7223 } 7224 if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7225 return err 7226 } 7227 iNdEx = postIndex 7228 default: 7229 iNdEx = preIndex 7230 skippy, err := skipGenerated(dAtA[iNdEx:]) 7231 if err != nil { 7232 return err 7233 } 7234 if skippy < 0 { 7235 return ErrInvalidLengthGenerated 7236 } 7237 if (iNdEx + skippy) > l { 7238 return io.ErrUnexpectedEOF 7239 } 7240 iNdEx += skippy 7241 } 7242 } 7243 7244 if iNdEx > l { 7245 return io.ErrUnexpectedEOF 7246 } 7247 return nil 7248} 7249func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error { 7250 l := len(dAtA) 7251 iNdEx := 0 7252 for iNdEx < l { 7253 preIndex := iNdEx 7254 var wire uint64 7255 for shift := uint(0); ; shift += 7 { 7256 if shift >= 64 { 7257 return ErrIntOverflowGenerated 7258 } 7259 if iNdEx >= l { 7260 return io.ErrUnexpectedEOF 7261 } 7262 b := dAtA[iNdEx] 7263 iNdEx++ 7264 wire |= (uint64(b) & 0x7F) << shift 7265 if b < 0x80 { 7266 break 7267 } 7268 } 7269 fieldNum := int32(wire >> 3) 7270 wireType := int(wire & 0x7) 7271 if wireType == 4 { 7272 return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group") 7273 } 7274 if fieldNum <= 0 { 7275 return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire) 7276 } 7277 switch fieldNum { 7278 case 1: 7279 if wireType != 2 { 7280 return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType) 7281 } 7282 var msglen int 7283 for shift := uint(0); ; shift += 7 { 7284 if shift >= 64 { 7285 return ErrIntOverflowGenerated 7286 } 7287 if iNdEx >= l { 7288 return io.ErrUnexpectedEOF 7289 } 7290 b := dAtA[iNdEx] 7291 iNdEx++ 7292 msglen |= (int(b) & 0x7F) << shift 7293 if b < 0x80 { 7294 break 7295 } 7296 } 7297 if msglen < 0 { 7298 return ErrInvalidLengthGenerated 7299 } 7300 postIndex := iNdEx + msglen 7301 if postIndex > l { 7302 return io.ErrUnexpectedEOF 7303 } 7304 m.Paths = append(m.Paths, HTTPIngressPath{}) 7305 if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7306 return err 7307 } 7308 iNdEx = postIndex 7309 default: 7310 iNdEx = preIndex 7311 skippy, err := skipGenerated(dAtA[iNdEx:]) 7312 if err != nil { 7313 return err 7314 } 7315 if skippy < 0 { 7316 return ErrInvalidLengthGenerated 7317 } 7318 if (iNdEx + skippy) > l { 7319 return io.ErrUnexpectedEOF 7320 } 7321 iNdEx += skippy 7322 } 7323 } 7324 7325 if iNdEx > l { 7326 return io.ErrUnexpectedEOF 7327 } 7328 return nil 7329} 7330func (m *HostPortRange) Unmarshal(dAtA []byte) error { 7331 l := len(dAtA) 7332 iNdEx := 0 7333 for iNdEx < l { 7334 preIndex := iNdEx 7335 var wire uint64 7336 for shift := uint(0); ; shift += 7 { 7337 if shift >= 64 { 7338 return ErrIntOverflowGenerated 7339 } 7340 if iNdEx >= l { 7341 return io.ErrUnexpectedEOF 7342 } 7343 b := dAtA[iNdEx] 7344 iNdEx++ 7345 wire |= (uint64(b) & 0x7F) << shift 7346 if b < 0x80 { 7347 break 7348 } 7349 } 7350 fieldNum := int32(wire >> 3) 7351 wireType := int(wire & 0x7) 7352 if wireType == 4 { 7353 return fmt.Errorf("proto: HostPortRange: wiretype end group for non-group") 7354 } 7355 if fieldNum <= 0 { 7356 return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire) 7357 } 7358 switch fieldNum { 7359 case 1: 7360 if wireType != 0 { 7361 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType) 7362 } 7363 m.Min = 0 7364 for shift := uint(0); ; shift += 7 { 7365 if shift >= 64 { 7366 return ErrIntOverflowGenerated 7367 } 7368 if iNdEx >= l { 7369 return io.ErrUnexpectedEOF 7370 } 7371 b := dAtA[iNdEx] 7372 iNdEx++ 7373 m.Min |= (int32(b) & 0x7F) << shift 7374 if b < 0x80 { 7375 break 7376 } 7377 } 7378 case 2: 7379 if wireType != 0 { 7380 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) 7381 } 7382 m.Max = 0 7383 for shift := uint(0); ; shift += 7 { 7384 if shift >= 64 { 7385 return ErrIntOverflowGenerated 7386 } 7387 if iNdEx >= l { 7388 return io.ErrUnexpectedEOF 7389 } 7390 b := dAtA[iNdEx] 7391 iNdEx++ 7392 m.Max |= (int32(b) & 0x7F) << shift 7393 if b < 0x80 { 7394 break 7395 } 7396 } 7397 default: 7398 iNdEx = preIndex 7399 skippy, err := skipGenerated(dAtA[iNdEx:]) 7400 if err != nil { 7401 return err 7402 } 7403 if skippy < 0 { 7404 return ErrInvalidLengthGenerated 7405 } 7406 if (iNdEx + skippy) > l { 7407 return io.ErrUnexpectedEOF 7408 } 7409 iNdEx += skippy 7410 } 7411 } 7412 7413 if iNdEx > l { 7414 return io.ErrUnexpectedEOF 7415 } 7416 return nil 7417} 7418func (m *IDRange) Unmarshal(dAtA []byte) error { 7419 l := len(dAtA) 7420 iNdEx := 0 7421 for iNdEx < l { 7422 preIndex := iNdEx 7423 var wire uint64 7424 for shift := uint(0); ; shift += 7 { 7425 if shift >= 64 { 7426 return ErrIntOverflowGenerated 7427 } 7428 if iNdEx >= l { 7429 return io.ErrUnexpectedEOF 7430 } 7431 b := dAtA[iNdEx] 7432 iNdEx++ 7433 wire |= (uint64(b) & 0x7F) << shift 7434 if b < 0x80 { 7435 break 7436 } 7437 } 7438 fieldNum := int32(wire >> 3) 7439 wireType := int(wire & 0x7) 7440 if wireType == 4 { 7441 return fmt.Errorf("proto: IDRange: wiretype end group for non-group") 7442 } 7443 if fieldNum <= 0 { 7444 return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire) 7445 } 7446 switch fieldNum { 7447 case 1: 7448 if wireType != 0 { 7449 return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType) 7450 } 7451 m.Min = 0 7452 for shift := uint(0); ; shift += 7 { 7453 if shift >= 64 { 7454 return ErrIntOverflowGenerated 7455 } 7456 if iNdEx >= l { 7457 return io.ErrUnexpectedEOF 7458 } 7459 b := dAtA[iNdEx] 7460 iNdEx++ 7461 m.Min |= (int64(b) & 0x7F) << shift 7462 if b < 0x80 { 7463 break 7464 } 7465 } 7466 case 2: 7467 if wireType != 0 { 7468 return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) 7469 } 7470 m.Max = 0 7471 for shift := uint(0); ; shift += 7 { 7472 if shift >= 64 { 7473 return ErrIntOverflowGenerated 7474 } 7475 if iNdEx >= l { 7476 return io.ErrUnexpectedEOF 7477 } 7478 b := dAtA[iNdEx] 7479 iNdEx++ 7480 m.Max |= (int64(b) & 0x7F) << shift 7481 if b < 0x80 { 7482 break 7483 } 7484 } 7485 default: 7486 iNdEx = preIndex 7487 skippy, err := skipGenerated(dAtA[iNdEx:]) 7488 if err != nil { 7489 return err 7490 } 7491 if skippy < 0 { 7492 return ErrInvalidLengthGenerated 7493 } 7494 if (iNdEx + skippy) > l { 7495 return io.ErrUnexpectedEOF 7496 } 7497 iNdEx += skippy 7498 } 7499 } 7500 7501 if iNdEx > l { 7502 return io.ErrUnexpectedEOF 7503 } 7504 return nil 7505} 7506func (m *IPBlock) Unmarshal(dAtA []byte) error { 7507 l := len(dAtA) 7508 iNdEx := 0 7509 for iNdEx < l { 7510 preIndex := iNdEx 7511 var wire uint64 7512 for shift := uint(0); ; shift += 7 { 7513 if shift >= 64 { 7514 return ErrIntOverflowGenerated 7515 } 7516 if iNdEx >= l { 7517 return io.ErrUnexpectedEOF 7518 } 7519 b := dAtA[iNdEx] 7520 iNdEx++ 7521 wire |= (uint64(b) & 0x7F) << shift 7522 if b < 0x80 { 7523 break 7524 } 7525 } 7526 fieldNum := int32(wire >> 3) 7527 wireType := int(wire & 0x7) 7528 if wireType == 4 { 7529 return fmt.Errorf("proto: IPBlock: wiretype end group for non-group") 7530 } 7531 if fieldNum <= 0 { 7532 return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire) 7533 } 7534 switch fieldNum { 7535 case 1: 7536 if wireType != 2 { 7537 return fmt.Errorf("proto: wrong wireType = %d for field CIDR", wireType) 7538 } 7539 var stringLen uint64 7540 for shift := uint(0); ; shift += 7 { 7541 if shift >= 64 { 7542 return ErrIntOverflowGenerated 7543 } 7544 if iNdEx >= l { 7545 return io.ErrUnexpectedEOF 7546 } 7547 b := dAtA[iNdEx] 7548 iNdEx++ 7549 stringLen |= (uint64(b) & 0x7F) << shift 7550 if b < 0x80 { 7551 break 7552 } 7553 } 7554 intStringLen := int(stringLen) 7555 if intStringLen < 0 { 7556 return ErrInvalidLengthGenerated 7557 } 7558 postIndex := iNdEx + intStringLen 7559 if postIndex > l { 7560 return io.ErrUnexpectedEOF 7561 } 7562 m.CIDR = string(dAtA[iNdEx:postIndex]) 7563 iNdEx = postIndex 7564 case 2: 7565 if wireType != 2 { 7566 return fmt.Errorf("proto: wrong wireType = %d for field Except", wireType) 7567 } 7568 var stringLen uint64 7569 for shift := uint(0); ; shift += 7 { 7570 if shift >= 64 { 7571 return ErrIntOverflowGenerated 7572 } 7573 if iNdEx >= l { 7574 return io.ErrUnexpectedEOF 7575 } 7576 b := dAtA[iNdEx] 7577 iNdEx++ 7578 stringLen |= (uint64(b) & 0x7F) << shift 7579 if b < 0x80 { 7580 break 7581 } 7582 } 7583 intStringLen := int(stringLen) 7584 if intStringLen < 0 { 7585 return ErrInvalidLengthGenerated 7586 } 7587 postIndex := iNdEx + intStringLen 7588 if postIndex > l { 7589 return io.ErrUnexpectedEOF 7590 } 7591 m.Except = append(m.Except, string(dAtA[iNdEx:postIndex])) 7592 iNdEx = postIndex 7593 default: 7594 iNdEx = preIndex 7595 skippy, err := skipGenerated(dAtA[iNdEx:]) 7596 if err != nil { 7597 return err 7598 } 7599 if skippy < 0 { 7600 return ErrInvalidLengthGenerated 7601 } 7602 if (iNdEx + skippy) > l { 7603 return io.ErrUnexpectedEOF 7604 } 7605 iNdEx += skippy 7606 } 7607 } 7608 7609 if iNdEx > l { 7610 return io.ErrUnexpectedEOF 7611 } 7612 return nil 7613} 7614func (m *Ingress) Unmarshal(dAtA []byte) error { 7615 l := len(dAtA) 7616 iNdEx := 0 7617 for iNdEx < l { 7618 preIndex := iNdEx 7619 var wire uint64 7620 for shift := uint(0); ; shift += 7 { 7621 if shift >= 64 { 7622 return ErrIntOverflowGenerated 7623 } 7624 if iNdEx >= l { 7625 return io.ErrUnexpectedEOF 7626 } 7627 b := dAtA[iNdEx] 7628 iNdEx++ 7629 wire |= (uint64(b) & 0x7F) << shift 7630 if b < 0x80 { 7631 break 7632 } 7633 } 7634 fieldNum := int32(wire >> 3) 7635 wireType := int(wire & 0x7) 7636 if wireType == 4 { 7637 return fmt.Errorf("proto: Ingress: wiretype end group for non-group") 7638 } 7639 if fieldNum <= 0 { 7640 return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire) 7641 } 7642 switch fieldNum { 7643 case 1: 7644 if wireType != 2 { 7645 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 7646 } 7647 var msglen int 7648 for shift := uint(0); ; shift += 7 { 7649 if shift >= 64 { 7650 return ErrIntOverflowGenerated 7651 } 7652 if iNdEx >= l { 7653 return io.ErrUnexpectedEOF 7654 } 7655 b := dAtA[iNdEx] 7656 iNdEx++ 7657 msglen |= (int(b) & 0x7F) << shift 7658 if b < 0x80 { 7659 break 7660 } 7661 } 7662 if msglen < 0 { 7663 return ErrInvalidLengthGenerated 7664 } 7665 postIndex := iNdEx + msglen 7666 if postIndex > l { 7667 return io.ErrUnexpectedEOF 7668 } 7669 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7670 return err 7671 } 7672 iNdEx = postIndex 7673 case 2: 7674 if wireType != 2 { 7675 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 7676 } 7677 var msglen int 7678 for shift := uint(0); ; shift += 7 { 7679 if shift >= 64 { 7680 return ErrIntOverflowGenerated 7681 } 7682 if iNdEx >= l { 7683 return io.ErrUnexpectedEOF 7684 } 7685 b := dAtA[iNdEx] 7686 iNdEx++ 7687 msglen |= (int(b) & 0x7F) << shift 7688 if b < 0x80 { 7689 break 7690 } 7691 } 7692 if msglen < 0 { 7693 return ErrInvalidLengthGenerated 7694 } 7695 postIndex := iNdEx + msglen 7696 if postIndex > l { 7697 return io.ErrUnexpectedEOF 7698 } 7699 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7700 return err 7701 } 7702 iNdEx = postIndex 7703 case 3: 7704 if wireType != 2 { 7705 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 7706 } 7707 var msglen int 7708 for shift := uint(0); ; shift += 7 { 7709 if shift >= 64 { 7710 return ErrIntOverflowGenerated 7711 } 7712 if iNdEx >= l { 7713 return io.ErrUnexpectedEOF 7714 } 7715 b := dAtA[iNdEx] 7716 iNdEx++ 7717 msglen |= (int(b) & 0x7F) << shift 7718 if b < 0x80 { 7719 break 7720 } 7721 } 7722 if msglen < 0 { 7723 return ErrInvalidLengthGenerated 7724 } 7725 postIndex := iNdEx + msglen 7726 if postIndex > l { 7727 return io.ErrUnexpectedEOF 7728 } 7729 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7730 return err 7731 } 7732 iNdEx = postIndex 7733 default: 7734 iNdEx = preIndex 7735 skippy, err := skipGenerated(dAtA[iNdEx:]) 7736 if err != nil { 7737 return err 7738 } 7739 if skippy < 0 { 7740 return ErrInvalidLengthGenerated 7741 } 7742 if (iNdEx + skippy) > l { 7743 return io.ErrUnexpectedEOF 7744 } 7745 iNdEx += skippy 7746 } 7747 } 7748 7749 if iNdEx > l { 7750 return io.ErrUnexpectedEOF 7751 } 7752 return nil 7753} 7754func (m *IngressBackend) Unmarshal(dAtA []byte) error { 7755 l := len(dAtA) 7756 iNdEx := 0 7757 for iNdEx < l { 7758 preIndex := iNdEx 7759 var wire uint64 7760 for shift := uint(0); ; shift += 7 { 7761 if shift >= 64 { 7762 return ErrIntOverflowGenerated 7763 } 7764 if iNdEx >= l { 7765 return io.ErrUnexpectedEOF 7766 } 7767 b := dAtA[iNdEx] 7768 iNdEx++ 7769 wire |= (uint64(b) & 0x7F) << shift 7770 if b < 0x80 { 7771 break 7772 } 7773 } 7774 fieldNum := int32(wire >> 3) 7775 wireType := int(wire & 0x7) 7776 if wireType == 4 { 7777 return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group") 7778 } 7779 if fieldNum <= 0 { 7780 return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire) 7781 } 7782 switch fieldNum { 7783 case 1: 7784 if wireType != 2 { 7785 return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) 7786 } 7787 var stringLen uint64 7788 for shift := uint(0); ; shift += 7 { 7789 if shift >= 64 { 7790 return ErrIntOverflowGenerated 7791 } 7792 if iNdEx >= l { 7793 return io.ErrUnexpectedEOF 7794 } 7795 b := dAtA[iNdEx] 7796 iNdEx++ 7797 stringLen |= (uint64(b) & 0x7F) << shift 7798 if b < 0x80 { 7799 break 7800 } 7801 } 7802 intStringLen := int(stringLen) 7803 if intStringLen < 0 { 7804 return ErrInvalidLengthGenerated 7805 } 7806 postIndex := iNdEx + intStringLen 7807 if postIndex > l { 7808 return io.ErrUnexpectedEOF 7809 } 7810 m.ServiceName = string(dAtA[iNdEx:postIndex]) 7811 iNdEx = postIndex 7812 case 2: 7813 if wireType != 2 { 7814 return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType) 7815 } 7816 var msglen int 7817 for shift := uint(0); ; shift += 7 { 7818 if shift >= 64 { 7819 return ErrIntOverflowGenerated 7820 } 7821 if iNdEx >= l { 7822 return io.ErrUnexpectedEOF 7823 } 7824 b := dAtA[iNdEx] 7825 iNdEx++ 7826 msglen |= (int(b) & 0x7F) << shift 7827 if b < 0x80 { 7828 break 7829 } 7830 } 7831 if msglen < 0 { 7832 return ErrInvalidLengthGenerated 7833 } 7834 postIndex := iNdEx + msglen 7835 if postIndex > l { 7836 return io.ErrUnexpectedEOF 7837 } 7838 if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7839 return err 7840 } 7841 iNdEx = postIndex 7842 default: 7843 iNdEx = preIndex 7844 skippy, err := skipGenerated(dAtA[iNdEx:]) 7845 if err != nil { 7846 return err 7847 } 7848 if skippy < 0 { 7849 return ErrInvalidLengthGenerated 7850 } 7851 if (iNdEx + skippy) > l { 7852 return io.ErrUnexpectedEOF 7853 } 7854 iNdEx += skippy 7855 } 7856 } 7857 7858 if iNdEx > l { 7859 return io.ErrUnexpectedEOF 7860 } 7861 return nil 7862} 7863func (m *IngressList) Unmarshal(dAtA []byte) error { 7864 l := len(dAtA) 7865 iNdEx := 0 7866 for iNdEx < l { 7867 preIndex := iNdEx 7868 var wire uint64 7869 for shift := uint(0); ; shift += 7 { 7870 if shift >= 64 { 7871 return ErrIntOverflowGenerated 7872 } 7873 if iNdEx >= l { 7874 return io.ErrUnexpectedEOF 7875 } 7876 b := dAtA[iNdEx] 7877 iNdEx++ 7878 wire |= (uint64(b) & 0x7F) << shift 7879 if b < 0x80 { 7880 break 7881 } 7882 } 7883 fieldNum := int32(wire >> 3) 7884 wireType := int(wire & 0x7) 7885 if wireType == 4 { 7886 return fmt.Errorf("proto: IngressList: wiretype end group for non-group") 7887 } 7888 if fieldNum <= 0 { 7889 return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire) 7890 } 7891 switch fieldNum { 7892 case 1: 7893 if wireType != 2 { 7894 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 7895 } 7896 var msglen int 7897 for shift := uint(0); ; shift += 7 { 7898 if shift >= 64 { 7899 return ErrIntOverflowGenerated 7900 } 7901 if iNdEx >= l { 7902 return io.ErrUnexpectedEOF 7903 } 7904 b := dAtA[iNdEx] 7905 iNdEx++ 7906 msglen |= (int(b) & 0x7F) << shift 7907 if b < 0x80 { 7908 break 7909 } 7910 } 7911 if msglen < 0 { 7912 return ErrInvalidLengthGenerated 7913 } 7914 postIndex := iNdEx + msglen 7915 if postIndex > l { 7916 return io.ErrUnexpectedEOF 7917 } 7918 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7919 return err 7920 } 7921 iNdEx = postIndex 7922 case 2: 7923 if wireType != 2 { 7924 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 7925 } 7926 var msglen int 7927 for shift := uint(0); ; shift += 7 { 7928 if shift >= 64 { 7929 return ErrIntOverflowGenerated 7930 } 7931 if iNdEx >= l { 7932 return io.ErrUnexpectedEOF 7933 } 7934 b := dAtA[iNdEx] 7935 iNdEx++ 7936 msglen |= (int(b) & 0x7F) << shift 7937 if b < 0x80 { 7938 break 7939 } 7940 } 7941 if msglen < 0 { 7942 return ErrInvalidLengthGenerated 7943 } 7944 postIndex := iNdEx + msglen 7945 if postIndex > l { 7946 return io.ErrUnexpectedEOF 7947 } 7948 m.Items = append(m.Items, Ingress{}) 7949 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7950 return err 7951 } 7952 iNdEx = postIndex 7953 default: 7954 iNdEx = preIndex 7955 skippy, err := skipGenerated(dAtA[iNdEx:]) 7956 if err != nil { 7957 return err 7958 } 7959 if skippy < 0 { 7960 return ErrInvalidLengthGenerated 7961 } 7962 if (iNdEx + skippy) > l { 7963 return io.ErrUnexpectedEOF 7964 } 7965 iNdEx += skippy 7966 } 7967 } 7968 7969 if iNdEx > l { 7970 return io.ErrUnexpectedEOF 7971 } 7972 return nil 7973} 7974func (m *IngressRule) Unmarshal(dAtA []byte) error { 7975 l := len(dAtA) 7976 iNdEx := 0 7977 for iNdEx < l { 7978 preIndex := iNdEx 7979 var wire uint64 7980 for shift := uint(0); ; shift += 7 { 7981 if shift >= 64 { 7982 return ErrIntOverflowGenerated 7983 } 7984 if iNdEx >= l { 7985 return io.ErrUnexpectedEOF 7986 } 7987 b := dAtA[iNdEx] 7988 iNdEx++ 7989 wire |= (uint64(b) & 0x7F) << shift 7990 if b < 0x80 { 7991 break 7992 } 7993 } 7994 fieldNum := int32(wire >> 3) 7995 wireType := int(wire & 0x7) 7996 if wireType == 4 { 7997 return fmt.Errorf("proto: IngressRule: wiretype end group for non-group") 7998 } 7999 if fieldNum <= 0 { 8000 return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire) 8001 } 8002 switch fieldNum { 8003 case 1: 8004 if wireType != 2 { 8005 return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) 8006 } 8007 var stringLen uint64 8008 for shift := uint(0); ; shift += 7 { 8009 if shift >= 64 { 8010 return ErrIntOverflowGenerated 8011 } 8012 if iNdEx >= l { 8013 return io.ErrUnexpectedEOF 8014 } 8015 b := dAtA[iNdEx] 8016 iNdEx++ 8017 stringLen |= (uint64(b) & 0x7F) << shift 8018 if b < 0x80 { 8019 break 8020 } 8021 } 8022 intStringLen := int(stringLen) 8023 if intStringLen < 0 { 8024 return ErrInvalidLengthGenerated 8025 } 8026 postIndex := iNdEx + intStringLen 8027 if postIndex > l { 8028 return io.ErrUnexpectedEOF 8029 } 8030 m.Host = string(dAtA[iNdEx:postIndex]) 8031 iNdEx = postIndex 8032 case 2: 8033 if wireType != 2 { 8034 return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType) 8035 } 8036 var msglen int 8037 for shift := uint(0); ; shift += 7 { 8038 if shift >= 64 { 8039 return ErrIntOverflowGenerated 8040 } 8041 if iNdEx >= l { 8042 return io.ErrUnexpectedEOF 8043 } 8044 b := dAtA[iNdEx] 8045 iNdEx++ 8046 msglen |= (int(b) & 0x7F) << shift 8047 if b < 0x80 { 8048 break 8049 } 8050 } 8051 if msglen < 0 { 8052 return ErrInvalidLengthGenerated 8053 } 8054 postIndex := iNdEx + msglen 8055 if postIndex > l { 8056 return io.ErrUnexpectedEOF 8057 } 8058 if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8059 return err 8060 } 8061 iNdEx = postIndex 8062 default: 8063 iNdEx = preIndex 8064 skippy, err := skipGenerated(dAtA[iNdEx:]) 8065 if err != nil { 8066 return err 8067 } 8068 if skippy < 0 { 8069 return ErrInvalidLengthGenerated 8070 } 8071 if (iNdEx + skippy) > l { 8072 return io.ErrUnexpectedEOF 8073 } 8074 iNdEx += skippy 8075 } 8076 } 8077 8078 if iNdEx > l { 8079 return io.ErrUnexpectedEOF 8080 } 8081 return nil 8082} 8083func (m *IngressRuleValue) Unmarshal(dAtA []byte) error { 8084 l := len(dAtA) 8085 iNdEx := 0 8086 for iNdEx < l { 8087 preIndex := iNdEx 8088 var wire uint64 8089 for shift := uint(0); ; shift += 7 { 8090 if shift >= 64 { 8091 return ErrIntOverflowGenerated 8092 } 8093 if iNdEx >= l { 8094 return io.ErrUnexpectedEOF 8095 } 8096 b := dAtA[iNdEx] 8097 iNdEx++ 8098 wire |= (uint64(b) & 0x7F) << shift 8099 if b < 0x80 { 8100 break 8101 } 8102 } 8103 fieldNum := int32(wire >> 3) 8104 wireType := int(wire & 0x7) 8105 if wireType == 4 { 8106 return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group") 8107 } 8108 if fieldNum <= 0 { 8109 return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire) 8110 } 8111 switch fieldNum { 8112 case 1: 8113 if wireType != 2 { 8114 return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType) 8115 } 8116 var msglen int 8117 for shift := uint(0); ; shift += 7 { 8118 if shift >= 64 { 8119 return ErrIntOverflowGenerated 8120 } 8121 if iNdEx >= l { 8122 return io.ErrUnexpectedEOF 8123 } 8124 b := dAtA[iNdEx] 8125 iNdEx++ 8126 msglen |= (int(b) & 0x7F) << shift 8127 if b < 0x80 { 8128 break 8129 } 8130 } 8131 if msglen < 0 { 8132 return ErrInvalidLengthGenerated 8133 } 8134 postIndex := iNdEx + msglen 8135 if postIndex > l { 8136 return io.ErrUnexpectedEOF 8137 } 8138 if m.HTTP == nil { 8139 m.HTTP = &HTTPIngressRuleValue{} 8140 } 8141 if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8142 return err 8143 } 8144 iNdEx = postIndex 8145 default: 8146 iNdEx = preIndex 8147 skippy, err := skipGenerated(dAtA[iNdEx:]) 8148 if err != nil { 8149 return err 8150 } 8151 if skippy < 0 { 8152 return ErrInvalidLengthGenerated 8153 } 8154 if (iNdEx + skippy) > l { 8155 return io.ErrUnexpectedEOF 8156 } 8157 iNdEx += skippy 8158 } 8159 } 8160 8161 if iNdEx > l { 8162 return io.ErrUnexpectedEOF 8163 } 8164 return nil 8165} 8166func (m *IngressSpec) Unmarshal(dAtA []byte) error { 8167 l := len(dAtA) 8168 iNdEx := 0 8169 for iNdEx < l { 8170 preIndex := iNdEx 8171 var wire uint64 8172 for shift := uint(0); ; shift += 7 { 8173 if shift >= 64 { 8174 return ErrIntOverflowGenerated 8175 } 8176 if iNdEx >= l { 8177 return io.ErrUnexpectedEOF 8178 } 8179 b := dAtA[iNdEx] 8180 iNdEx++ 8181 wire |= (uint64(b) & 0x7F) << shift 8182 if b < 0x80 { 8183 break 8184 } 8185 } 8186 fieldNum := int32(wire >> 3) 8187 wireType := int(wire & 0x7) 8188 if wireType == 4 { 8189 return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group") 8190 } 8191 if fieldNum <= 0 { 8192 return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire) 8193 } 8194 switch fieldNum { 8195 case 1: 8196 if wireType != 2 { 8197 return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType) 8198 } 8199 var msglen int 8200 for shift := uint(0); ; shift += 7 { 8201 if shift >= 64 { 8202 return ErrIntOverflowGenerated 8203 } 8204 if iNdEx >= l { 8205 return io.ErrUnexpectedEOF 8206 } 8207 b := dAtA[iNdEx] 8208 iNdEx++ 8209 msglen |= (int(b) & 0x7F) << shift 8210 if b < 0x80 { 8211 break 8212 } 8213 } 8214 if msglen < 0 { 8215 return ErrInvalidLengthGenerated 8216 } 8217 postIndex := iNdEx + msglen 8218 if postIndex > l { 8219 return io.ErrUnexpectedEOF 8220 } 8221 if m.Backend == nil { 8222 m.Backend = &IngressBackend{} 8223 } 8224 if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8225 return err 8226 } 8227 iNdEx = postIndex 8228 case 2: 8229 if wireType != 2 { 8230 return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType) 8231 } 8232 var msglen int 8233 for shift := uint(0); ; shift += 7 { 8234 if shift >= 64 { 8235 return ErrIntOverflowGenerated 8236 } 8237 if iNdEx >= l { 8238 return io.ErrUnexpectedEOF 8239 } 8240 b := dAtA[iNdEx] 8241 iNdEx++ 8242 msglen |= (int(b) & 0x7F) << shift 8243 if b < 0x80 { 8244 break 8245 } 8246 } 8247 if msglen < 0 { 8248 return ErrInvalidLengthGenerated 8249 } 8250 postIndex := iNdEx + msglen 8251 if postIndex > l { 8252 return io.ErrUnexpectedEOF 8253 } 8254 m.TLS = append(m.TLS, IngressTLS{}) 8255 if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8256 return err 8257 } 8258 iNdEx = postIndex 8259 case 3: 8260 if wireType != 2 { 8261 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType) 8262 } 8263 var msglen int 8264 for shift := uint(0); ; shift += 7 { 8265 if shift >= 64 { 8266 return ErrIntOverflowGenerated 8267 } 8268 if iNdEx >= l { 8269 return io.ErrUnexpectedEOF 8270 } 8271 b := dAtA[iNdEx] 8272 iNdEx++ 8273 msglen |= (int(b) & 0x7F) << shift 8274 if b < 0x80 { 8275 break 8276 } 8277 } 8278 if msglen < 0 { 8279 return ErrInvalidLengthGenerated 8280 } 8281 postIndex := iNdEx + msglen 8282 if postIndex > l { 8283 return io.ErrUnexpectedEOF 8284 } 8285 m.Rules = append(m.Rules, IngressRule{}) 8286 if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8287 return err 8288 } 8289 iNdEx = postIndex 8290 default: 8291 iNdEx = preIndex 8292 skippy, err := skipGenerated(dAtA[iNdEx:]) 8293 if err != nil { 8294 return err 8295 } 8296 if skippy < 0 { 8297 return ErrInvalidLengthGenerated 8298 } 8299 if (iNdEx + skippy) > l { 8300 return io.ErrUnexpectedEOF 8301 } 8302 iNdEx += skippy 8303 } 8304 } 8305 8306 if iNdEx > l { 8307 return io.ErrUnexpectedEOF 8308 } 8309 return nil 8310} 8311func (m *IngressStatus) Unmarshal(dAtA []byte) error { 8312 l := len(dAtA) 8313 iNdEx := 0 8314 for iNdEx < l { 8315 preIndex := iNdEx 8316 var wire uint64 8317 for shift := uint(0); ; shift += 7 { 8318 if shift >= 64 { 8319 return ErrIntOverflowGenerated 8320 } 8321 if iNdEx >= l { 8322 return io.ErrUnexpectedEOF 8323 } 8324 b := dAtA[iNdEx] 8325 iNdEx++ 8326 wire |= (uint64(b) & 0x7F) << shift 8327 if b < 0x80 { 8328 break 8329 } 8330 } 8331 fieldNum := int32(wire >> 3) 8332 wireType := int(wire & 0x7) 8333 if wireType == 4 { 8334 return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group") 8335 } 8336 if fieldNum <= 0 { 8337 return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire) 8338 } 8339 switch fieldNum { 8340 case 1: 8341 if wireType != 2 { 8342 return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType) 8343 } 8344 var msglen int 8345 for shift := uint(0); ; shift += 7 { 8346 if shift >= 64 { 8347 return ErrIntOverflowGenerated 8348 } 8349 if iNdEx >= l { 8350 return io.ErrUnexpectedEOF 8351 } 8352 b := dAtA[iNdEx] 8353 iNdEx++ 8354 msglen |= (int(b) & 0x7F) << shift 8355 if b < 0x80 { 8356 break 8357 } 8358 } 8359 if msglen < 0 { 8360 return ErrInvalidLengthGenerated 8361 } 8362 postIndex := iNdEx + msglen 8363 if postIndex > l { 8364 return io.ErrUnexpectedEOF 8365 } 8366 if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8367 return err 8368 } 8369 iNdEx = postIndex 8370 default: 8371 iNdEx = preIndex 8372 skippy, err := skipGenerated(dAtA[iNdEx:]) 8373 if err != nil { 8374 return err 8375 } 8376 if skippy < 0 { 8377 return ErrInvalidLengthGenerated 8378 } 8379 if (iNdEx + skippy) > l { 8380 return io.ErrUnexpectedEOF 8381 } 8382 iNdEx += skippy 8383 } 8384 } 8385 8386 if iNdEx > l { 8387 return io.ErrUnexpectedEOF 8388 } 8389 return nil 8390} 8391func (m *IngressTLS) Unmarshal(dAtA []byte) error { 8392 l := len(dAtA) 8393 iNdEx := 0 8394 for iNdEx < l { 8395 preIndex := iNdEx 8396 var wire uint64 8397 for shift := uint(0); ; shift += 7 { 8398 if shift >= 64 { 8399 return ErrIntOverflowGenerated 8400 } 8401 if iNdEx >= l { 8402 return io.ErrUnexpectedEOF 8403 } 8404 b := dAtA[iNdEx] 8405 iNdEx++ 8406 wire |= (uint64(b) & 0x7F) << shift 8407 if b < 0x80 { 8408 break 8409 } 8410 } 8411 fieldNum := int32(wire >> 3) 8412 wireType := int(wire & 0x7) 8413 if wireType == 4 { 8414 return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group") 8415 } 8416 if fieldNum <= 0 { 8417 return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire) 8418 } 8419 switch fieldNum { 8420 case 1: 8421 if wireType != 2 { 8422 return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType) 8423 } 8424 var stringLen uint64 8425 for shift := uint(0); ; shift += 7 { 8426 if shift >= 64 { 8427 return ErrIntOverflowGenerated 8428 } 8429 if iNdEx >= l { 8430 return io.ErrUnexpectedEOF 8431 } 8432 b := dAtA[iNdEx] 8433 iNdEx++ 8434 stringLen |= (uint64(b) & 0x7F) << shift 8435 if b < 0x80 { 8436 break 8437 } 8438 } 8439 intStringLen := int(stringLen) 8440 if intStringLen < 0 { 8441 return ErrInvalidLengthGenerated 8442 } 8443 postIndex := iNdEx + intStringLen 8444 if postIndex > l { 8445 return io.ErrUnexpectedEOF 8446 } 8447 m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex])) 8448 iNdEx = postIndex 8449 case 2: 8450 if wireType != 2 { 8451 return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType) 8452 } 8453 var stringLen uint64 8454 for shift := uint(0); ; shift += 7 { 8455 if shift >= 64 { 8456 return ErrIntOverflowGenerated 8457 } 8458 if iNdEx >= l { 8459 return io.ErrUnexpectedEOF 8460 } 8461 b := dAtA[iNdEx] 8462 iNdEx++ 8463 stringLen |= (uint64(b) & 0x7F) << shift 8464 if b < 0x80 { 8465 break 8466 } 8467 } 8468 intStringLen := int(stringLen) 8469 if intStringLen < 0 { 8470 return ErrInvalidLengthGenerated 8471 } 8472 postIndex := iNdEx + intStringLen 8473 if postIndex > l { 8474 return io.ErrUnexpectedEOF 8475 } 8476 m.SecretName = string(dAtA[iNdEx:postIndex]) 8477 iNdEx = postIndex 8478 default: 8479 iNdEx = preIndex 8480 skippy, err := skipGenerated(dAtA[iNdEx:]) 8481 if err != nil { 8482 return err 8483 } 8484 if skippy < 0 { 8485 return ErrInvalidLengthGenerated 8486 } 8487 if (iNdEx + skippy) > l { 8488 return io.ErrUnexpectedEOF 8489 } 8490 iNdEx += skippy 8491 } 8492 } 8493 8494 if iNdEx > l { 8495 return io.ErrUnexpectedEOF 8496 } 8497 return nil 8498} 8499func (m *NetworkPolicy) Unmarshal(dAtA []byte) error { 8500 l := len(dAtA) 8501 iNdEx := 0 8502 for iNdEx < l { 8503 preIndex := iNdEx 8504 var wire uint64 8505 for shift := uint(0); ; shift += 7 { 8506 if shift >= 64 { 8507 return ErrIntOverflowGenerated 8508 } 8509 if iNdEx >= l { 8510 return io.ErrUnexpectedEOF 8511 } 8512 b := dAtA[iNdEx] 8513 iNdEx++ 8514 wire |= (uint64(b) & 0x7F) << shift 8515 if b < 0x80 { 8516 break 8517 } 8518 } 8519 fieldNum := int32(wire >> 3) 8520 wireType := int(wire & 0x7) 8521 if wireType == 4 { 8522 return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group") 8523 } 8524 if fieldNum <= 0 { 8525 return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire) 8526 } 8527 switch fieldNum { 8528 case 1: 8529 if wireType != 2 { 8530 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 8531 } 8532 var msglen int 8533 for shift := uint(0); ; shift += 7 { 8534 if shift >= 64 { 8535 return ErrIntOverflowGenerated 8536 } 8537 if iNdEx >= l { 8538 return io.ErrUnexpectedEOF 8539 } 8540 b := dAtA[iNdEx] 8541 iNdEx++ 8542 msglen |= (int(b) & 0x7F) << shift 8543 if b < 0x80 { 8544 break 8545 } 8546 } 8547 if msglen < 0 { 8548 return ErrInvalidLengthGenerated 8549 } 8550 postIndex := iNdEx + msglen 8551 if postIndex > l { 8552 return io.ErrUnexpectedEOF 8553 } 8554 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8555 return err 8556 } 8557 iNdEx = postIndex 8558 case 2: 8559 if wireType != 2 { 8560 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 8561 } 8562 var msglen int 8563 for shift := uint(0); ; shift += 7 { 8564 if shift >= 64 { 8565 return ErrIntOverflowGenerated 8566 } 8567 if iNdEx >= l { 8568 return io.ErrUnexpectedEOF 8569 } 8570 b := dAtA[iNdEx] 8571 iNdEx++ 8572 msglen |= (int(b) & 0x7F) << shift 8573 if b < 0x80 { 8574 break 8575 } 8576 } 8577 if msglen < 0 { 8578 return ErrInvalidLengthGenerated 8579 } 8580 postIndex := iNdEx + msglen 8581 if postIndex > l { 8582 return io.ErrUnexpectedEOF 8583 } 8584 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8585 return err 8586 } 8587 iNdEx = postIndex 8588 default: 8589 iNdEx = preIndex 8590 skippy, err := skipGenerated(dAtA[iNdEx:]) 8591 if err != nil { 8592 return err 8593 } 8594 if skippy < 0 { 8595 return ErrInvalidLengthGenerated 8596 } 8597 if (iNdEx + skippy) > l { 8598 return io.ErrUnexpectedEOF 8599 } 8600 iNdEx += skippy 8601 } 8602 } 8603 8604 if iNdEx > l { 8605 return io.ErrUnexpectedEOF 8606 } 8607 return nil 8608} 8609func (m *NetworkPolicyEgressRule) Unmarshal(dAtA []byte) error { 8610 l := len(dAtA) 8611 iNdEx := 0 8612 for iNdEx < l { 8613 preIndex := iNdEx 8614 var wire uint64 8615 for shift := uint(0); ; shift += 7 { 8616 if shift >= 64 { 8617 return ErrIntOverflowGenerated 8618 } 8619 if iNdEx >= l { 8620 return io.ErrUnexpectedEOF 8621 } 8622 b := dAtA[iNdEx] 8623 iNdEx++ 8624 wire |= (uint64(b) & 0x7F) << shift 8625 if b < 0x80 { 8626 break 8627 } 8628 } 8629 fieldNum := int32(wire >> 3) 8630 wireType := int(wire & 0x7) 8631 if wireType == 4 { 8632 return fmt.Errorf("proto: NetworkPolicyEgressRule: wiretype end group for non-group") 8633 } 8634 if fieldNum <= 0 { 8635 return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire) 8636 } 8637 switch fieldNum { 8638 case 1: 8639 if wireType != 2 { 8640 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType) 8641 } 8642 var msglen int 8643 for shift := uint(0); ; shift += 7 { 8644 if shift >= 64 { 8645 return ErrIntOverflowGenerated 8646 } 8647 if iNdEx >= l { 8648 return io.ErrUnexpectedEOF 8649 } 8650 b := dAtA[iNdEx] 8651 iNdEx++ 8652 msglen |= (int(b) & 0x7F) << shift 8653 if b < 0x80 { 8654 break 8655 } 8656 } 8657 if msglen < 0 { 8658 return ErrInvalidLengthGenerated 8659 } 8660 postIndex := iNdEx + msglen 8661 if postIndex > l { 8662 return io.ErrUnexpectedEOF 8663 } 8664 m.Ports = append(m.Ports, NetworkPolicyPort{}) 8665 if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8666 return err 8667 } 8668 iNdEx = postIndex 8669 case 2: 8670 if wireType != 2 { 8671 return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) 8672 } 8673 var msglen int 8674 for shift := uint(0); ; shift += 7 { 8675 if shift >= 64 { 8676 return ErrIntOverflowGenerated 8677 } 8678 if iNdEx >= l { 8679 return io.ErrUnexpectedEOF 8680 } 8681 b := dAtA[iNdEx] 8682 iNdEx++ 8683 msglen |= (int(b) & 0x7F) << shift 8684 if b < 0x80 { 8685 break 8686 } 8687 } 8688 if msglen < 0 { 8689 return ErrInvalidLengthGenerated 8690 } 8691 postIndex := iNdEx + msglen 8692 if postIndex > l { 8693 return io.ErrUnexpectedEOF 8694 } 8695 m.To = append(m.To, NetworkPolicyPeer{}) 8696 if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8697 return err 8698 } 8699 iNdEx = postIndex 8700 default: 8701 iNdEx = preIndex 8702 skippy, err := skipGenerated(dAtA[iNdEx:]) 8703 if err != nil { 8704 return err 8705 } 8706 if skippy < 0 { 8707 return ErrInvalidLengthGenerated 8708 } 8709 if (iNdEx + skippy) > l { 8710 return io.ErrUnexpectedEOF 8711 } 8712 iNdEx += skippy 8713 } 8714 } 8715 8716 if iNdEx > l { 8717 return io.ErrUnexpectedEOF 8718 } 8719 return nil 8720} 8721func (m *NetworkPolicyIngressRule) Unmarshal(dAtA []byte) error { 8722 l := len(dAtA) 8723 iNdEx := 0 8724 for iNdEx < l { 8725 preIndex := iNdEx 8726 var wire uint64 8727 for shift := uint(0); ; shift += 7 { 8728 if shift >= 64 { 8729 return ErrIntOverflowGenerated 8730 } 8731 if iNdEx >= l { 8732 return io.ErrUnexpectedEOF 8733 } 8734 b := dAtA[iNdEx] 8735 iNdEx++ 8736 wire |= (uint64(b) & 0x7F) << shift 8737 if b < 0x80 { 8738 break 8739 } 8740 } 8741 fieldNum := int32(wire >> 3) 8742 wireType := int(wire & 0x7) 8743 if wireType == 4 { 8744 return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group") 8745 } 8746 if fieldNum <= 0 { 8747 return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire) 8748 } 8749 switch fieldNum { 8750 case 1: 8751 if wireType != 2 { 8752 return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType) 8753 } 8754 var msglen int 8755 for shift := uint(0); ; shift += 7 { 8756 if shift >= 64 { 8757 return ErrIntOverflowGenerated 8758 } 8759 if iNdEx >= l { 8760 return io.ErrUnexpectedEOF 8761 } 8762 b := dAtA[iNdEx] 8763 iNdEx++ 8764 msglen |= (int(b) & 0x7F) << shift 8765 if b < 0x80 { 8766 break 8767 } 8768 } 8769 if msglen < 0 { 8770 return ErrInvalidLengthGenerated 8771 } 8772 postIndex := iNdEx + msglen 8773 if postIndex > l { 8774 return io.ErrUnexpectedEOF 8775 } 8776 m.Ports = append(m.Ports, NetworkPolicyPort{}) 8777 if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8778 return err 8779 } 8780 iNdEx = postIndex 8781 case 2: 8782 if wireType != 2 { 8783 return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) 8784 } 8785 var msglen int 8786 for shift := uint(0); ; shift += 7 { 8787 if shift >= 64 { 8788 return ErrIntOverflowGenerated 8789 } 8790 if iNdEx >= l { 8791 return io.ErrUnexpectedEOF 8792 } 8793 b := dAtA[iNdEx] 8794 iNdEx++ 8795 msglen |= (int(b) & 0x7F) << shift 8796 if b < 0x80 { 8797 break 8798 } 8799 } 8800 if msglen < 0 { 8801 return ErrInvalidLengthGenerated 8802 } 8803 postIndex := iNdEx + msglen 8804 if postIndex > l { 8805 return io.ErrUnexpectedEOF 8806 } 8807 m.From = append(m.From, NetworkPolicyPeer{}) 8808 if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8809 return err 8810 } 8811 iNdEx = postIndex 8812 default: 8813 iNdEx = preIndex 8814 skippy, err := skipGenerated(dAtA[iNdEx:]) 8815 if err != nil { 8816 return err 8817 } 8818 if skippy < 0 { 8819 return ErrInvalidLengthGenerated 8820 } 8821 if (iNdEx + skippy) > l { 8822 return io.ErrUnexpectedEOF 8823 } 8824 iNdEx += skippy 8825 } 8826 } 8827 8828 if iNdEx > l { 8829 return io.ErrUnexpectedEOF 8830 } 8831 return nil 8832} 8833func (m *NetworkPolicyList) Unmarshal(dAtA []byte) error { 8834 l := len(dAtA) 8835 iNdEx := 0 8836 for iNdEx < l { 8837 preIndex := iNdEx 8838 var wire uint64 8839 for shift := uint(0); ; shift += 7 { 8840 if shift >= 64 { 8841 return ErrIntOverflowGenerated 8842 } 8843 if iNdEx >= l { 8844 return io.ErrUnexpectedEOF 8845 } 8846 b := dAtA[iNdEx] 8847 iNdEx++ 8848 wire |= (uint64(b) & 0x7F) << shift 8849 if b < 0x80 { 8850 break 8851 } 8852 } 8853 fieldNum := int32(wire >> 3) 8854 wireType := int(wire & 0x7) 8855 if wireType == 4 { 8856 return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group") 8857 } 8858 if fieldNum <= 0 { 8859 return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire) 8860 } 8861 switch fieldNum { 8862 case 1: 8863 if wireType != 2 { 8864 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 8865 } 8866 var msglen int 8867 for shift := uint(0); ; shift += 7 { 8868 if shift >= 64 { 8869 return ErrIntOverflowGenerated 8870 } 8871 if iNdEx >= l { 8872 return io.ErrUnexpectedEOF 8873 } 8874 b := dAtA[iNdEx] 8875 iNdEx++ 8876 msglen |= (int(b) & 0x7F) << shift 8877 if b < 0x80 { 8878 break 8879 } 8880 } 8881 if msglen < 0 { 8882 return ErrInvalidLengthGenerated 8883 } 8884 postIndex := iNdEx + msglen 8885 if postIndex > l { 8886 return io.ErrUnexpectedEOF 8887 } 8888 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8889 return err 8890 } 8891 iNdEx = postIndex 8892 case 2: 8893 if wireType != 2 { 8894 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 8895 } 8896 var msglen int 8897 for shift := uint(0); ; shift += 7 { 8898 if shift >= 64 { 8899 return ErrIntOverflowGenerated 8900 } 8901 if iNdEx >= l { 8902 return io.ErrUnexpectedEOF 8903 } 8904 b := dAtA[iNdEx] 8905 iNdEx++ 8906 msglen |= (int(b) & 0x7F) << shift 8907 if b < 0x80 { 8908 break 8909 } 8910 } 8911 if msglen < 0 { 8912 return ErrInvalidLengthGenerated 8913 } 8914 postIndex := iNdEx + msglen 8915 if postIndex > l { 8916 return io.ErrUnexpectedEOF 8917 } 8918 m.Items = append(m.Items, NetworkPolicy{}) 8919 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8920 return err 8921 } 8922 iNdEx = postIndex 8923 default: 8924 iNdEx = preIndex 8925 skippy, err := skipGenerated(dAtA[iNdEx:]) 8926 if err != nil { 8927 return err 8928 } 8929 if skippy < 0 { 8930 return ErrInvalidLengthGenerated 8931 } 8932 if (iNdEx + skippy) > l { 8933 return io.ErrUnexpectedEOF 8934 } 8935 iNdEx += skippy 8936 } 8937 } 8938 8939 if iNdEx > l { 8940 return io.ErrUnexpectedEOF 8941 } 8942 return nil 8943} 8944func (m *NetworkPolicyPeer) Unmarshal(dAtA []byte) error { 8945 l := len(dAtA) 8946 iNdEx := 0 8947 for iNdEx < l { 8948 preIndex := iNdEx 8949 var wire uint64 8950 for shift := uint(0); ; shift += 7 { 8951 if shift >= 64 { 8952 return ErrIntOverflowGenerated 8953 } 8954 if iNdEx >= l { 8955 return io.ErrUnexpectedEOF 8956 } 8957 b := dAtA[iNdEx] 8958 iNdEx++ 8959 wire |= (uint64(b) & 0x7F) << shift 8960 if b < 0x80 { 8961 break 8962 } 8963 } 8964 fieldNum := int32(wire >> 3) 8965 wireType := int(wire & 0x7) 8966 if wireType == 4 { 8967 return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group") 8968 } 8969 if fieldNum <= 0 { 8970 return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire) 8971 } 8972 switch fieldNum { 8973 case 1: 8974 if wireType != 2 { 8975 return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType) 8976 } 8977 var msglen int 8978 for shift := uint(0); ; shift += 7 { 8979 if shift >= 64 { 8980 return ErrIntOverflowGenerated 8981 } 8982 if iNdEx >= l { 8983 return io.ErrUnexpectedEOF 8984 } 8985 b := dAtA[iNdEx] 8986 iNdEx++ 8987 msglen |= (int(b) & 0x7F) << shift 8988 if b < 0x80 { 8989 break 8990 } 8991 } 8992 if msglen < 0 { 8993 return ErrInvalidLengthGenerated 8994 } 8995 postIndex := iNdEx + msglen 8996 if postIndex > l { 8997 return io.ErrUnexpectedEOF 8998 } 8999 if m.PodSelector == nil { 9000 m.PodSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 9001 } 9002 if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9003 return err 9004 } 9005 iNdEx = postIndex 9006 case 2: 9007 if wireType != 2 { 9008 return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType) 9009 } 9010 var msglen int 9011 for shift := uint(0); ; shift += 7 { 9012 if shift >= 64 { 9013 return ErrIntOverflowGenerated 9014 } 9015 if iNdEx >= l { 9016 return io.ErrUnexpectedEOF 9017 } 9018 b := dAtA[iNdEx] 9019 iNdEx++ 9020 msglen |= (int(b) & 0x7F) << shift 9021 if b < 0x80 { 9022 break 9023 } 9024 } 9025 if msglen < 0 { 9026 return ErrInvalidLengthGenerated 9027 } 9028 postIndex := iNdEx + msglen 9029 if postIndex > l { 9030 return io.ErrUnexpectedEOF 9031 } 9032 if m.NamespaceSelector == nil { 9033 m.NamespaceSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 9034 } 9035 if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9036 return err 9037 } 9038 iNdEx = postIndex 9039 case 3: 9040 if wireType != 2 { 9041 return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", wireType) 9042 } 9043 var msglen int 9044 for shift := uint(0); ; shift += 7 { 9045 if shift >= 64 { 9046 return ErrIntOverflowGenerated 9047 } 9048 if iNdEx >= l { 9049 return io.ErrUnexpectedEOF 9050 } 9051 b := dAtA[iNdEx] 9052 iNdEx++ 9053 msglen |= (int(b) & 0x7F) << shift 9054 if b < 0x80 { 9055 break 9056 } 9057 } 9058 if msglen < 0 { 9059 return ErrInvalidLengthGenerated 9060 } 9061 postIndex := iNdEx + msglen 9062 if postIndex > l { 9063 return io.ErrUnexpectedEOF 9064 } 9065 if m.IPBlock == nil { 9066 m.IPBlock = &IPBlock{} 9067 } 9068 if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9069 return err 9070 } 9071 iNdEx = postIndex 9072 default: 9073 iNdEx = preIndex 9074 skippy, err := skipGenerated(dAtA[iNdEx:]) 9075 if err != nil { 9076 return err 9077 } 9078 if skippy < 0 { 9079 return ErrInvalidLengthGenerated 9080 } 9081 if (iNdEx + skippy) > l { 9082 return io.ErrUnexpectedEOF 9083 } 9084 iNdEx += skippy 9085 } 9086 } 9087 9088 if iNdEx > l { 9089 return io.ErrUnexpectedEOF 9090 } 9091 return nil 9092} 9093func (m *NetworkPolicyPort) Unmarshal(dAtA []byte) error { 9094 l := len(dAtA) 9095 iNdEx := 0 9096 for iNdEx < l { 9097 preIndex := iNdEx 9098 var wire uint64 9099 for shift := uint(0); ; shift += 7 { 9100 if shift >= 64 { 9101 return ErrIntOverflowGenerated 9102 } 9103 if iNdEx >= l { 9104 return io.ErrUnexpectedEOF 9105 } 9106 b := dAtA[iNdEx] 9107 iNdEx++ 9108 wire |= (uint64(b) & 0x7F) << shift 9109 if b < 0x80 { 9110 break 9111 } 9112 } 9113 fieldNum := int32(wire >> 3) 9114 wireType := int(wire & 0x7) 9115 if wireType == 4 { 9116 return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group") 9117 } 9118 if fieldNum <= 0 { 9119 return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire) 9120 } 9121 switch fieldNum { 9122 case 1: 9123 if wireType != 2 { 9124 return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) 9125 } 9126 var stringLen uint64 9127 for shift := uint(0); ; shift += 7 { 9128 if shift >= 64 { 9129 return ErrIntOverflowGenerated 9130 } 9131 if iNdEx >= l { 9132 return io.ErrUnexpectedEOF 9133 } 9134 b := dAtA[iNdEx] 9135 iNdEx++ 9136 stringLen |= (uint64(b) & 0x7F) << shift 9137 if b < 0x80 { 9138 break 9139 } 9140 } 9141 intStringLen := int(stringLen) 9142 if intStringLen < 0 { 9143 return ErrInvalidLengthGenerated 9144 } 9145 postIndex := iNdEx + intStringLen 9146 if postIndex > l { 9147 return io.ErrUnexpectedEOF 9148 } 9149 s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex]) 9150 m.Protocol = &s 9151 iNdEx = postIndex 9152 case 2: 9153 if wireType != 2 { 9154 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) 9155 } 9156 var msglen int 9157 for shift := uint(0); ; shift += 7 { 9158 if shift >= 64 { 9159 return ErrIntOverflowGenerated 9160 } 9161 if iNdEx >= l { 9162 return io.ErrUnexpectedEOF 9163 } 9164 b := dAtA[iNdEx] 9165 iNdEx++ 9166 msglen |= (int(b) & 0x7F) << shift 9167 if b < 0x80 { 9168 break 9169 } 9170 } 9171 if msglen < 0 { 9172 return ErrInvalidLengthGenerated 9173 } 9174 postIndex := iNdEx + msglen 9175 if postIndex > l { 9176 return io.ErrUnexpectedEOF 9177 } 9178 if m.Port == nil { 9179 m.Port = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 9180 } 9181 if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9182 return err 9183 } 9184 iNdEx = postIndex 9185 default: 9186 iNdEx = preIndex 9187 skippy, err := skipGenerated(dAtA[iNdEx:]) 9188 if err != nil { 9189 return err 9190 } 9191 if skippy < 0 { 9192 return ErrInvalidLengthGenerated 9193 } 9194 if (iNdEx + skippy) > l { 9195 return io.ErrUnexpectedEOF 9196 } 9197 iNdEx += skippy 9198 } 9199 } 9200 9201 if iNdEx > l { 9202 return io.ErrUnexpectedEOF 9203 } 9204 return nil 9205} 9206func (m *NetworkPolicySpec) Unmarshal(dAtA []byte) error { 9207 l := len(dAtA) 9208 iNdEx := 0 9209 for iNdEx < l { 9210 preIndex := iNdEx 9211 var wire uint64 9212 for shift := uint(0); ; shift += 7 { 9213 if shift >= 64 { 9214 return ErrIntOverflowGenerated 9215 } 9216 if iNdEx >= l { 9217 return io.ErrUnexpectedEOF 9218 } 9219 b := dAtA[iNdEx] 9220 iNdEx++ 9221 wire |= (uint64(b) & 0x7F) << shift 9222 if b < 0x80 { 9223 break 9224 } 9225 } 9226 fieldNum := int32(wire >> 3) 9227 wireType := int(wire & 0x7) 9228 if wireType == 4 { 9229 return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group") 9230 } 9231 if fieldNum <= 0 { 9232 return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire) 9233 } 9234 switch fieldNum { 9235 case 1: 9236 if wireType != 2 { 9237 return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType) 9238 } 9239 var msglen int 9240 for shift := uint(0); ; shift += 7 { 9241 if shift >= 64 { 9242 return ErrIntOverflowGenerated 9243 } 9244 if iNdEx >= l { 9245 return io.ErrUnexpectedEOF 9246 } 9247 b := dAtA[iNdEx] 9248 iNdEx++ 9249 msglen |= (int(b) & 0x7F) << shift 9250 if b < 0x80 { 9251 break 9252 } 9253 } 9254 if msglen < 0 { 9255 return ErrInvalidLengthGenerated 9256 } 9257 postIndex := iNdEx + msglen 9258 if postIndex > l { 9259 return io.ErrUnexpectedEOF 9260 } 9261 if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9262 return err 9263 } 9264 iNdEx = postIndex 9265 case 2: 9266 if wireType != 2 { 9267 return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType) 9268 } 9269 var msglen int 9270 for shift := uint(0); ; shift += 7 { 9271 if shift >= 64 { 9272 return ErrIntOverflowGenerated 9273 } 9274 if iNdEx >= l { 9275 return io.ErrUnexpectedEOF 9276 } 9277 b := dAtA[iNdEx] 9278 iNdEx++ 9279 msglen |= (int(b) & 0x7F) << shift 9280 if b < 0x80 { 9281 break 9282 } 9283 } 9284 if msglen < 0 { 9285 return ErrInvalidLengthGenerated 9286 } 9287 postIndex := iNdEx + msglen 9288 if postIndex > l { 9289 return io.ErrUnexpectedEOF 9290 } 9291 m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{}) 9292 if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9293 return err 9294 } 9295 iNdEx = postIndex 9296 case 3: 9297 if wireType != 2 { 9298 return fmt.Errorf("proto: wrong wireType = %d for field Egress", wireType) 9299 } 9300 var msglen int 9301 for shift := uint(0); ; shift += 7 { 9302 if shift >= 64 { 9303 return ErrIntOverflowGenerated 9304 } 9305 if iNdEx >= l { 9306 return io.ErrUnexpectedEOF 9307 } 9308 b := dAtA[iNdEx] 9309 iNdEx++ 9310 msglen |= (int(b) & 0x7F) << shift 9311 if b < 0x80 { 9312 break 9313 } 9314 } 9315 if msglen < 0 { 9316 return ErrInvalidLengthGenerated 9317 } 9318 postIndex := iNdEx + msglen 9319 if postIndex > l { 9320 return io.ErrUnexpectedEOF 9321 } 9322 m.Egress = append(m.Egress, NetworkPolicyEgressRule{}) 9323 if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9324 return err 9325 } 9326 iNdEx = postIndex 9327 case 4: 9328 if wireType != 2 { 9329 return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", wireType) 9330 } 9331 var stringLen uint64 9332 for shift := uint(0); ; shift += 7 { 9333 if shift >= 64 { 9334 return ErrIntOverflowGenerated 9335 } 9336 if iNdEx >= l { 9337 return io.ErrUnexpectedEOF 9338 } 9339 b := dAtA[iNdEx] 9340 iNdEx++ 9341 stringLen |= (uint64(b) & 0x7F) << shift 9342 if b < 0x80 { 9343 break 9344 } 9345 } 9346 intStringLen := int(stringLen) 9347 if intStringLen < 0 { 9348 return ErrInvalidLengthGenerated 9349 } 9350 postIndex := iNdEx + intStringLen 9351 if postIndex > l { 9352 return io.ErrUnexpectedEOF 9353 } 9354 m.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex])) 9355 iNdEx = postIndex 9356 default: 9357 iNdEx = preIndex 9358 skippy, err := skipGenerated(dAtA[iNdEx:]) 9359 if err != nil { 9360 return err 9361 } 9362 if skippy < 0 { 9363 return ErrInvalidLengthGenerated 9364 } 9365 if (iNdEx + skippy) > l { 9366 return io.ErrUnexpectedEOF 9367 } 9368 iNdEx += skippy 9369 } 9370 } 9371 9372 if iNdEx > l { 9373 return io.ErrUnexpectedEOF 9374 } 9375 return nil 9376} 9377func (m *PodSecurityPolicy) Unmarshal(dAtA []byte) error { 9378 l := len(dAtA) 9379 iNdEx := 0 9380 for iNdEx < l { 9381 preIndex := iNdEx 9382 var wire uint64 9383 for shift := uint(0); ; shift += 7 { 9384 if shift >= 64 { 9385 return ErrIntOverflowGenerated 9386 } 9387 if iNdEx >= l { 9388 return io.ErrUnexpectedEOF 9389 } 9390 b := dAtA[iNdEx] 9391 iNdEx++ 9392 wire |= (uint64(b) & 0x7F) << shift 9393 if b < 0x80 { 9394 break 9395 } 9396 } 9397 fieldNum := int32(wire >> 3) 9398 wireType := int(wire & 0x7) 9399 if wireType == 4 { 9400 return fmt.Errorf("proto: PodSecurityPolicy: wiretype end group for non-group") 9401 } 9402 if fieldNum <= 0 { 9403 return fmt.Errorf("proto: PodSecurityPolicy: illegal tag %d (wire type %d)", fieldNum, wire) 9404 } 9405 switch fieldNum { 9406 case 1: 9407 if wireType != 2 { 9408 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 9409 } 9410 var msglen int 9411 for shift := uint(0); ; shift += 7 { 9412 if shift >= 64 { 9413 return ErrIntOverflowGenerated 9414 } 9415 if iNdEx >= l { 9416 return io.ErrUnexpectedEOF 9417 } 9418 b := dAtA[iNdEx] 9419 iNdEx++ 9420 msglen |= (int(b) & 0x7F) << shift 9421 if b < 0x80 { 9422 break 9423 } 9424 } 9425 if msglen < 0 { 9426 return ErrInvalidLengthGenerated 9427 } 9428 postIndex := iNdEx + msglen 9429 if postIndex > l { 9430 return io.ErrUnexpectedEOF 9431 } 9432 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9433 return err 9434 } 9435 iNdEx = postIndex 9436 case 2: 9437 if wireType != 2 { 9438 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 9439 } 9440 var msglen int 9441 for shift := uint(0); ; shift += 7 { 9442 if shift >= 64 { 9443 return ErrIntOverflowGenerated 9444 } 9445 if iNdEx >= l { 9446 return io.ErrUnexpectedEOF 9447 } 9448 b := dAtA[iNdEx] 9449 iNdEx++ 9450 msglen |= (int(b) & 0x7F) << shift 9451 if b < 0x80 { 9452 break 9453 } 9454 } 9455 if msglen < 0 { 9456 return ErrInvalidLengthGenerated 9457 } 9458 postIndex := iNdEx + msglen 9459 if postIndex > l { 9460 return io.ErrUnexpectedEOF 9461 } 9462 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9463 return err 9464 } 9465 iNdEx = postIndex 9466 default: 9467 iNdEx = preIndex 9468 skippy, err := skipGenerated(dAtA[iNdEx:]) 9469 if err != nil { 9470 return err 9471 } 9472 if skippy < 0 { 9473 return ErrInvalidLengthGenerated 9474 } 9475 if (iNdEx + skippy) > l { 9476 return io.ErrUnexpectedEOF 9477 } 9478 iNdEx += skippy 9479 } 9480 } 9481 9482 if iNdEx > l { 9483 return io.ErrUnexpectedEOF 9484 } 9485 return nil 9486} 9487func (m *PodSecurityPolicyList) Unmarshal(dAtA []byte) error { 9488 l := len(dAtA) 9489 iNdEx := 0 9490 for iNdEx < l { 9491 preIndex := iNdEx 9492 var wire uint64 9493 for shift := uint(0); ; shift += 7 { 9494 if shift >= 64 { 9495 return ErrIntOverflowGenerated 9496 } 9497 if iNdEx >= l { 9498 return io.ErrUnexpectedEOF 9499 } 9500 b := dAtA[iNdEx] 9501 iNdEx++ 9502 wire |= (uint64(b) & 0x7F) << shift 9503 if b < 0x80 { 9504 break 9505 } 9506 } 9507 fieldNum := int32(wire >> 3) 9508 wireType := int(wire & 0x7) 9509 if wireType == 4 { 9510 return fmt.Errorf("proto: PodSecurityPolicyList: wiretype end group for non-group") 9511 } 9512 if fieldNum <= 0 { 9513 return fmt.Errorf("proto: PodSecurityPolicyList: illegal tag %d (wire type %d)", fieldNum, wire) 9514 } 9515 switch fieldNum { 9516 case 1: 9517 if wireType != 2 { 9518 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 9519 } 9520 var msglen int 9521 for shift := uint(0); ; shift += 7 { 9522 if shift >= 64 { 9523 return ErrIntOverflowGenerated 9524 } 9525 if iNdEx >= l { 9526 return io.ErrUnexpectedEOF 9527 } 9528 b := dAtA[iNdEx] 9529 iNdEx++ 9530 msglen |= (int(b) & 0x7F) << shift 9531 if b < 0x80 { 9532 break 9533 } 9534 } 9535 if msglen < 0 { 9536 return ErrInvalidLengthGenerated 9537 } 9538 postIndex := iNdEx + msglen 9539 if postIndex > l { 9540 return io.ErrUnexpectedEOF 9541 } 9542 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9543 return err 9544 } 9545 iNdEx = postIndex 9546 case 2: 9547 if wireType != 2 { 9548 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 9549 } 9550 var msglen int 9551 for shift := uint(0); ; shift += 7 { 9552 if shift >= 64 { 9553 return ErrIntOverflowGenerated 9554 } 9555 if iNdEx >= l { 9556 return io.ErrUnexpectedEOF 9557 } 9558 b := dAtA[iNdEx] 9559 iNdEx++ 9560 msglen |= (int(b) & 0x7F) << shift 9561 if b < 0x80 { 9562 break 9563 } 9564 } 9565 if msglen < 0 { 9566 return ErrInvalidLengthGenerated 9567 } 9568 postIndex := iNdEx + msglen 9569 if postIndex > l { 9570 return io.ErrUnexpectedEOF 9571 } 9572 m.Items = append(m.Items, PodSecurityPolicy{}) 9573 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9574 return err 9575 } 9576 iNdEx = postIndex 9577 default: 9578 iNdEx = preIndex 9579 skippy, err := skipGenerated(dAtA[iNdEx:]) 9580 if err != nil { 9581 return err 9582 } 9583 if skippy < 0 { 9584 return ErrInvalidLengthGenerated 9585 } 9586 if (iNdEx + skippy) > l { 9587 return io.ErrUnexpectedEOF 9588 } 9589 iNdEx += skippy 9590 } 9591 } 9592 9593 if iNdEx > l { 9594 return io.ErrUnexpectedEOF 9595 } 9596 return nil 9597} 9598func (m *PodSecurityPolicySpec) Unmarshal(dAtA []byte) error { 9599 l := len(dAtA) 9600 iNdEx := 0 9601 for iNdEx < l { 9602 preIndex := iNdEx 9603 var wire uint64 9604 for shift := uint(0); ; shift += 7 { 9605 if shift >= 64 { 9606 return ErrIntOverflowGenerated 9607 } 9608 if iNdEx >= l { 9609 return io.ErrUnexpectedEOF 9610 } 9611 b := dAtA[iNdEx] 9612 iNdEx++ 9613 wire |= (uint64(b) & 0x7F) << shift 9614 if b < 0x80 { 9615 break 9616 } 9617 } 9618 fieldNum := int32(wire >> 3) 9619 wireType := int(wire & 0x7) 9620 if wireType == 4 { 9621 return fmt.Errorf("proto: PodSecurityPolicySpec: wiretype end group for non-group") 9622 } 9623 if fieldNum <= 0 { 9624 return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire) 9625 } 9626 switch fieldNum { 9627 case 1: 9628 if wireType != 0 { 9629 return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType) 9630 } 9631 var v int 9632 for shift := uint(0); ; shift += 7 { 9633 if shift >= 64 { 9634 return ErrIntOverflowGenerated 9635 } 9636 if iNdEx >= l { 9637 return io.ErrUnexpectedEOF 9638 } 9639 b := dAtA[iNdEx] 9640 iNdEx++ 9641 v |= (int(b) & 0x7F) << shift 9642 if b < 0x80 { 9643 break 9644 } 9645 } 9646 m.Privileged = bool(v != 0) 9647 case 2: 9648 if wireType != 2 { 9649 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", wireType) 9650 } 9651 var stringLen uint64 9652 for shift := uint(0); ; shift += 7 { 9653 if shift >= 64 { 9654 return ErrIntOverflowGenerated 9655 } 9656 if iNdEx >= l { 9657 return io.ErrUnexpectedEOF 9658 } 9659 b := dAtA[iNdEx] 9660 iNdEx++ 9661 stringLen |= (uint64(b) & 0x7F) << shift 9662 if b < 0x80 { 9663 break 9664 } 9665 } 9666 intStringLen := int(stringLen) 9667 if intStringLen < 0 { 9668 return ErrInvalidLengthGenerated 9669 } 9670 postIndex := iNdEx + intStringLen 9671 if postIndex > l { 9672 return io.ErrUnexpectedEOF 9673 } 9674 m.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) 9675 iNdEx = postIndex 9676 case 3: 9677 if wireType != 2 { 9678 return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", wireType) 9679 } 9680 var stringLen uint64 9681 for shift := uint(0); ; shift += 7 { 9682 if shift >= 64 { 9683 return ErrIntOverflowGenerated 9684 } 9685 if iNdEx >= l { 9686 return io.ErrUnexpectedEOF 9687 } 9688 b := dAtA[iNdEx] 9689 iNdEx++ 9690 stringLen |= (uint64(b) & 0x7F) << shift 9691 if b < 0x80 { 9692 break 9693 } 9694 } 9695 intStringLen := int(stringLen) 9696 if intStringLen < 0 { 9697 return ErrInvalidLengthGenerated 9698 } 9699 postIndex := iNdEx + intStringLen 9700 if postIndex > l { 9701 return io.ErrUnexpectedEOF 9702 } 9703 m.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) 9704 iNdEx = postIndex 9705 case 4: 9706 if wireType != 2 { 9707 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", wireType) 9708 } 9709 var stringLen uint64 9710 for shift := uint(0); ; shift += 7 { 9711 if shift >= 64 { 9712 return ErrIntOverflowGenerated 9713 } 9714 if iNdEx >= l { 9715 return io.ErrUnexpectedEOF 9716 } 9717 b := dAtA[iNdEx] 9718 iNdEx++ 9719 stringLen |= (uint64(b) & 0x7F) << shift 9720 if b < 0x80 { 9721 break 9722 } 9723 } 9724 intStringLen := int(stringLen) 9725 if intStringLen < 0 { 9726 return ErrInvalidLengthGenerated 9727 } 9728 postIndex := iNdEx + intStringLen 9729 if postIndex > l { 9730 return io.ErrUnexpectedEOF 9731 } 9732 m.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) 9733 iNdEx = postIndex 9734 case 5: 9735 if wireType != 2 { 9736 return fmt.Errorf("proto: wrong wireType = %d for field Volumes", wireType) 9737 } 9738 var stringLen uint64 9739 for shift := uint(0); ; shift += 7 { 9740 if shift >= 64 { 9741 return ErrIntOverflowGenerated 9742 } 9743 if iNdEx >= l { 9744 return io.ErrUnexpectedEOF 9745 } 9746 b := dAtA[iNdEx] 9747 iNdEx++ 9748 stringLen |= (uint64(b) & 0x7F) << shift 9749 if b < 0x80 { 9750 break 9751 } 9752 } 9753 intStringLen := int(stringLen) 9754 if intStringLen < 0 { 9755 return ErrInvalidLengthGenerated 9756 } 9757 postIndex := iNdEx + intStringLen 9758 if postIndex > l { 9759 return io.ErrUnexpectedEOF 9760 } 9761 m.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex])) 9762 iNdEx = postIndex 9763 case 6: 9764 if wireType != 0 { 9765 return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", wireType) 9766 } 9767 var v 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 v |= (int(b) & 0x7F) << shift 9778 if b < 0x80 { 9779 break 9780 } 9781 } 9782 m.HostNetwork = bool(v != 0) 9783 case 7: 9784 if wireType != 2 { 9785 return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", wireType) 9786 } 9787 var msglen int 9788 for shift := uint(0); ; shift += 7 { 9789 if shift >= 64 { 9790 return ErrIntOverflowGenerated 9791 } 9792 if iNdEx >= l { 9793 return io.ErrUnexpectedEOF 9794 } 9795 b := dAtA[iNdEx] 9796 iNdEx++ 9797 msglen |= (int(b) & 0x7F) << shift 9798 if b < 0x80 { 9799 break 9800 } 9801 } 9802 if msglen < 0 { 9803 return ErrInvalidLengthGenerated 9804 } 9805 postIndex := iNdEx + msglen 9806 if postIndex > l { 9807 return io.ErrUnexpectedEOF 9808 } 9809 m.HostPorts = append(m.HostPorts, HostPortRange{}) 9810 if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9811 return err 9812 } 9813 iNdEx = postIndex 9814 case 8: 9815 if wireType != 0 { 9816 return fmt.Errorf("proto: wrong wireType = %d for field HostPID", wireType) 9817 } 9818 var v int 9819 for shift := uint(0); ; shift += 7 { 9820 if shift >= 64 { 9821 return ErrIntOverflowGenerated 9822 } 9823 if iNdEx >= l { 9824 return io.ErrUnexpectedEOF 9825 } 9826 b := dAtA[iNdEx] 9827 iNdEx++ 9828 v |= (int(b) & 0x7F) << shift 9829 if b < 0x80 { 9830 break 9831 } 9832 } 9833 m.HostPID = bool(v != 0) 9834 case 9: 9835 if wireType != 0 { 9836 return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", wireType) 9837 } 9838 var v int 9839 for shift := uint(0); ; shift += 7 { 9840 if shift >= 64 { 9841 return ErrIntOverflowGenerated 9842 } 9843 if iNdEx >= l { 9844 return io.ErrUnexpectedEOF 9845 } 9846 b := dAtA[iNdEx] 9847 iNdEx++ 9848 v |= (int(b) & 0x7F) << shift 9849 if b < 0x80 { 9850 break 9851 } 9852 } 9853 m.HostIPC = bool(v != 0) 9854 case 10: 9855 if wireType != 2 { 9856 return fmt.Errorf("proto: wrong wireType = %d for field SELinux", wireType) 9857 } 9858 var msglen int 9859 for shift := uint(0); ; shift += 7 { 9860 if shift >= 64 { 9861 return ErrIntOverflowGenerated 9862 } 9863 if iNdEx >= l { 9864 return io.ErrUnexpectedEOF 9865 } 9866 b := dAtA[iNdEx] 9867 iNdEx++ 9868 msglen |= (int(b) & 0x7F) << shift 9869 if b < 0x80 { 9870 break 9871 } 9872 } 9873 if msglen < 0 { 9874 return ErrInvalidLengthGenerated 9875 } 9876 postIndex := iNdEx + msglen 9877 if postIndex > l { 9878 return io.ErrUnexpectedEOF 9879 } 9880 if err := m.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9881 return err 9882 } 9883 iNdEx = postIndex 9884 case 11: 9885 if wireType != 2 { 9886 return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", wireType) 9887 } 9888 var msglen int 9889 for shift := uint(0); ; shift += 7 { 9890 if shift >= 64 { 9891 return ErrIntOverflowGenerated 9892 } 9893 if iNdEx >= l { 9894 return io.ErrUnexpectedEOF 9895 } 9896 b := dAtA[iNdEx] 9897 iNdEx++ 9898 msglen |= (int(b) & 0x7F) << shift 9899 if b < 0x80 { 9900 break 9901 } 9902 } 9903 if msglen < 0 { 9904 return ErrInvalidLengthGenerated 9905 } 9906 postIndex := iNdEx + msglen 9907 if postIndex > l { 9908 return io.ErrUnexpectedEOF 9909 } 9910 if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9911 return err 9912 } 9913 iNdEx = postIndex 9914 case 12: 9915 if wireType != 2 { 9916 return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType) 9917 } 9918 var msglen int 9919 for shift := uint(0); ; shift += 7 { 9920 if shift >= 64 { 9921 return ErrIntOverflowGenerated 9922 } 9923 if iNdEx >= l { 9924 return io.ErrUnexpectedEOF 9925 } 9926 b := dAtA[iNdEx] 9927 iNdEx++ 9928 msglen |= (int(b) & 0x7F) << shift 9929 if b < 0x80 { 9930 break 9931 } 9932 } 9933 if msglen < 0 { 9934 return ErrInvalidLengthGenerated 9935 } 9936 postIndex := iNdEx + msglen 9937 if postIndex > l { 9938 return io.ErrUnexpectedEOF 9939 } 9940 if err := m.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9941 return err 9942 } 9943 iNdEx = postIndex 9944 case 13: 9945 if wireType != 2 { 9946 return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", wireType) 9947 } 9948 var msglen int 9949 for shift := uint(0); ; shift += 7 { 9950 if shift >= 64 { 9951 return ErrIntOverflowGenerated 9952 } 9953 if iNdEx >= l { 9954 return io.ErrUnexpectedEOF 9955 } 9956 b := dAtA[iNdEx] 9957 iNdEx++ 9958 msglen |= (int(b) & 0x7F) << shift 9959 if b < 0x80 { 9960 break 9961 } 9962 } 9963 if msglen < 0 { 9964 return ErrInvalidLengthGenerated 9965 } 9966 postIndex := iNdEx + msglen 9967 if postIndex > l { 9968 return io.ErrUnexpectedEOF 9969 } 9970 if err := m.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9971 return err 9972 } 9973 iNdEx = postIndex 9974 case 14: 9975 if wireType != 0 { 9976 return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", wireType) 9977 } 9978 var v int 9979 for shift := uint(0); ; shift += 7 { 9980 if shift >= 64 { 9981 return ErrIntOverflowGenerated 9982 } 9983 if iNdEx >= l { 9984 return io.ErrUnexpectedEOF 9985 } 9986 b := dAtA[iNdEx] 9987 iNdEx++ 9988 v |= (int(b) & 0x7F) << shift 9989 if b < 0x80 { 9990 break 9991 } 9992 } 9993 m.ReadOnlyRootFilesystem = bool(v != 0) 9994 case 15: 9995 if wireType != 0 { 9996 return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType) 9997 } 9998 var v int 9999 for shift := uint(0); ; shift += 7 { 10000 if shift >= 64 { 10001 return ErrIntOverflowGenerated 10002 } 10003 if iNdEx >= l { 10004 return io.ErrUnexpectedEOF 10005 } 10006 b := dAtA[iNdEx] 10007 iNdEx++ 10008 v |= (int(b) & 0x7F) << shift 10009 if b < 0x80 { 10010 break 10011 } 10012 } 10013 b := bool(v != 0) 10014 m.DefaultAllowPrivilegeEscalation = &b 10015 case 16: 10016 if wireType != 0 { 10017 return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType) 10018 } 10019 var v int 10020 for shift := uint(0); ; shift += 7 { 10021 if shift >= 64 { 10022 return ErrIntOverflowGenerated 10023 } 10024 if iNdEx >= l { 10025 return io.ErrUnexpectedEOF 10026 } 10027 b := dAtA[iNdEx] 10028 iNdEx++ 10029 v |= (int(b) & 0x7F) << shift 10030 if b < 0x80 { 10031 break 10032 } 10033 } 10034 b := bool(v != 0) 10035 m.AllowPrivilegeEscalation = &b 10036 case 17: 10037 if wireType != 2 { 10038 return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", wireType) 10039 } 10040 var msglen int 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 msglen |= (int(b) & 0x7F) << shift 10051 if b < 0x80 { 10052 break 10053 } 10054 } 10055 if msglen < 0 { 10056 return ErrInvalidLengthGenerated 10057 } 10058 postIndex := iNdEx + msglen 10059 if postIndex > l { 10060 return io.ErrUnexpectedEOF 10061 } 10062 m.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{}) 10063 if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10064 return err 10065 } 10066 iNdEx = postIndex 10067 case 18: 10068 if wireType != 2 { 10069 return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", wireType) 10070 } 10071 var msglen int 10072 for shift := uint(0); ; shift += 7 { 10073 if shift >= 64 { 10074 return ErrIntOverflowGenerated 10075 } 10076 if iNdEx >= l { 10077 return io.ErrUnexpectedEOF 10078 } 10079 b := dAtA[iNdEx] 10080 iNdEx++ 10081 msglen |= (int(b) & 0x7F) << shift 10082 if b < 0x80 { 10083 break 10084 } 10085 } 10086 if msglen < 0 { 10087 return ErrInvalidLengthGenerated 10088 } 10089 postIndex := iNdEx + msglen 10090 if postIndex > l { 10091 return io.ErrUnexpectedEOF 10092 } 10093 m.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{}) 10094 if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10095 return err 10096 } 10097 iNdEx = postIndex 10098 case 19: 10099 if wireType != 2 { 10100 return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", wireType) 10101 } 10102 var stringLen uint64 10103 for shift := uint(0); ; shift += 7 { 10104 if shift >= 64 { 10105 return ErrIntOverflowGenerated 10106 } 10107 if iNdEx >= l { 10108 return io.ErrUnexpectedEOF 10109 } 10110 b := dAtA[iNdEx] 10111 iNdEx++ 10112 stringLen |= (uint64(b) & 0x7F) << shift 10113 if b < 0x80 { 10114 break 10115 } 10116 } 10117 intStringLen := int(stringLen) 10118 if intStringLen < 0 { 10119 return ErrInvalidLengthGenerated 10120 } 10121 postIndex := iNdEx + intStringLen 10122 if postIndex > l { 10123 return io.ErrUnexpectedEOF 10124 } 10125 m.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex])) 10126 iNdEx = postIndex 10127 case 20: 10128 if wireType != 2 { 10129 return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", wireType) 10130 } 10131 var stringLen uint64 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 stringLen |= (uint64(b) & 0x7F) << shift 10142 if b < 0x80 { 10143 break 10144 } 10145 } 10146 intStringLen := int(stringLen) 10147 if intStringLen < 0 { 10148 return ErrInvalidLengthGenerated 10149 } 10150 postIndex := iNdEx + intStringLen 10151 if postIndex > l { 10152 return io.ErrUnexpectedEOF 10153 } 10154 m.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex])) 10155 iNdEx = postIndex 10156 case 21: 10157 if wireType != 2 { 10158 return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", wireType) 10159 } 10160 var stringLen uint64 10161 for shift := uint(0); ; shift += 7 { 10162 if shift >= 64 { 10163 return ErrIntOverflowGenerated 10164 } 10165 if iNdEx >= l { 10166 return io.ErrUnexpectedEOF 10167 } 10168 b := dAtA[iNdEx] 10169 iNdEx++ 10170 stringLen |= (uint64(b) & 0x7F) << shift 10171 if b < 0x80 { 10172 break 10173 } 10174 } 10175 intStringLen := int(stringLen) 10176 if intStringLen < 0 { 10177 return ErrInvalidLengthGenerated 10178 } 10179 postIndex := iNdEx + intStringLen 10180 if postIndex > l { 10181 return io.ErrUnexpectedEOF 10182 } 10183 m.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex])) 10184 iNdEx = postIndex 10185 case 22: 10186 if wireType != 2 { 10187 return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", wireType) 10188 } 10189 var msglen int 10190 for shift := uint(0); ; shift += 7 { 10191 if shift >= 64 { 10192 return ErrIntOverflowGenerated 10193 } 10194 if iNdEx >= l { 10195 return io.ErrUnexpectedEOF 10196 } 10197 b := dAtA[iNdEx] 10198 iNdEx++ 10199 msglen |= (int(b) & 0x7F) << shift 10200 if b < 0x80 { 10201 break 10202 } 10203 } 10204 if msglen < 0 { 10205 return ErrInvalidLengthGenerated 10206 } 10207 postIndex := iNdEx + msglen 10208 if postIndex > l { 10209 return io.ErrUnexpectedEOF 10210 } 10211 if m.RunAsGroup == nil { 10212 m.RunAsGroup = &RunAsGroupStrategyOptions{} 10213 } 10214 if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10215 return err 10216 } 10217 iNdEx = postIndex 10218 case 23: 10219 if wireType != 2 { 10220 return fmt.Errorf("proto: wrong wireType = %d for field AllowedCSIDrivers", wireType) 10221 } 10222 var msglen int 10223 for shift := uint(0); ; shift += 7 { 10224 if shift >= 64 { 10225 return ErrIntOverflowGenerated 10226 } 10227 if iNdEx >= l { 10228 return io.ErrUnexpectedEOF 10229 } 10230 b := dAtA[iNdEx] 10231 iNdEx++ 10232 msglen |= (int(b) & 0x7F) << shift 10233 if b < 0x80 { 10234 break 10235 } 10236 } 10237 if msglen < 0 { 10238 return ErrInvalidLengthGenerated 10239 } 10240 postIndex := iNdEx + msglen 10241 if postIndex > l { 10242 return io.ErrUnexpectedEOF 10243 } 10244 m.AllowedCSIDrivers = append(m.AllowedCSIDrivers, AllowedCSIDriver{}) 10245 if err := m.AllowedCSIDrivers[len(m.AllowedCSIDrivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10246 return err 10247 } 10248 iNdEx = postIndex 10249 case 24: 10250 if wireType != 2 { 10251 return fmt.Errorf("proto: wrong wireType = %d for field RuntimeClass", wireType) 10252 } 10253 var msglen int 10254 for shift := uint(0); ; shift += 7 { 10255 if shift >= 64 { 10256 return ErrIntOverflowGenerated 10257 } 10258 if iNdEx >= l { 10259 return io.ErrUnexpectedEOF 10260 } 10261 b := dAtA[iNdEx] 10262 iNdEx++ 10263 msglen |= (int(b) & 0x7F) << shift 10264 if b < 0x80 { 10265 break 10266 } 10267 } 10268 if msglen < 0 { 10269 return ErrInvalidLengthGenerated 10270 } 10271 postIndex := iNdEx + msglen 10272 if postIndex > l { 10273 return io.ErrUnexpectedEOF 10274 } 10275 if m.RuntimeClass == nil { 10276 m.RuntimeClass = &RuntimeClassStrategyOptions{} 10277 } 10278 if err := m.RuntimeClass.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10279 return err 10280 } 10281 iNdEx = postIndex 10282 default: 10283 iNdEx = preIndex 10284 skippy, err := skipGenerated(dAtA[iNdEx:]) 10285 if err != nil { 10286 return err 10287 } 10288 if skippy < 0 { 10289 return ErrInvalidLengthGenerated 10290 } 10291 if (iNdEx + skippy) > l { 10292 return io.ErrUnexpectedEOF 10293 } 10294 iNdEx += skippy 10295 } 10296 } 10297 10298 if iNdEx > l { 10299 return io.ErrUnexpectedEOF 10300 } 10301 return nil 10302} 10303func (m *ReplicaSet) Unmarshal(dAtA []byte) error { 10304 l := len(dAtA) 10305 iNdEx := 0 10306 for iNdEx < l { 10307 preIndex := iNdEx 10308 var wire uint64 10309 for shift := uint(0); ; shift += 7 { 10310 if shift >= 64 { 10311 return ErrIntOverflowGenerated 10312 } 10313 if iNdEx >= l { 10314 return io.ErrUnexpectedEOF 10315 } 10316 b := dAtA[iNdEx] 10317 iNdEx++ 10318 wire |= (uint64(b) & 0x7F) << shift 10319 if b < 0x80 { 10320 break 10321 } 10322 } 10323 fieldNum := int32(wire >> 3) 10324 wireType := int(wire & 0x7) 10325 if wireType == 4 { 10326 return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group") 10327 } 10328 if fieldNum <= 0 { 10329 return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire) 10330 } 10331 switch fieldNum { 10332 case 1: 10333 if wireType != 2 { 10334 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 10335 } 10336 var msglen int 10337 for shift := uint(0); ; shift += 7 { 10338 if shift >= 64 { 10339 return ErrIntOverflowGenerated 10340 } 10341 if iNdEx >= l { 10342 return io.ErrUnexpectedEOF 10343 } 10344 b := dAtA[iNdEx] 10345 iNdEx++ 10346 msglen |= (int(b) & 0x7F) << shift 10347 if b < 0x80 { 10348 break 10349 } 10350 } 10351 if msglen < 0 { 10352 return ErrInvalidLengthGenerated 10353 } 10354 postIndex := iNdEx + msglen 10355 if postIndex > l { 10356 return io.ErrUnexpectedEOF 10357 } 10358 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10359 return err 10360 } 10361 iNdEx = postIndex 10362 case 2: 10363 if wireType != 2 { 10364 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 10365 } 10366 var msglen int 10367 for shift := uint(0); ; shift += 7 { 10368 if shift >= 64 { 10369 return ErrIntOverflowGenerated 10370 } 10371 if iNdEx >= l { 10372 return io.ErrUnexpectedEOF 10373 } 10374 b := dAtA[iNdEx] 10375 iNdEx++ 10376 msglen |= (int(b) & 0x7F) << shift 10377 if b < 0x80 { 10378 break 10379 } 10380 } 10381 if msglen < 0 { 10382 return ErrInvalidLengthGenerated 10383 } 10384 postIndex := iNdEx + msglen 10385 if postIndex > l { 10386 return io.ErrUnexpectedEOF 10387 } 10388 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10389 return err 10390 } 10391 iNdEx = postIndex 10392 case 3: 10393 if wireType != 2 { 10394 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 10395 } 10396 var msglen int 10397 for shift := uint(0); ; shift += 7 { 10398 if shift >= 64 { 10399 return ErrIntOverflowGenerated 10400 } 10401 if iNdEx >= l { 10402 return io.ErrUnexpectedEOF 10403 } 10404 b := dAtA[iNdEx] 10405 iNdEx++ 10406 msglen |= (int(b) & 0x7F) << shift 10407 if b < 0x80 { 10408 break 10409 } 10410 } 10411 if msglen < 0 { 10412 return ErrInvalidLengthGenerated 10413 } 10414 postIndex := iNdEx + msglen 10415 if postIndex > l { 10416 return io.ErrUnexpectedEOF 10417 } 10418 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10419 return err 10420 } 10421 iNdEx = postIndex 10422 default: 10423 iNdEx = preIndex 10424 skippy, err := skipGenerated(dAtA[iNdEx:]) 10425 if err != nil { 10426 return err 10427 } 10428 if skippy < 0 { 10429 return ErrInvalidLengthGenerated 10430 } 10431 if (iNdEx + skippy) > l { 10432 return io.ErrUnexpectedEOF 10433 } 10434 iNdEx += skippy 10435 } 10436 } 10437 10438 if iNdEx > l { 10439 return io.ErrUnexpectedEOF 10440 } 10441 return nil 10442} 10443func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error { 10444 l := len(dAtA) 10445 iNdEx := 0 10446 for iNdEx < l { 10447 preIndex := iNdEx 10448 var wire uint64 10449 for shift := uint(0); ; shift += 7 { 10450 if shift >= 64 { 10451 return ErrIntOverflowGenerated 10452 } 10453 if iNdEx >= l { 10454 return io.ErrUnexpectedEOF 10455 } 10456 b := dAtA[iNdEx] 10457 iNdEx++ 10458 wire |= (uint64(b) & 0x7F) << shift 10459 if b < 0x80 { 10460 break 10461 } 10462 } 10463 fieldNum := int32(wire >> 3) 10464 wireType := int(wire & 0x7) 10465 if wireType == 4 { 10466 return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group") 10467 } 10468 if fieldNum <= 0 { 10469 return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) 10470 } 10471 switch fieldNum { 10472 case 1: 10473 if wireType != 2 { 10474 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 10475 } 10476 var stringLen uint64 10477 for shift := uint(0); ; shift += 7 { 10478 if shift >= 64 { 10479 return ErrIntOverflowGenerated 10480 } 10481 if iNdEx >= l { 10482 return io.ErrUnexpectedEOF 10483 } 10484 b := dAtA[iNdEx] 10485 iNdEx++ 10486 stringLen |= (uint64(b) & 0x7F) << shift 10487 if b < 0x80 { 10488 break 10489 } 10490 } 10491 intStringLen := int(stringLen) 10492 if intStringLen < 0 { 10493 return ErrInvalidLengthGenerated 10494 } 10495 postIndex := iNdEx + intStringLen 10496 if postIndex > l { 10497 return io.ErrUnexpectedEOF 10498 } 10499 m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex]) 10500 iNdEx = postIndex 10501 case 2: 10502 if wireType != 2 { 10503 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 10504 } 10505 var stringLen uint64 10506 for shift := uint(0); ; shift += 7 { 10507 if shift >= 64 { 10508 return ErrIntOverflowGenerated 10509 } 10510 if iNdEx >= l { 10511 return io.ErrUnexpectedEOF 10512 } 10513 b := dAtA[iNdEx] 10514 iNdEx++ 10515 stringLen |= (uint64(b) & 0x7F) << shift 10516 if b < 0x80 { 10517 break 10518 } 10519 } 10520 intStringLen := int(stringLen) 10521 if intStringLen < 0 { 10522 return ErrInvalidLengthGenerated 10523 } 10524 postIndex := iNdEx + intStringLen 10525 if postIndex > l { 10526 return io.ErrUnexpectedEOF 10527 } 10528 m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) 10529 iNdEx = postIndex 10530 case 3: 10531 if wireType != 2 { 10532 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) 10533 } 10534 var msglen int 10535 for shift := uint(0); ; shift += 7 { 10536 if shift >= 64 { 10537 return ErrIntOverflowGenerated 10538 } 10539 if iNdEx >= l { 10540 return io.ErrUnexpectedEOF 10541 } 10542 b := dAtA[iNdEx] 10543 iNdEx++ 10544 msglen |= (int(b) & 0x7F) << shift 10545 if b < 0x80 { 10546 break 10547 } 10548 } 10549 if msglen < 0 { 10550 return ErrInvalidLengthGenerated 10551 } 10552 postIndex := iNdEx + msglen 10553 if postIndex > l { 10554 return io.ErrUnexpectedEOF 10555 } 10556 if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10557 return err 10558 } 10559 iNdEx = postIndex 10560 case 4: 10561 if wireType != 2 { 10562 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) 10563 } 10564 var stringLen uint64 10565 for shift := uint(0); ; shift += 7 { 10566 if shift >= 64 { 10567 return ErrIntOverflowGenerated 10568 } 10569 if iNdEx >= l { 10570 return io.ErrUnexpectedEOF 10571 } 10572 b := dAtA[iNdEx] 10573 iNdEx++ 10574 stringLen |= (uint64(b) & 0x7F) << shift 10575 if b < 0x80 { 10576 break 10577 } 10578 } 10579 intStringLen := int(stringLen) 10580 if intStringLen < 0 { 10581 return ErrInvalidLengthGenerated 10582 } 10583 postIndex := iNdEx + intStringLen 10584 if postIndex > l { 10585 return io.ErrUnexpectedEOF 10586 } 10587 m.Reason = string(dAtA[iNdEx:postIndex]) 10588 iNdEx = postIndex 10589 case 5: 10590 if wireType != 2 { 10591 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 10592 } 10593 var stringLen uint64 10594 for shift := uint(0); ; shift += 7 { 10595 if shift >= 64 { 10596 return ErrIntOverflowGenerated 10597 } 10598 if iNdEx >= l { 10599 return io.ErrUnexpectedEOF 10600 } 10601 b := dAtA[iNdEx] 10602 iNdEx++ 10603 stringLen |= (uint64(b) & 0x7F) << shift 10604 if b < 0x80 { 10605 break 10606 } 10607 } 10608 intStringLen := int(stringLen) 10609 if intStringLen < 0 { 10610 return ErrInvalidLengthGenerated 10611 } 10612 postIndex := iNdEx + intStringLen 10613 if postIndex > l { 10614 return io.ErrUnexpectedEOF 10615 } 10616 m.Message = string(dAtA[iNdEx:postIndex]) 10617 iNdEx = postIndex 10618 default: 10619 iNdEx = preIndex 10620 skippy, err := skipGenerated(dAtA[iNdEx:]) 10621 if err != nil { 10622 return err 10623 } 10624 if skippy < 0 { 10625 return ErrInvalidLengthGenerated 10626 } 10627 if (iNdEx + skippy) > l { 10628 return io.ErrUnexpectedEOF 10629 } 10630 iNdEx += skippy 10631 } 10632 } 10633 10634 if iNdEx > l { 10635 return io.ErrUnexpectedEOF 10636 } 10637 return nil 10638} 10639func (m *ReplicaSetList) Unmarshal(dAtA []byte) error { 10640 l := len(dAtA) 10641 iNdEx := 0 10642 for iNdEx < l { 10643 preIndex := iNdEx 10644 var wire uint64 10645 for shift := uint(0); ; shift += 7 { 10646 if shift >= 64 { 10647 return ErrIntOverflowGenerated 10648 } 10649 if iNdEx >= l { 10650 return io.ErrUnexpectedEOF 10651 } 10652 b := dAtA[iNdEx] 10653 iNdEx++ 10654 wire |= (uint64(b) & 0x7F) << shift 10655 if b < 0x80 { 10656 break 10657 } 10658 } 10659 fieldNum := int32(wire >> 3) 10660 wireType := int(wire & 0x7) 10661 if wireType == 4 { 10662 return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group") 10663 } 10664 if fieldNum <= 0 { 10665 return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire) 10666 } 10667 switch fieldNum { 10668 case 1: 10669 if wireType != 2 { 10670 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) 10671 } 10672 var msglen int 10673 for shift := uint(0); ; shift += 7 { 10674 if shift >= 64 { 10675 return ErrIntOverflowGenerated 10676 } 10677 if iNdEx >= l { 10678 return io.ErrUnexpectedEOF 10679 } 10680 b := dAtA[iNdEx] 10681 iNdEx++ 10682 msglen |= (int(b) & 0x7F) << shift 10683 if b < 0x80 { 10684 break 10685 } 10686 } 10687 if msglen < 0 { 10688 return ErrInvalidLengthGenerated 10689 } 10690 postIndex := iNdEx + msglen 10691 if postIndex > l { 10692 return io.ErrUnexpectedEOF 10693 } 10694 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10695 return err 10696 } 10697 iNdEx = postIndex 10698 case 2: 10699 if wireType != 2 { 10700 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) 10701 } 10702 var msglen int 10703 for shift := uint(0); ; shift += 7 { 10704 if shift >= 64 { 10705 return ErrIntOverflowGenerated 10706 } 10707 if iNdEx >= l { 10708 return io.ErrUnexpectedEOF 10709 } 10710 b := dAtA[iNdEx] 10711 iNdEx++ 10712 msglen |= (int(b) & 0x7F) << shift 10713 if b < 0x80 { 10714 break 10715 } 10716 } 10717 if msglen < 0 { 10718 return ErrInvalidLengthGenerated 10719 } 10720 postIndex := iNdEx + msglen 10721 if postIndex > l { 10722 return io.ErrUnexpectedEOF 10723 } 10724 m.Items = append(m.Items, ReplicaSet{}) 10725 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10726 return err 10727 } 10728 iNdEx = postIndex 10729 default: 10730 iNdEx = preIndex 10731 skippy, err := skipGenerated(dAtA[iNdEx:]) 10732 if err != nil { 10733 return err 10734 } 10735 if skippy < 0 { 10736 return ErrInvalidLengthGenerated 10737 } 10738 if (iNdEx + skippy) > l { 10739 return io.ErrUnexpectedEOF 10740 } 10741 iNdEx += skippy 10742 } 10743 } 10744 10745 if iNdEx > l { 10746 return io.ErrUnexpectedEOF 10747 } 10748 return nil 10749} 10750func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error { 10751 l := len(dAtA) 10752 iNdEx := 0 10753 for iNdEx < l { 10754 preIndex := iNdEx 10755 var wire uint64 10756 for shift := uint(0); ; shift += 7 { 10757 if shift >= 64 { 10758 return ErrIntOverflowGenerated 10759 } 10760 if iNdEx >= l { 10761 return io.ErrUnexpectedEOF 10762 } 10763 b := dAtA[iNdEx] 10764 iNdEx++ 10765 wire |= (uint64(b) & 0x7F) << shift 10766 if b < 0x80 { 10767 break 10768 } 10769 } 10770 fieldNum := int32(wire >> 3) 10771 wireType := int(wire & 0x7) 10772 if wireType == 4 { 10773 return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group") 10774 } 10775 if fieldNum <= 0 { 10776 return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) 10777 } 10778 switch fieldNum { 10779 case 1: 10780 if wireType != 0 { 10781 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 10782 } 10783 var v int32 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 v |= (int32(b) & 0x7F) << shift 10794 if b < 0x80 { 10795 break 10796 } 10797 } 10798 m.Replicas = &v 10799 case 2: 10800 if wireType != 2 { 10801 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 10802 } 10803 var msglen int 10804 for shift := uint(0); ; shift += 7 { 10805 if shift >= 64 { 10806 return ErrIntOverflowGenerated 10807 } 10808 if iNdEx >= l { 10809 return io.ErrUnexpectedEOF 10810 } 10811 b := dAtA[iNdEx] 10812 iNdEx++ 10813 msglen |= (int(b) & 0x7F) << shift 10814 if b < 0x80 { 10815 break 10816 } 10817 } 10818 if msglen < 0 { 10819 return ErrInvalidLengthGenerated 10820 } 10821 postIndex := iNdEx + msglen 10822 if postIndex > l { 10823 return io.ErrUnexpectedEOF 10824 } 10825 if m.Selector == nil { 10826 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{} 10827 } 10828 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10829 return err 10830 } 10831 iNdEx = postIndex 10832 case 3: 10833 if wireType != 2 { 10834 return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) 10835 } 10836 var msglen int 10837 for shift := uint(0); ; shift += 7 { 10838 if shift >= 64 { 10839 return ErrIntOverflowGenerated 10840 } 10841 if iNdEx >= l { 10842 return io.ErrUnexpectedEOF 10843 } 10844 b := dAtA[iNdEx] 10845 iNdEx++ 10846 msglen |= (int(b) & 0x7F) << shift 10847 if b < 0x80 { 10848 break 10849 } 10850 } 10851 if msglen < 0 { 10852 return ErrInvalidLengthGenerated 10853 } 10854 postIndex := iNdEx + msglen 10855 if postIndex > l { 10856 return io.ErrUnexpectedEOF 10857 } 10858 if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10859 return err 10860 } 10861 iNdEx = postIndex 10862 case 4: 10863 if wireType != 0 { 10864 return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) 10865 } 10866 m.MinReadySeconds = 0 10867 for shift := uint(0); ; shift += 7 { 10868 if shift >= 64 { 10869 return ErrIntOverflowGenerated 10870 } 10871 if iNdEx >= l { 10872 return io.ErrUnexpectedEOF 10873 } 10874 b := dAtA[iNdEx] 10875 iNdEx++ 10876 m.MinReadySeconds |= (int32(b) & 0x7F) << shift 10877 if b < 0x80 { 10878 break 10879 } 10880 } 10881 default: 10882 iNdEx = preIndex 10883 skippy, err := skipGenerated(dAtA[iNdEx:]) 10884 if err != nil { 10885 return err 10886 } 10887 if skippy < 0 { 10888 return ErrInvalidLengthGenerated 10889 } 10890 if (iNdEx + skippy) > l { 10891 return io.ErrUnexpectedEOF 10892 } 10893 iNdEx += skippy 10894 } 10895 } 10896 10897 if iNdEx > l { 10898 return io.ErrUnexpectedEOF 10899 } 10900 return nil 10901} 10902func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error { 10903 l := len(dAtA) 10904 iNdEx := 0 10905 for iNdEx < l { 10906 preIndex := iNdEx 10907 var wire uint64 10908 for shift := uint(0); ; shift += 7 { 10909 if shift >= 64 { 10910 return ErrIntOverflowGenerated 10911 } 10912 if iNdEx >= l { 10913 return io.ErrUnexpectedEOF 10914 } 10915 b := dAtA[iNdEx] 10916 iNdEx++ 10917 wire |= (uint64(b) & 0x7F) << shift 10918 if b < 0x80 { 10919 break 10920 } 10921 } 10922 fieldNum := int32(wire >> 3) 10923 wireType := int(wire & 0x7) 10924 if wireType == 4 { 10925 return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group") 10926 } 10927 if fieldNum <= 0 { 10928 return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) 10929 } 10930 switch fieldNum { 10931 case 1: 10932 if wireType != 0 { 10933 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 10934 } 10935 m.Replicas = 0 10936 for shift := uint(0); ; shift += 7 { 10937 if shift >= 64 { 10938 return ErrIntOverflowGenerated 10939 } 10940 if iNdEx >= l { 10941 return io.ErrUnexpectedEOF 10942 } 10943 b := dAtA[iNdEx] 10944 iNdEx++ 10945 m.Replicas |= (int32(b) & 0x7F) << shift 10946 if b < 0x80 { 10947 break 10948 } 10949 } 10950 case 2: 10951 if wireType != 0 { 10952 return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType) 10953 } 10954 m.FullyLabeledReplicas = 0 10955 for shift := uint(0); ; shift += 7 { 10956 if shift >= 64 { 10957 return ErrIntOverflowGenerated 10958 } 10959 if iNdEx >= l { 10960 return io.ErrUnexpectedEOF 10961 } 10962 b := dAtA[iNdEx] 10963 iNdEx++ 10964 m.FullyLabeledReplicas |= (int32(b) & 0x7F) << shift 10965 if b < 0x80 { 10966 break 10967 } 10968 } 10969 case 3: 10970 if wireType != 0 { 10971 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) 10972 } 10973 m.ObservedGeneration = 0 10974 for shift := uint(0); ; shift += 7 { 10975 if shift >= 64 { 10976 return ErrIntOverflowGenerated 10977 } 10978 if iNdEx >= l { 10979 return io.ErrUnexpectedEOF 10980 } 10981 b := dAtA[iNdEx] 10982 iNdEx++ 10983 m.ObservedGeneration |= (int64(b) & 0x7F) << shift 10984 if b < 0x80 { 10985 break 10986 } 10987 } 10988 case 4: 10989 if wireType != 0 { 10990 return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) 10991 } 10992 m.ReadyReplicas = 0 10993 for shift := uint(0); ; shift += 7 { 10994 if shift >= 64 { 10995 return ErrIntOverflowGenerated 10996 } 10997 if iNdEx >= l { 10998 return io.ErrUnexpectedEOF 10999 } 11000 b := dAtA[iNdEx] 11001 iNdEx++ 11002 m.ReadyReplicas |= (int32(b) & 0x7F) << shift 11003 if b < 0x80 { 11004 break 11005 } 11006 } 11007 case 5: 11008 if wireType != 0 { 11009 return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) 11010 } 11011 m.AvailableReplicas = 0 11012 for shift := uint(0); ; shift += 7 { 11013 if shift >= 64 { 11014 return ErrIntOverflowGenerated 11015 } 11016 if iNdEx >= l { 11017 return io.ErrUnexpectedEOF 11018 } 11019 b := dAtA[iNdEx] 11020 iNdEx++ 11021 m.AvailableReplicas |= (int32(b) & 0x7F) << shift 11022 if b < 0x80 { 11023 break 11024 } 11025 } 11026 case 6: 11027 if wireType != 2 { 11028 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) 11029 } 11030 var msglen int 11031 for shift := uint(0); ; shift += 7 { 11032 if shift >= 64 { 11033 return ErrIntOverflowGenerated 11034 } 11035 if iNdEx >= l { 11036 return io.ErrUnexpectedEOF 11037 } 11038 b := dAtA[iNdEx] 11039 iNdEx++ 11040 msglen |= (int(b) & 0x7F) << shift 11041 if b < 0x80 { 11042 break 11043 } 11044 } 11045 if msglen < 0 { 11046 return ErrInvalidLengthGenerated 11047 } 11048 postIndex := iNdEx + msglen 11049 if postIndex > l { 11050 return io.ErrUnexpectedEOF 11051 } 11052 m.Conditions = append(m.Conditions, ReplicaSetCondition{}) 11053 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11054 return err 11055 } 11056 iNdEx = postIndex 11057 default: 11058 iNdEx = preIndex 11059 skippy, err := skipGenerated(dAtA[iNdEx:]) 11060 if err != nil { 11061 return err 11062 } 11063 if skippy < 0 { 11064 return ErrInvalidLengthGenerated 11065 } 11066 if (iNdEx + skippy) > l { 11067 return io.ErrUnexpectedEOF 11068 } 11069 iNdEx += skippy 11070 } 11071 } 11072 11073 if iNdEx > l { 11074 return io.ErrUnexpectedEOF 11075 } 11076 return nil 11077} 11078func (m *ReplicationControllerDummy) Unmarshal(dAtA []byte) error { 11079 l := len(dAtA) 11080 iNdEx := 0 11081 for iNdEx < l { 11082 preIndex := iNdEx 11083 var wire uint64 11084 for shift := uint(0); ; shift += 7 { 11085 if shift >= 64 { 11086 return ErrIntOverflowGenerated 11087 } 11088 if iNdEx >= l { 11089 return io.ErrUnexpectedEOF 11090 } 11091 b := dAtA[iNdEx] 11092 iNdEx++ 11093 wire |= (uint64(b) & 0x7F) << shift 11094 if b < 0x80 { 11095 break 11096 } 11097 } 11098 fieldNum := int32(wire >> 3) 11099 wireType := int(wire & 0x7) 11100 if wireType == 4 { 11101 return fmt.Errorf("proto: ReplicationControllerDummy: wiretype end group for non-group") 11102 } 11103 if fieldNum <= 0 { 11104 return fmt.Errorf("proto: ReplicationControllerDummy: illegal tag %d (wire type %d)", fieldNum, wire) 11105 } 11106 switch fieldNum { 11107 default: 11108 iNdEx = preIndex 11109 skippy, err := skipGenerated(dAtA[iNdEx:]) 11110 if err != nil { 11111 return err 11112 } 11113 if skippy < 0 { 11114 return ErrInvalidLengthGenerated 11115 } 11116 if (iNdEx + skippy) > l { 11117 return io.ErrUnexpectedEOF 11118 } 11119 iNdEx += skippy 11120 } 11121 } 11122 11123 if iNdEx > l { 11124 return io.ErrUnexpectedEOF 11125 } 11126 return nil 11127} 11128func (m *RollbackConfig) Unmarshal(dAtA []byte) error { 11129 l := len(dAtA) 11130 iNdEx := 0 11131 for iNdEx < l { 11132 preIndex := iNdEx 11133 var wire uint64 11134 for shift := uint(0); ; shift += 7 { 11135 if shift >= 64 { 11136 return ErrIntOverflowGenerated 11137 } 11138 if iNdEx >= l { 11139 return io.ErrUnexpectedEOF 11140 } 11141 b := dAtA[iNdEx] 11142 iNdEx++ 11143 wire |= (uint64(b) & 0x7F) << shift 11144 if b < 0x80 { 11145 break 11146 } 11147 } 11148 fieldNum := int32(wire >> 3) 11149 wireType := int(wire & 0x7) 11150 if wireType == 4 { 11151 return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group") 11152 } 11153 if fieldNum <= 0 { 11154 return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire) 11155 } 11156 switch fieldNum { 11157 case 1: 11158 if wireType != 0 { 11159 return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) 11160 } 11161 m.Revision = 0 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 m.Revision |= (int64(b) & 0x7F) << shift 11172 if b < 0x80 { 11173 break 11174 } 11175 } 11176 default: 11177 iNdEx = preIndex 11178 skippy, err := skipGenerated(dAtA[iNdEx:]) 11179 if err != nil { 11180 return err 11181 } 11182 if skippy < 0 { 11183 return ErrInvalidLengthGenerated 11184 } 11185 if (iNdEx + skippy) > l { 11186 return io.ErrUnexpectedEOF 11187 } 11188 iNdEx += skippy 11189 } 11190 } 11191 11192 if iNdEx > l { 11193 return io.ErrUnexpectedEOF 11194 } 11195 return nil 11196} 11197func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error { 11198 l := len(dAtA) 11199 iNdEx := 0 11200 for iNdEx < l { 11201 preIndex := iNdEx 11202 var wire uint64 11203 for shift := uint(0); ; shift += 7 { 11204 if shift >= 64 { 11205 return ErrIntOverflowGenerated 11206 } 11207 if iNdEx >= l { 11208 return io.ErrUnexpectedEOF 11209 } 11210 b := dAtA[iNdEx] 11211 iNdEx++ 11212 wire |= (uint64(b) & 0x7F) << shift 11213 if b < 0x80 { 11214 break 11215 } 11216 } 11217 fieldNum := int32(wire >> 3) 11218 wireType := int(wire & 0x7) 11219 if wireType == 4 { 11220 return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group") 11221 } 11222 if fieldNum <= 0 { 11223 return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire) 11224 } 11225 switch fieldNum { 11226 case 1: 11227 if wireType != 2 { 11228 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType) 11229 } 11230 var msglen int 11231 for shift := uint(0); ; shift += 7 { 11232 if shift >= 64 { 11233 return ErrIntOverflowGenerated 11234 } 11235 if iNdEx >= l { 11236 return io.ErrUnexpectedEOF 11237 } 11238 b := dAtA[iNdEx] 11239 iNdEx++ 11240 msglen |= (int(b) & 0x7F) << shift 11241 if b < 0x80 { 11242 break 11243 } 11244 } 11245 if msglen < 0 { 11246 return ErrInvalidLengthGenerated 11247 } 11248 postIndex := iNdEx + msglen 11249 if postIndex > l { 11250 return io.ErrUnexpectedEOF 11251 } 11252 if m.MaxUnavailable == nil { 11253 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 11254 } 11255 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11256 return err 11257 } 11258 iNdEx = postIndex 11259 default: 11260 iNdEx = preIndex 11261 skippy, err := skipGenerated(dAtA[iNdEx:]) 11262 if err != nil { 11263 return err 11264 } 11265 if skippy < 0 { 11266 return ErrInvalidLengthGenerated 11267 } 11268 if (iNdEx + skippy) > l { 11269 return io.ErrUnexpectedEOF 11270 } 11271 iNdEx += skippy 11272 } 11273 } 11274 11275 if iNdEx > l { 11276 return io.ErrUnexpectedEOF 11277 } 11278 return nil 11279} 11280func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error { 11281 l := len(dAtA) 11282 iNdEx := 0 11283 for iNdEx < l { 11284 preIndex := iNdEx 11285 var wire uint64 11286 for shift := uint(0); ; shift += 7 { 11287 if shift >= 64 { 11288 return ErrIntOverflowGenerated 11289 } 11290 if iNdEx >= l { 11291 return io.ErrUnexpectedEOF 11292 } 11293 b := dAtA[iNdEx] 11294 iNdEx++ 11295 wire |= (uint64(b) & 0x7F) << shift 11296 if b < 0x80 { 11297 break 11298 } 11299 } 11300 fieldNum := int32(wire >> 3) 11301 wireType := int(wire & 0x7) 11302 if wireType == 4 { 11303 return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group") 11304 } 11305 if fieldNum <= 0 { 11306 return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire) 11307 } 11308 switch fieldNum { 11309 case 1: 11310 if wireType != 2 { 11311 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType) 11312 } 11313 var msglen int 11314 for shift := uint(0); ; shift += 7 { 11315 if shift >= 64 { 11316 return ErrIntOverflowGenerated 11317 } 11318 if iNdEx >= l { 11319 return io.ErrUnexpectedEOF 11320 } 11321 b := dAtA[iNdEx] 11322 iNdEx++ 11323 msglen |= (int(b) & 0x7F) << shift 11324 if b < 0x80 { 11325 break 11326 } 11327 } 11328 if msglen < 0 { 11329 return ErrInvalidLengthGenerated 11330 } 11331 postIndex := iNdEx + msglen 11332 if postIndex > l { 11333 return io.ErrUnexpectedEOF 11334 } 11335 if m.MaxUnavailable == nil { 11336 m.MaxUnavailable = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 11337 } 11338 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11339 return err 11340 } 11341 iNdEx = postIndex 11342 case 2: 11343 if wireType != 2 { 11344 return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType) 11345 } 11346 var msglen int 11347 for shift := uint(0); ; shift += 7 { 11348 if shift >= 64 { 11349 return ErrIntOverflowGenerated 11350 } 11351 if iNdEx >= l { 11352 return io.ErrUnexpectedEOF 11353 } 11354 b := dAtA[iNdEx] 11355 iNdEx++ 11356 msglen |= (int(b) & 0x7F) << shift 11357 if b < 0x80 { 11358 break 11359 } 11360 } 11361 if msglen < 0 { 11362 return ErrInvalidLengthGenerated 11363 } 11364 postIndex := iNdEx + msglen 11365 if postIndex > l { 11366 return io.ErrUnexpectedEOF 11367 } 11368 if m.MaxSurge == nil { 11369 m.MaxSurge = &k8s_io_apimachinery_pkg_util_intstr.IntOrString{} 11370 } 11371 if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11372 return err 11373 } 11374 iNdEx = postIndex 11375 default: 11376 iNdEx = preIndex 11377 skippy, err := skipGenerated(dAtA[iNdEx:]) 11378 if err != nil { 11379 return err 11380 } 11381 if skippy < 0 { 11382 return ErrInvalidLengthGenerated 11383 } 11384 if (iNdEx + skippy) > l { 11385 return io.ErrUnexpectedEOF 11386 } 11387 iNdEx += skippy 11388 } 11389 } 11390 11391 if iNdEx > l { 11392 return io.ErrUnexpectedEOF 11393 } 11394 return nil 11395} 11396func (m *RunAsGroupStrategyOptions) Unmarshal(dAtA []byte) error { 11397 l := len(dAtA) 11398 iNdEx := 0 11399 for iNdEx < l { 11400 preIndex := iNdEx 11401 var wire uint64 11402 for shift := uint(0); ; shift += 7 { 11403 if shift >= 64 { 11404 return ErrIntOverflowGenerated 11405 } 11406 if iNdEx >= l { 11407 return io.ErrUnexpectedEOF 11408 } 11409 b := dAtA[iNdEx] 11410 iNdEx++ 11411 wire |= (uint64(b) & 0x7F) << shift 11412 if b < 0x80 { 11413 break 11414 } 11415 } 11416 fieldNum := int32(wire >> 3) 11417 wireType := int(wire & 0x7) 11418 if wireType == 4 { 11419 return fmt.Errorf("proto: RunAsGroupStrategyOptions: wiretype end group for non-group") 11420 } 11421 if fieldNum <= 0 { 11422 return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11423 } 11424 switch fieldNum { 11425 case 1: 11426 if wireType != 2 { 11427 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 11428 } 11429 var stringLen uint64 11430 for shift := uint(0); ; shift += 7 { 11431 if shift >= 64 { 11432 return ErrIntOverflowGenerated 11433 } 11434 if iNdEx >= l { 11435 return io.ErrUnexpectedEOF 11436 } 11437 b := dAtA[iNdEx] 11438 iNdEx++ 11439 stringLen |= (uint64(b) & 0x7F) << shift 11440 if b < 0x80 { 11441 break 11442 } 11443 } 11444 intStringLen := int(stringLen) 11445 if intStringLen < 0 { 11446 return ErrInvalidLengthGenerated 11447 } 11448 postIndex := iNdEx + intStringLen 11449 if postIndex > l { 11450 return io.ErrUnexpectedEOF 11451 } 11452 m.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex]) 11453 iNdEx = postIndex 11454 case 2: 11455 if wireType != 2 { 11456 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 11457 } 11458 var msglen int 11459 for shift := uint(0); ; shift += 7 { 11460 if shift >= 64 { 11461 return ErrIntOverflowGenerated 11462 } 11463 if iNdEx >= l { 11464 return io.ErrUnexpectedEOF 11465 } 11466 b := dAtA[iNdEx] 11467 iNdEx++ 11468 msglen |= (int(b) & 0x7F) << shift 11469 if b < 0x80 { 11470 break 11471 } 11472 } 11473 if msglen < 0 { 11474 return ErrInvalidLengthGenerated 11475 } 11476 postIndex := iNdEx + msglen 11477 if postIndex > l { 11478 return io.ErrUnexpectedEOF 11479 } 11480 m.Ranges = append(m.Ranges, IDRange{}) 11481 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11482 return err 11483 } 11484 iNdEx = postIndex 11485 default: 11486 iNdEx = preIndex 11487 skippy, err := skipGenerated(dAtA[iNdEx:]) 11488 if err != nil { 11489 return err 11490 } 11491 if skippy < 0 { 11492 return ErrInvalidLengthGenerated 11493 } 11494 if (iNdEx + skippy) > l { 11495 return io.ErrUnexpectedEOF 11496 } 11497 iNdEx += skippy 11498 } 11499 } 11500 11501 if iNdEx > l { 11502 return io.ErrUnexpectedEOF 11503 } 11504 return nil 11505} 11506func (m *RunAsUserStrategyOptions) Unmarshal(dAtA []byte) error { 11507 l := len(dAtA) 11508 iNdEx := 0 11509 for iNdEx < l { 11510 preIndex := iNdEx 11511 var wire uint64 11512 for shift := uint(0); ; shift += 7 { 11513 if shift >= 64 { 11514 return ErrIntOverflowGenerated 11515 } 11516 if iNdEx >= l { 11517 return io.ErrUnexpectedEOF 11518 } 11519 b := dAtA[iNdEx] 11520 iNdEx++ 11521 wire |= (uint64(b) & 0x7F) << shift 11522 if b < 0x80 { 11523 break 11524 } 11525 } 11526 fieldNum := int32(wire >> 3) 11527 wireType := int(wire & 0x7) 11528 if wireType == 4 { 11529 return fmt.Errorf("proto: RunAsUserStrategyOptions: wiretype end group for non-group") 11530 } 11531 if fieldNum <= 0 { 11532 return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11533 } 11534 switch fieldNum { 11535 case 1: 11536 if wireType != 2 { 11537 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 11538 } 11539 var stringLen uint64 11540 for shift := uint(0); ; shift += 7 { 11541 if shift >= 64 { 11542 return ErrIntOverflowGenerated 11543 } 11544 if iNdEx >= l { 11545 return io.ErrUnexpectedEOF 11546 } 11547 b := dAtA[iNdEx] 11548 iNdEx++ 11549 stringLen |= (uint64(b) & 0x7F) << shift 11550 if b < 0x80 { 11551 break 11552 } 11553 } 11554 intStringLen := int(stringLen) 11555 if intStringLen < 0 { 11556 return ErrInvalidLengthGenerated 11557 } 11558 postIndex := iNdEx + intStringLen 11559 if postIndex > l { 11560 return io.ErrUnexpectedEOF 11561 } 11562 m.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex]) 11563 iNdEx = postIndex 11564 case 2: 11565 if wireType != 2 { 11566 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 11567 } 11568 var msglen int 11569 for shift := uint(0); ; shift += 7 { 11570 if shift >= 64 { 11571 return ErrIntOverflowGenerated 11572 } 11573 if iNdEx >= l { 11574 return io.ErrUnexpectedEOF 11575 } 11576 b := dAtA[iNdEx] 11577 iNdEx++ 11578 msglen |= (int(b) & 0x7F) << shift 11579 if b < 0x80 { 11580 break 11581 } 11582 } 11583 if msglen < 0 { 11584 return ErrInvalidLengthGenerated 11585 } 11586 postIndex := iNdEx + msglen 11587 if postIndex > l { 11588 return io.ErrUnexpectedEOF 11589 } 11590 m.Ranges = append(m.Ranges, IDRange{}) 11591 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11592 return err 11593 } 11594 iNdEx = postIndex 11595 default: 11596 iNdEx = preIndex 11597 skippy, err := skipGenerated(dAtA[iNdEx:]) 11598 if err != nil { 11599 return err 11600 } 11601 if skippy < 0 { 11602 return ErrInvalidLengthGenerated 11603 } 11604 if (iNdEx + skippy) > l { 11605 return io.ErrUnexpectedEOF 11606 } 11607 iNdEx += skippy 11608 } 11609 } 11610 11611 if iNdEx > l { 11612 return io.ErrUnexpectedEOF 11613 } 11614 return nil 11615} 11616func (m *RuntimeClassStrategyOptions) Unmarshal(dAtA []byte) error { 11617 l := len(dAtA) 11618 iNdEx := 0 11619 for iNdEx < l { 11620 preIndex := iNdEx 11621 var wire uint64 11622 for shift := uint(0); ; shift += 7 { 11623 if shift >= 64 { 11624 return ErrIntOverflowGenerated 11625 } 11626 if iNdEx >= l { 11627 return io.ErrUnexpectedEOF 11628 } 11629 b := dAtA[iNdEx] 11630 iNdEx++ 11631 wire |= (uint64(b) & 0x7F) << shift 11632 if b < 0x80 { 11633 break 11634 } 11635 } 11636 fieldNum := int32(wire >> 3) 11637 wireType := int(wire & 0x7) 11638 if wireType == 4 { 11639 return fmt.Errorf("proto: RuntimeClassStrategyOptions: wiretype end group for non-group") 11640 } 11641 if fieldNum <= 0 { 11642 return fmt.Errorf("proto: RuntimeClassStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11643 } 11644 switch fieldNum { 11645 case 1: 11646 if wireType != 2 { 11647 return fmt.Errorf("proto: wrong wireType = %d for field AllowedRuntimeClassNames", wireType) 11648 } 11649 var stringLen uint64 11650 for shift := uint(0); ; shift += 7 { 11651 if shift >= 64 { 11652 return ErrIntOverflowGenerated 11653 } 11654 if iNdEx >= l { 11655 return io.ErrUnexpectedEOF 11656 } 11657 b := dAtA[iNdEx] 11658 iNdEx++ 11659 stringLen |= (uint64(b) & 0x7F) << shift 11660 if b < 0x80 { 11661 break 11662 } 11663 } 11664 intStringLen := int(stringLen) 11665 if intStringLen < 0 { 11666 return ErrInvalidLengthGenerated 11667 } 11668 postIndex := iNdEx + intStringLen 11669 if postIndex > l { 11670 return io.ErrUnexpectedEOF 11671 } 11672 m.AllowedRuntimeClassNames = append(m.AllowedRuntimeClassNames, string(dAtA[iNdEx:postIndex])) 11673 iNdEx = postIndex 11674 case 2: 11675 if wireType != 2 { 11676 return fmt.Errorf("proto: wrong wireType = %d for field DefaultRuntimeClassName", wireType) 11677 } 11678 var stringLen uint64 11679 for shift := uint(0); ; shift += 7 { 11680 if shift >= 64 { 11681 return ErrIntOverflowGenerated 11682 } 11683 if iNdEx >= l { 11684 return io.ErrUnexpectedEOF 11685 } 11686 b := dAtA[iNdEx] 11687 iNdEx++ 11688 stringLen |= (uint64(b) & 0x7F) << shift 11689 if b < 0x80 { 11690 break 11691 } 11692 } 11693 intStringLen := int(stringLen) 11694 if intStringLen < 0 { 11695 return ErrInvalidLengthGenerated 11696 } 11697 postIndex := iNdEx + intStringLen 11698 if postIndex > l { 11699 return io.ErrUnexpectedEOF 11700 } 11701 s := string(dAtA[iNdEx:postIndex]) 11702 m.DefaultRuntimeClassName = &s 11703 iNdEx = postIndex 11704 default: 11705 iNdEx = preIndex 11706 skippy, err := skipGenerated(dAtA[iNdEx:]) 11707 if err != nil { 11708 return err 11709 } 11710 if skippy < 0 { 11711 return ErrInvalidLengthGenerated 11712 } 11713 if (iNdEx + skippy) > l { 11714 return io.ErrUnexpectedEOF 11715 } 11716 iNdEx += skippy 11717 } 11718 } 11719 11720 if iNdEx > l { 11721 return io.ErrUnexpectedEOF 11722 } 11723 return nil 11724} 11725func (m *SELinuxStrategyOptions) Unmarshal(dAtA []byte) error { 11726 l := len(dAtA) 11727 iNdEx := 0 11728 for iNdEx < l { 11729 preIndex := iNdEx 11730 var wire uint64 11731 for shift := uint(0); ; shift += 7 { 11732 if shift >= 64 { 11733 return ErrIntOverflowGenerated 11734 } 11735 if iNdEx >= l { 11736 return io.ErrUnexpectedEOF 11737 } 11738 b := dAtA[iNdEx] 11739 iNdEx++ 11740 wire |= (uint64(b) & 0x7F) << shift 11741 if b < 0x80 { 11742 break 11743 } 11744 } 11745 fieldNum := int32(wire >> 3) 11746 wireType := int(wire & 0x7) 11747 if wireType == 4 { 11748 return fmt.Errorf("proto: SELinuxStrategyOptions: wiretype end group for non-group") 11749 } 11750 if fieldNum <= 0 { 11751 return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 11752 } 11753 switch fieldNum { 11754 case 1: 11755 if wireType != 2 { 11756 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 11757 } 11758 var stringLen uint64 11759 for shift := uint(0); ; shift += 7 { 11760 if shift >= 64 { 11761 return ErrIntOverflowGenerated 11762 } 11763 if iNdEx >= l { 11764 return io.ErrUnexpectedEOF 11765 } 11766 b := dAtA[iNdEx] 11767 iNdEx++ 11768 stringLen |= (uint64(b) & 0x7F) << shift 11769 if b < 0x80 { 11770 break 11771 } 11772 } 11773 intStringLen := int(stringLen) 11774 if intStringLen < 0 { 11775 return ErrInvalidLengthGenerated 11776 } 11777 postIndex := iNdEx + intStringLen 11778 if postIndex > l { 11779 return io.ErrUnexpectedEOF 11780 } 11781 m.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex]) 11782 iNdEx = postIndex 11783 case 2: 11784 if wireType != 2 { 11785 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", wireType) 11786 } 11787 var msglen int 11788 for shift := uint(0); ; shift += 7 { 11789 if shift >= 64 { 11790 return ErrIntOverflowGenerated 11791 } 11792 if iNdEx >= l { 11793 return io.ErrUnexpectedEOF 11794 } 11795 b := dAtA[iNdEx] 11796 iNdEx++ 11797 msglen |= (int(b) & 0x7F) << shift 11798 if b < 0x80 { 11799 break 11800 } 11801 } 11802 if msglen < 0 { 11803 return ErrInvalidLengthGenerated 11804 } 11805 postIndex := iNdEx + msglen 11806 if postIndex > l { 11807 return io.ErrUnexpectedEOF 11808 } 11809 if m.SELinuxOptions == nil { 11810 m.SELinuxOptions = &k8s_io_api_core_v1.SELinuxOptions{} 11811 } 11812 if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11813 return err 11814 } 11815 iNdEx = postIndex 11816 default: 11817 iNdEx = preIndex 11818 skippy, err := skipGenerated(dAtA[iNdEx:]) 11819 if err != nil { 11820 return err 11821 } 11822 if skippy < 0 { 11823 return ErrInvalidLengthGenerated 11824 } 11825 if (iNdEx + skippy) > l { 11826 return io.ErrUnexpectedEOF 11827 } 11828 iNdEx += skippy 11829 } 11830 } 11831 11832 if iNdEx > l { 11833 return io.ErrUnexpectedEOF 11834 } 11835 return nil 11836} 11837func (m *Scale) Unmarshal(dAtA []byte) error { 11838 l := len(dAtA) 11839 iNdEx := 0 11840 for iNdEx < l { 11841 preIndex := iNdEx 11842 var wire uint64 11843 for shift := uint(0); ; shift += 7 { 11844 if shift >= 64 { 11845 return ErrIntOverflowGenerated 11846 } 11847 if iNdEx >= l { 11848 return io.ErrUnexpectedEOF 11849 } 11850 b := dAtA[iNdEx] 11851 iNdEx++ 11852 wire |= (uint64(b) & 0x7F) << shift 11853 if b < 0x80 { 11854 break 11855 } 11856 } 11857 fieldNum := int32(wire >> 3) 11858 wireType := int(wire & 0x7) 11859 if wireType == 4 { 11860 return fmt.Errorf("proto: Scale: wiretype end group for non-group") 11861 } 11862 if fieldNum <= 0 { 11863 return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire) 11864 } 11865 switch fieldNum { 11866 case 1: 11867 if wireType != 2 { 11868 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) 11869 } 11870 var msglen int 11871 for shift := uint(0); ; shift += 7 { 11872 if shift >= 64 { 11873 return ErrIntOverflowGenerated 11874 } 11875 if iNdEx >= l { 11876 return io.ErrUnexpectedEOF 11877 } 11878 b := dAtA[iNdEx] 11879 iNdEx++ 11880 msglen |= (int(b) & 0x7F) << shift 11881 if b < 0x80 { 11882 break 11883 } 11884 } 11885 if msglen < 0 { 11886 return ErrInvalidLengthGenerated 11887 } 11888 postIndex := iNdEx + msglen 11889 if postIndex > l { 11890 return io.ErrUnexpectedEOF 11891 } 11892 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11893 return err 11894 } 11895 iNdEx = postIndex 11896 case 2: 11897 if wireType != 2 { 11898 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) 11899 } 11900 var msglen int 11901 for shift := uint(0); ; shift += 7 { 11902 if shift >= 64 { 11903 return ErrIntOverflowGenerated 11904 } 11905 if iNdEx >= l { 11906 return io.ErrUnexpectedEOF 11907 } 11908 b := dAtA[iNdEx] 11909 iNdEx++ 11910 msglen |= (int(b) & 0x7F) << shift 11911 if b < 0x80 { 11912 break 11913 } 11914 } 11915 if msglen < 0 { 11916 return ErrInvalidLengthGenerated 11917 } 11918 postIndex := iNdEx + msglen 11919 if postIndex > l { 11920 return io.ErrUnexpectedEOF 11921 } 11922 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11923 return err 11924 } 11925 iNdEx = postIndex 11926 case 3: 11927 if wireType != 2 { 11928 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) 11929 } 11930 var msglen int 11931 for shift := uint(0); ; shift += 7 { 11932 if shift >= 64 { 11933 return ErrIntOverflowGenerated 11934 } 11935 if iNdEx >= l { 11936 return io.ErrUnexpectedEOF 11937 } 11938 b := dAtA[iNdEx] 11939 iNdEx++ 11940 msglen |= (int(b) & 0x7F) << shift 11941 if b < 0x80 { 11942 break 11943 } 11944 } 11945 if msglen < 0 { 11946 return ErrInvalidLengthGenerated 11947 } 11948 postIndex := iNdEx + msglen 11949 if postIndex > l { 11950 return io.ErrUnexpectedEOF 11951 } 11952 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11953 return err 11954 } 11955 iNdEx = postIndex 11956 default: 11957 iNdEx = preIndex 11958 skippy, err := skipGenerated(dAtA[iNdEx:]) 11959 if err != nil { 11960 return err 11961 } 11962 if skippy < 0 { 11963 return ErrInvalidLengthGenerated 11964 } 11965 if (iNdEx + skippy) > l { 11966 return io.ErrUnexpectedEOF 11967 } 11968 iNdEx += skippy 11969 } 11970 } 11971 11972 if iNdEx > l { 11973 return io.ErrUnexpectedEOF 11974 } 11975 return nil 11976} 11977func (m *ScaleSpec) Unmarshal(dAtA []byte) error { 11978 l := len(dAtA) 11979 iNdEx := 0 11980 for iNdEx < l { 11981 preIndex := iNdEx 11982 var wire uint64 11983 for shift := uint(0); ; shift += 7 { 11984 if shift >= 64 { 11985 return ErrIntOverflowGenerated 11986 } 11987 if iNdEx >= l { 11988 return io.ErrUnexpectedEOF 11989 } 11990 b := dAtA[iNdEx] 11991 iNdEx++ 11992 wire |= (uint64(b) & 0x7F) << shift 11993 if b < 0x80 { 11994 break 11995 } 11996 } 11997 fieldNum := int32(wire >> 3) 11998 wireType := int(wire & 0x7) 11999 if wireType == 4 { 12000 return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group") 12001 } 12002 if fieldNum <= 0 { 12003 return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire) 12004 } 12005 switch fieldNum { 12006 case 1: 12007 if wireType != 0 { 12008 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 12009 } 12010 m.Replicas = 0 12011 for shift := uint(0); ; shift += 7 { 12012 if shift >= 64 { 12013 return ErrIntOverflowGenerated 12014 } 12015 if iNdEx >= l { 12016 return io.ErrUnexpectedEOF 12017 } 12018 b := dAtA[iNdEx] 12019 iNdEx++ 12020 m.Replicas |= (int32(b) & 0x7F) << shift 12021 if b < 0x80 { 12022 break 12023 } 12024 } 12025 default: 12026 iNdEx = preIndex 12027 skippy, err := skipGenerated(dAtA[iNdEx:]) 12028 if err != nil { 12029 return err 12030 } 12031 if skippy < 0 { 12032 return ErrInvalidLengthGenerated 12033 } 12034 if (iNdEx + skippy) > l { 12035 return io.ErrUnexpectedEOF 12036 } 12037 iNdEx += skippy 12038 } 12039 } 12040 12041 if iNdEx > l { 12042 return io.ErrUnexpectedEOF 12043 } 12044 return nil 12045} 12046func (m *ScaleStatus) Unmarshal(dAtA []byte) error { 12047 l := len(dAtA) 12048 iNdEx := 0 12049 for iNdEx < l { 12050 preIndex := iNdEx 12051 var wire uint64 12052 for shift := uint(0); ; shift += 7 { 12053 if shift >= 64 { 12054 return ErrIntOverflowGenerated 12055 } 12056 if iNdEx >= l { 12057 return io.ErrUnexpectedEOF 12058 } 12059 b := dAtA[iNdEx] 12060 iNdEx++ 12061 wire |= (uint64(b) & 0x7F) << shift 12062 if b < 0x80 { 12063 break 12064 } 12065 } 12066 fieldNum := int32(wire >> 3) 12067 wireType := int(wire & 0x7) 12068 if wireType == 4 { 12069 return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group") 12070 } 12071 if fieldNum <= 0 { 12072 return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire) 12073 } 12074 switch fieldNum { 12075 case 1: 12076 if wireType != 0 { 12077 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) 12078 } 12079 m.Replicas = 0 12080 for shift := uint(0); ; shift += 7 { 12081 if shift >= 64 { 12082 return ErrIntOverflowGenerated 12083 } 12084 if iNdEx >= l { 12085 return io.ErrUnexpectedEOF 12086 } 12087 b := dAtA[iNdEx] 12088 iNdEx++ 12089 m.Replicas |= (int32(b) & 0x7F) << shift 12090 if b < 0x80 { 12091 break 12092 } 12093 } 12094 case 2: 12095 if wireType != 2 { 12096 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) 12097 } 12098 var msglen int 12099 for shift := uint(0); ; shift += 7 { 12100 if shift >= 64 { 12101 return ErrIntOverflowGenerated 12102 } 12103 if iNdEx >= l { 12104 return io.ErrUnexpectedEOF 12105 } 12106 b := dAtA[iNdEx] 12107 iNdEx++ 12108 msglen |= (int(b) & 0x7F) << shift 12109 if b < 0x80 { 12110 break 12111 } 12112 } 12113 if msglen < 0 { 12114 return ErrInvalidLengthGenerated 12115 } 12116 postIndex := iNdEx + msglen 12117 if postIndex > l { 12118 return io.ErrUnexpectedEOF 12119 } 12120 if m.Selector == nil { 12121 m.Selector = make(map[string]string) 12122 } 12123 var mapkey string 12124 var mapvalue string 12125 for iNdEx < postIndex { 12126 entryPreIndex := iNdEx 12127 var wire uint64 12128 for shift := uint(0); ; shift += 7 { 12129 if shift >= 64 { 12130 return ErrIntOverflowGenerated 12131 } 12132 if iNdEx >= l { 12133 return io.ErrUnexpectedEOF 12134 } 12135 b := dAtA[iNdEx] 12136 iNdEx++ 12137 wire |= (uint64(b) & 0x7F) << shift 12138 if b < 0x80 { 12139 break 12140 } 12141 } 12142 fieldNum := int32(wire >> 3) 12143 if fieldNum == 1 { 12144 var stringLenmapkey uint64 12145 for shift := uint(0); ; shift += 7 { 12146 if shift >= 64 { 12147 return ErrIntOverflowGenerated 12148 } 12149 if iNdEx >= l { 12150 return io.ErrUnexpectedEOF 12151 } 12152 b := dAtA[iNdEx] 12153 iNdEx++ 12154 stringLenmapkey |= (uint64(b) & 0x7F) << shift 12155 if b < 0x80 { 12156 break 12157 } 12158 } 12159 intStringLenmapkey := int(stringLenmapkey) 12160 if intStringLenmapkey < 0 { 12161 return ErrInvalidLengthGenerated 12162 } 12163 postStringIndexmapkey := iNdEx + intStringLenmapkey 12164 if postStringIndexmapkey > l { 12165 return io.ErrUnexpectedEOF 12166 } 12167 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 12168 iNdEx = postStringIndexmapkey 12169 } else if fieldNum == 2 { 12170 var stringLenmapvalue uint64 12171 for shift := uint(0); ; shift += 7 { 12172 if shift >= 64 { 12173 return ErrIntOverflowGenerated 12174 } 12175 if iNdEx >= l { 12176 return io.ErrUnexpectedEOF 12177 } 12178 b := dAtA[iNdEx] 12179 iNdEx++ 12180 stringLenmapvalue |= (uint64(b) & 0x7F) << shift 12181 if b < 0x80 { 12182 break 12183 } 12184 } 12185 intStringLenmapvalue := int(stringLenmapvalue) 12186 if intStringLenmapvalue < 0 { 12187 return ErrInvalidLengthGenerated 12188 } 12189 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 12190 if postStringIndexmapvalue > l { 12191 return io.ErrUnexpectedEOF 12192 } 12193 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 12194 iNdEx = postStringIndexmapvalue 12195 } else { 12196 iNdEx = entryPreIndex 12197 skippy, err := skipGenerated(dAtA[iNdEx:]) 12198 if err != nil { 12199 return err 12200 } 12201 if skippy < 0 { 12202 return ErrInvalidLengthGenerated 12203 } 12204 if (iNdEx + skippy) > postIndex { 12205 return io.ErrUnexpectedEOF 12206 } 12207 iNdEx += skippy 12208 } 12209 } 12210 m.Selector[mapkey] = mapvalue 12211 iNdEx = postIndex 12212 case 3: 12213 if wireType != 2 { 12214 return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType) 12215 } 12216 var stringLen uint64 12217 for shift := uint(0); ; shift += 7 { 12218 if shift >= 64 { 12219 return ErrIntOverflowGenerated 12220 } 12221 if iNdEx >= l { 12222 return io.ErrUnexpectedEOF 12223 } 12224 b := dAtA[iNdEx] 12225 iNdEx++ 12226 stringLen |= (uint64(b) & 0x7F) << shift 12227 if b < 0x80 { 12228 break 12229 } 12230 } 12231 intStringLen := int(stringLen) 12232 if intStringLen < 0 { 12233 return ErrInvalidLengthGenerated 12234 } 12235 postIndex := iNdEx + intStringLen 12236 if postIndex > l { 12237 return io.ErrUnexpectedEOF 12238 } 12239 m.TargetSelector = string(dAtA[iNdEx:postIndex]) 12240 iNdEx = postIndex 12241 default: 12242 iNdEx = preIndex 12243 skippy, err := skipGenerated(dAtA[iNdEx:]) 12244 if err != nil { 12245 return err 12246 } 12247 if skippy < 0 { 12248 return ErrInvalidLengthGenerated 12249 } 12250 if (iNdEx + skippy) > l { 12251 return io.ErrUnexpectedEOF 12252 } 12253 iNdEx += skippy 12254 } 12255 } 12256 12257 if iNdEx > l { 12258 return io.ErrUnexpectedEOF 12259 } 12260 return nil 12261} 12262func (m *SupplementalGroupsStrategyOptions) Unmarshal(dAtA []byte) error { 12263 l := len(dAtA) 12264 iNdEx := 0 12265 for iNdEx < l { 12266 preIndex := iNdEx 12267 var wire uint64 12268 for shift := uint(0); ; shift += 7 { 12269 if shift >= 64 { 12270 return ErrIntOverflowGenerated 12271 } 12272 if iNdEx >= l { 12273 return io.ErrUnexpectedEOF 12274 } 12275 b := dAtA[iNdEx] 12276 iNdEx++ 12277 wire |= (uint64(b) & 0x7F) << shift 12278 if b < 0x80 { 12279 break 12280 } 12281 } 12282 fieldNum := int32(wire >> 3) 12283 wireType := int(wire & 0x7) 12284 if wireType == 4 { 12285 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: wiretype end group for non-group") 12286 } 12287 if fieldNum <= 0 { 12288 return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) 12289 } 12290 switch fieldNum { 12291 case 1: 12292 if wireType != 2 { 12293 return fmt.Errorf("proto: wrong wireType = %d for field Rule", wireType) 12294 } 12295 var stringLen uint64 12296 for shift := uint(0); ; shift += 7 { 12297 if shift >= 64 { 12298 return ErrIntOverflowGenerated 12299 } 12300 if iNdEx >= l { 12301 return io.ErrUnexpectedEOF 12302 } 12303 b := dAtA[iNdEx] 12304 iNdEx++ 12305 stringLen |= (uint64(b) & 0x7F) << shift 12306 if b < 0x80 { 12307 break 12308 } 12309 } 12310 intStringLen := int(stringLen) 12311 if intStringLen < 0 { 12312 return ErrInvalidLengthGenerated 12313 } 12314 postIndex := iNdEx + intStringLen 12315 if postIndex > l { 12316 return io.ErrUnexpectedEOF 12317 } 12318 m.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex]) 12319 iNdEx = postIndex 12320 case 2: 12321 if wireType != 2 { 12322 return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) 12323 } 12324 var msglen int 12325 for shift := uint(0); ; shift += 7 { 12326 if shift >= 64 { 12327 return ErrIntOverflowGenerated 12328 } 12329 if iNdEx >= l { 12330 return io.ErrUnexpectedEOF 12331 } 12332 b := dAtA[iNdEx] 12333 iNdEx++ 12334 msglen |= (int(b) & 0x7F) << shift 12335 if b < 0x80 { 12336 break 12337 } 12338 } 12339 if msglen < 0 { 12340 return ErrInvalidLengthGenerated 12341 } 12342 postIndex := iNdEx + msglen 12343 if postIndex > l { 12344 return io.ErrUnexpectedEOF 12345 } 12346 m.Ranges = append(m.Ranges, IDRange{}) 12347 if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12348 return err 12349 } 12350 iNdEx = postIndex 12351 default: 12352 iNdEx = preIndex 12353 skippy, err := skipGenerated(dAtA[iNdEx:]) 12354 if err != nil { 12355 return err 12356 } 12357 if skippy < 0 { 12358 return ErrInvalidLengthGenerated 12359 } 12360 if (iNdEx + skippy) > l { 12361 return io.ErrUnexpectedEOF 12362 } 12363 iNdEx += skippy 12364 } 12365 } 12366 12367 if iNdEx > l { 12368 return io.ErrUnexpectedEOF 12369 } 12370 return nil 12371} 12372func skipGenerated(dAtA []byte) (n int, err error) { 12373 l := len(dAtA) 12374 iNdEx := 0 12375 for iNdEx < l { 12376 var wire uint64 12377 for shift := uint(0); ; shift += 7 { 12378 if shift >= 64 { 12379 return 0, ErrIntOverflowGenerated 12380 } 12381 if iNdEx >= l { 12382 return 0, io.ErrUnexpectedEOF 12383 } 12384 b := dAtA[iNdEx] 12385 iNdEx++ 12386 wire |= (uint64(b) & 0x7F) << shift 12387 if b < 0x80 { 12388 break 12389 } 12390 } 12391 wireType := int(wire & 0x7) 12392 switch wireType { 12393 case 0: 12394 for shift := uint(0); ; shift += 7 { 12395 if shift >= 64 { 12396 return 0, ErrIntOverflowGenerated 12397 } 12398 if iNdEx >= l { 12399 return 0, io.ErrUnexpectedEOF 12400 } 12401 iNdEx++ 12402 if dAtA[iNdEx-1] < 0x80 { 12403 break 12404 } 12405 } 12406 return iNdEx, nil 12407 case 1: 12408 iNdEx += 8 12409 return iNdEx, nil 12410 case 2: 12411 var length int 12412 for shift := uint(0); ; shift += 7 { 12413 if shift >= 64 { 12414 return 0, ErrIntOverflowGenerated 12415 } 12416 if iNdEx >= l { 12417 return 0, io.ErrUnexpectedEOF 12418 } 12419 b := dAtA[iNdEx] 12420 iNdEx++ 12421 length |= (int(b) & 0x7F) << shift 12422 if b < 0x80 { 12423 break 12424 } 12425 } 12426 iNdEx += length 12427 if length < 0 { 12428 return 0, ErrInvalidLengthGenerated 12429 } 12430 return iNdEx, nil 12431 case 3: 12432 for { 12433 var innerWire uint64 12434 var start int = iNdEx 12435 for shift := uint(0); ; shift += 7 { 12436 if shift >= 64 { 12437 return 0, ErrIntOverflowGenerated 12438 } 12439 if iNdEx >= l { 12440 return 0, io.ErrUnexpectedEOF 12441 } 12442 b := dAtA[iNdEx] 12443 iNdEx++ 12444 innerWire |= (uint64(b) & 0x7F) << shift 12445 if b < 0x80 { 12446 break 12447 } 12448 } 12449 innerWireType := int(innerWire & 0x7) 12450 if innerWireType == 4 { 12451 break 12452 } 12453 next, err := skipGenerated(dAtA[start:]) 12454 if err != nil { 12455 return 0, err 12456 } 12457 iNdEx = start + next 12458 } 12459 return iNdEx, nil 12460 case 4: 12461 return iNdEx, nil 12462 case 5: 12463 iNdEx += 4 12464 return iNdEx, nil 12465 default: 12466 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 12467 } 12468 } 12469 panic("unreachable") 12470} 12471 12472var ( 12473 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") 12474 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") 12475) 12476 12477func init() { 12478 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptorGenerated) 12479} 12480 12481var fileDescriptorGenerated = []byte{ 12482 // 3695 bytes of a gzipped FileDescriptorProto 12483 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x4f, 0x6c, 0x1b, 0x47, 12484 0x77, 0xf7, 0x92, 0x94, 0x48, 0x3d, 0xfd, 0x1f, 0xc9, 0x12, 0x3f, 0x3b, 0x16, 0xfd, 0x6d, 0x00, 12485 0xd7, 0x49, 0x6d, 0x32, 0x76, 0x6c, 0x7f, 0xae, 0x8d, 0x26, 0x11, 0x25, 0xcb, 0x56, 0xaa, 0x3f, 12486 0xcc, 0x50, 0x72, 0x83, 0xa0, 0x49, 0xb3, 0x22, 0x47, 0xd4, 0x5a, 0xcb, 0xdd, 0xcd, 0xce, 0x52, 12487 0x11, 0x81, 0x1e, 0x7a, 0x28, 0x0a, 0x14, 0x68, 0xd1, 0x5e, 0xd2, 0xf6, 0xd8, 0xa0, 0x40, 0x4f, 12488 0x2d, 0xda, 0x5b, 0x7b, 0x08, 0x02, 0x14, 0x48, 0x01, 0xa3, 0x48, 0x8b, 0xdc, 0x9a, 0x93, 0xd0, 12489 0x28, 0xa7, 0xa2, 0xa7, 0xde, 0x0a, 0x1f, 0x8a, 0x62, 0x66, 0x67, 0xff, 0xef, 0x8a, 0x2b, 0xc5, 12490 0x16, 0x8a, 0xe2, 0xbb, 0x89, 0xf3, 0xde, 0xfb, 0xbd, 0x37, 0x33, 0x6f, 0xde, 0x7b, 0x33, 0xfb, 12491 0x04, 0x2b, 0xfb, 0xf7, 0x69, 0x55, 0x35, 0x6a, 0xfb, 0xbd, 0x1d, 0x62, 0xe9, 0xc4, 0x26, 0xb4, 12492 0x76, 0x40, 0xf4, 0xb6, 0x61, 0xd5, 0x04, 0x41, 0x31, 0xd5, 0x1a, 0x39, 0xb4, 0x89, 0x4e, 0x55, 12493 0x43, 0xa7, 0xb5, 0x83, 0x5b, 0x3b, 0xc4, 0x56, 0x6e, 0xd5, 0x3a, 0x44, 0x27, 0x96, 0x62, 0x93, 12494 0x76, 0xd5, 0xb4, 0x0c, 0xdb, 0x40, 0x57, 0x1c, 0xf6, 0xaa, 0x62, 0xaa, 0x55, 0x9f, 0xbd, 0x2a, 12495 0xd8, 0x2f, 0xdd, 0xec, 0xa8, 0xf6, 0x5e, 0x6f, 0xa7, 0xda, 0x32, 0xba, 0xb5, 0x8e, 0xd1, 0x31, 12496 0x6a, 0x5c, 0x6a, 0xa7, 0xb7, 0xcb, 0x7f, 0xf1, 0x1f, 0xfc, 0x2f, 0x07, 0xed, 0x92, 0x1c, 0x50, 12497 0xde, 0x32, 0x2c, 0x52, 0x3b, 0x88, 0x69, 0xbc, 0x74, 0xc7, 0xe7, 0xe9, 0x2a, 0xad, 0x3d, 0x55, 12498 0x27, 0x56, 0xbf, 0x66, 0xee, 0x77, 0xd8, 0x00, 0xad, 0x75, 0x89, 0xad, 0x24, 0x49, 0xd5, 0xd2, 12499 0xa4, 0xac, 0x9e, 0x6e, 0xab, 0x5d, 0x12, 0x13, 0xb8, 0x37, 0x48, 0x80, 0xb6, 0xf6, 0x48, 0x57, 12500 0x89, 0xc9, 0xbd, 0x9d, 0x26, 0xd7, 0xb3, 0x55, 0xad, 0xa6, 0xea, 0x36, 0xb5, 0xad, 0xa8, 0x90, 12501 0x7c, 0x07, 0xa6, 0x16, 0x35, 0xcd, 0xf8, 0x9c, 0xb4, 0x97, 0x9a, 0xab, 0xcb, 0x96, 0x7a, 0x40, 12502 0x2c, 0x74, 0x15, 0x0a, 0xba, 0xd2, 0x25, 0x65, 0xe9, 0xaa, 0x74, 0x7d, 0xa4, 0x3e, 0xf6, 0xfc, 12503 0xa8, 0x72, 0xe1, 0xf8, 0xa8, 0x52, 0xd8, 0x50, 0xba, 0x04, 0x73, 0x8a, 0xfc, 0x10, 0xa6, 0x85, 12504 0xd4, 0x8a, 0x46, 0x0e, 0x9f, 0x1a, 0x5a, 0xaf, 0x4b, 0xd0, 0x35, 0x18, 0x6e, 0x73, 0x00, 0x21, 12505 0x38, 0x21, 0x04, 0x87, 0x1d, 0x58, 0x2c, 0xa8, 0x32, 0x85, 0x49, 0x21, 0xfc, 0xc4, 0xa0, 0x76, 12506 0x43, 0xb1, 0xf7, 0xd0, 0x6d, 0x00, 0x53, 0xb1, 0xf7, 0x1a, 0x16, 0xd9, 0x55, 0x0f, 0x85, 0x38, 12507 0x12, 0xe2, 0xd0, 0xf0, 0x28, 0x38, 0xc0, 0x85, 0x6e, 0x40, 0xc9, 0x22, 0x4a, 0x7b, 0x53, 0xd7, 12508 0xfa, 0xe5, 0xdc, 0x55, 0xe9, 0x7a, 0xa9, 0x3e, 0x25, 0x24, 0x4a, 0x58, 0x8c, 0x63, 0x8f, 0x43, 12509 0xfe, 0x22, 0x07, 0x23, 0xcb, 0x0a, 0xe9, 0x1a, 0x7a, 0x93, 0xd8, 0xe8, 0x53, 0x28, 0xb1, 0xed, 12510 0x6a, 0x2b, 0xb6, 0xc2, 0xb5, 0x8d, 0xde, 0x7e, 0xab, 0xea, 0xbb, 0x93, 0xb7, 0x7a, 0x55, 0x73, 12511 0xbf, 0xc3, 0x06, 0x68, 0x95, 0x71, 0x57, 0x0f, 0x6e, 0x55, 0x37, 0x77, 0x9e, 0x91, 0x96, 0xbd, 12512 0x4e, 0x6c, 0xc5, 0xb7, 0xcf, 0x1f, 0xc3, 0x1e, 0x2a, 0xda, 0x80, 0x02, 0x35, 0x49, 0x8b, 0x5b, 12513 0x36, 0x7a, 0xfb, 0x46, 0xf5, 0x44, 0x67, 0xad, 0x7a, 0x96, 0x35, 0x4d, 0xd2, 0xf2, 0x57, 0x9c, 12514 0xfd, 0xc2, 0x1c, 0x07, 0x3d, 0x85, 0x61, 0x6a, 0x2b, 0x76, 0x8f, 0x96, 0xf3, 0x1c, 0xb1, 0x9a, 12515 0x19, 0x91, 0x4b, 0xf9, 0x9b, 0xe1, 0xfc, 0xc6, 0x02, 0x4d, 0xfe, 0x8f, 0x1c, 0x20, 0x8f, 0x77, 12516 0xc9, 0xd0, 0xdb, 0xaa, 0xad, 0x1a, 0x3a, 0x7a, 0x00, 0x05, 0xbb, 0x6f, 0xba, 0x2e, 0x70, 0xcd, 12517 0x35, 0x68, 0xab, 0x6f, 0x92, 0x17, 0x47, 0x95, 0xb9, 0xb8, 0x04, 0xa3, 0x60, 0x2e, 0x83, 0xd6, 12518 0x3c, 0x53, 0x73, 0x5c, 0xfa, 0x4e, 0x58, 0xf5, 0x8b, 0xa3, 0x4a, 0xc2, 0x61, 0xab, 0x7a, 0x48, 12519 0x61, 0x03, 0xd1, 0x01, 0x20, 0x4d, 0xa1, 0xf6, 0x96, 0xa5, 0xe8, 0xd4, 0xd1, 0xa4, 0x76, 0x89, 12520 0x58, 0x84, 0x37, 0xb3, 0x6d, 0x1a, 0x93, 0xa8, 0x5f, 0x12, 0x56, 0xa0, 0xb5, 0x18, 0x1a, 0x4e, 12521 0xd0, 0xc0, 0xbc, 0xd9, 0x22, 0x0a, 0x35, 0xf4, 0x72, 0x21, 0xec, 0xcd, 0x98, 0x8f, 0x62, 0x41, 12522 0x45, 0x6f, 0x40, 0xb1, 0x4b, 0x28, 0x55, 0x3a, 0xa4, 0x3c, 0xc4, 0x19, 0x27, 0x05, 0x63, 0x71, 12523 0xdd, 0x19, 0xc6, 0x2e, 0x5d, 0xfe, 0x4a, 0x82, 0x71, 0x6f, 0xe5, 0xd6, 0x54, 0x6a, 0xa3, 0xdf, 12524 0x8a, 0xf9, 0x61, 0x35, 0xdb, 0x94, 0x98, 0x34, 0xf7, 0x42, 0xcf, 0xe7, 0xdd, 0x91, 0x80, 0x0f, 12525 0xae, 0xc3, 0x90, 0x6a, 0x93, 0x2e, 0xdb, 0x87, 0xfc, 0xf5, 0xd1, 0xdb, 0xd7, 0xb3, 0xba, 0x4c, 12526 0x7d, 0x5c, 0x80, 0x0e, 0xad, 0x32, 0x71, 0xec, 0xa0, 0xc8, 0x7f, 0x5a, 0x08, 0x98, 0xcf, 0x5c, 12527 0x13, 0x7d, 0x0c, 0x25, 0x4a, 0x34, 0xd2, 0xb2, 0x0d, 0x4b, 0x98, 0xff, 0x76, 0x46, 0xf3, 0x95, 12528 0x1d, 0xa2, 0x35, 0x85, 0x68, 0x7d, 0x8c, 0xd9, 0xef, 0xfe, 0xc2, 0x1e, 0x24, 0xfa, 0x00, 0x4a, 12529 0x36, 0xe9, 0x9a, 0x9a, 0x62, 0x13, 0x71, 0x8e, 0x5e, 0x0f, 0x4e, 0x81, 0x79, 0x0e, 0x03, 0x6b, 12530 0x18, 0xed, 0x2d, 0xc1, 0xc6, 0x8f, 0x8f, 0xb7, 0x24, 0xee, 0x28, 0xf6, 0x60, 0xd0, 0x01, 0x4c, 12531 0xf4, 0xcc, 0x36, 0xe3, 0xb4, 0x59, 0x14, 0xec, 0xf4, 0x85, 0x27, 0xdd, 0xcb, 0xba, 0x36, 0xdb, 12532 0x21, 0xe9, 0xfa, 0x9c, 0xd0, 0x35, 0x11, 0x1e, 0xc7, 0x11, 0x2d, 0x68, 0x11, 0x26, 0xbb, 0xaa, 12533 0xce, 0xe2, 0x52, 0xbf, 0x49, 0x5a, 0x86, 0xde, 0xa6, 0xdc, 0xad, 0x86, 0xea, 0xf3, 0x02, 0x60, 12534 0x72, 0x3d, 0x4c, 0xc6, 0x51, 0x7e, 0xf4, 0x3e, 0x20, 0x77, 0x1a, 0x8f, 0x9d, 0x20, 0xae, 0x1a, 12535 0x3a, 0xf7, 0xb9, 0xbc, 0xef, 0xdc, 0x5b, 0x31, 0x0e, 0x9c, 0x20, 0x85, 0xd6, 0x60, 0xd6, 0x22, 12536 0x07, 0x2a, 0x9b, 0xe3, 0x13, 0x95, 0xda, 0x86, 0xd5, 0x5f, 0x53, 0xbb, 0xaa, 0x5d, 0x1e, 0xe6, 12537 0x36, 0x95, 0x8f, 0x8f, 0x2a, 0xb3, 0x38, 0x81, 0x8e, 0x13, 0xa5, 0xe4, 0x3f, 0x1b, 0x86, 0xc9, 12538 0x48, 0xbc, 0x41, 0x4f, 0x61, 0xae, 0xd5, 0xb3, 0x2c, 0xa2, 0xdb, 0x1b, 0xbd, 0xee, 0x0e, 0xb1, 12539 0x9a, 0xad, 0x3d, 0xd2, 0xee, 0x69, 0xa4, 0xcd, 0x1d, 0x65, 0xa8, 0xbe, 0x20, 0x2c, 0x9e, 0x5b, 12540 0x4a, 0xe4, 0xc2, 0x29, 0xd2, 0x6c, 0x15, 0x74, 0x3e, 0xb4, 0xae, 0x52, 0xea, 0x61, 0xe6, 0x38, 12541 0xa6, 0xb7, 0x0a, 0x1b, 0x31, 0x0e, 0x9c, 0x20, 0xc5, 0x6c, 0x6c, 0x13, 0xaa, 0x5a, 0xa4, 0x1d, 12542 0xb5, 0x31, 0x1f, 0xb6, 0x71, 0x39, 0x91, 0x0b, 0xa7, 0x48, 0xa3, 0xbb, 0x30, 0xea, 0x68, 0xe3, 12543 0xfb, 0x27, 0x36, 0x7a, 0x46, 0x80, 0x8d, 0x6e, 0xf8, 0x24, 0x1c, 0xe4, 0x63, 0x53, 0x33, 0x76, 12544 0x28, 0xb1, 0x0e, 0x48, 0x3b, 0x7d, 0x83, 0x37, 0x63, 0x1c, 0x38, 0x41, 0x8a, 0x4d, 0xcd, 0xf1, 12545 0xc0, 0xd8, 0xd4, 0x86, 0xc3, 0x53, 0xdb, 0x4e, 0xe4, 0xc2, 0x29, 0xd2, 0xcc, 0x8f, 0x1d, 0x93, 12546 0x17, 0x0f, 0x14, 0x55, 0x53, 0x76, 0x34, 0x52, 0x2e, 0x86, 0xfd, 0x78, 0x23, 0x4c, 0xc6, 0x51, 12547 0x7e, 0xf4, 0x18, 0xa6, 0x9d, 0xa1, 0x6d, 0x5d, 0xf1, 0x40, 0x4a, 0x1c, 0xe4, 0x67, 0x02, 0x64, 12548 0x7a, 0x23, 0xca, 0x80, 0xe3, 0x32, 0xe8, 0x01, 0x4c, 0xb4, 0x0c, 0x4d, 0xe3, 0xfe, 0xb8, 0x64, 12549 0xf4, 0x74, 0xbb, 0x3c, 0xc2, 0x51, 0x10, 0x3b, 0x8f, 0x4b, 0x21, 0x0a, 0x8e, 0x70, 0x22, 0x02, 12550 0xd0, 0x72, 0x13, 0x0e, 0x2d, 0x03, 0x8f, 0x8f, 0xb7, 0xb2, 0xc6, 0x00, 0x2f, 0x55, 0xf9, 0x35, 12551 0x80, 0x37, 0x44, 0x71, 0x00, 0x58, 0xfe, 0x67, 0x09, 0xe6, 0x53, 0x42, 0x07, 0x7a, 0x37, 0x94, 12552 0x62, 0x7f, 0x35, 0x92, 0x62, 0x2f, 0xa7, 0x88, 0x05, 0xf2, 0xac, 0x0e, 0xe3, 0x16, 0x9b, 0x95, 12553 0xde, 0x71, 0x58, 0x44, 0x8c, 0xbc, 0x3b, 0x60, 0x1a, 0x38, 0x28, 0xe3, 0xc7, 0xfc, 0xe9, 0xe3, 12554 0xa3, 0xca, 0x78, 0x88, 0x86, 0xc3, 0xf0, 0xf2, 0x9f, 0xe7, 0x00, 0x96, 0x89, 0xa9, 0x19, 0xfd, 12555 0x2e, 0xd1, 0xcf, 0xa3, 0x86, 0xda, 0x0c, 0xd5, 0x50, 0x37, 0x07, 0x6d, 0x8f, 0x67, 0x5a, 0x6a, 12556 0x11, 0xf5, 0x9b, 0x91, 0x22, 0xaa, 0x96, 0x1d, 0xf2, 0xe4, 0x2a, 0xea, 0xdf, 0xf2, 0x30, 0xe3, 12557 0x33, 0xfb, 0x65, 0xd4, 0xc3, 0xd0, 0x1e, 0xff, 0x4a, 0x64, 0x8f, 0xe7, 0x13, 0x44, 0x5e, 0x59, 12558 0x1d, 0xf5, 0xf2, 0xeb, 0x19, 0xf4, 0x0c, 0x26, 0x58, 0xe1, 0xe4, 0xb8, 0x07, 0x2f, 0xcb, 0x86, 12559 0x4f, 0x5d, 0x96, 0x79, 0x09, 0x74, 0x2d, 0x84, 0x84, 0x23, 0xc8, 0x29, 0x65, 0x60, 0xf1, 0x55, 12560 0x97, 0x81, 0xf2, 0xd7, 0x12, 0x4c, 0xf8, 0xdb, 0x74, 0x0e, 0x45, 0xdb, 0x46, 0xb8, 0x68, 0x7b, 12561 0x23, 0xb3, 0x8b, 0xa6, 0x54, 0x6d, 0xff, 0xcd, 0x0a, 0x7c, 0x8f, 0x89, 0x1d, 0xf0, 0x1d, 0xa5, 12562 0xb5, 0x3f, 0xf8, 0x8e, 0x87, 0xbe, 0x90, 0x00, 0x89, 0x2c, 0xb0, 0xa8, 0xeb, 0x86, 0xad, 0x38, 12563 0xb1, 0xd2, 0x31, 0x6b, 0x35, 0xb3, 0x59, 0xae, 0xc6, 0xea, 0x76, 0x0c, 0xeb, 0x91, 0x6e, 0x5b, 12564 0x7d, 0x7f, 0x47, 0xe2, 0x0c, 0x38, 0xc1, 0x00, 0xa4, 0x00, 0x58, 0x02, 0x73, 0xcb, 0x10, 0x07, 12565 0xf9, 0x66, 0x86, 0x98, 0xc7, 0x04, 0x96, 0x0c, 0x7d, 0x57, 0xed, 0xf8, 0x61, 0x07, 0x7b, 0x40, 12566 0x38, 0x00, 0x7a, 0xe9, 0x11, 0xcc, 0xa7, 0x58, 0x8b, 0xa6, 0x20, 0xbf, 0x4f, 0xfa, 0xce, 0xb2, 12567 0x61, 0xf6, 0x27, 0x9a, 0x85, 0xa1, 0x03, 0x45, 0xeb, 0x39, 0xe1, 0x77, 0x04, 0x3b, 0x3f, 0x1e, 12568 0xe4, 0xee, 0x4b, 0xf2, 0x57, 0x43, 0x41, 0xdf, 0xe1, 0x15, 0xf3, 0x75, 0x76, 0x69, 0x35, 0x35, 12569 0xb5, 0xa5, 0x50, 0x51, 0x08, 0x8d, 0x39, 0x17, 0x56, 0x67, 0x0c, 0x7b, 0xd4, 0x50, 0x6d, 0x9d, 12570 0x7b, 0xb5, 0xb5, 0x75, 0xfe, 0xe5, 0xd4, 0xd6, 0xbf, 0x0d, 0x25, 0xea, 0x56, 0xd5, 0x05, 0x0e, 12571 0x79, 0xeb, 0x14, 0xf1, 0x55, 0x14, 0xd4, 0x9e, 0x02, 0xaf, 0x94, 0xf6, 0x40, 0x93, 0x8a, 0xe8, 12572 0xa1, 0x53, 0x16, 0xd1, 0x2f, 0xb5, 0xf0, 0x65, 0x31, 0xd5, 0x54, 0x7a, 0x94, 0xb4, 0x79, 0x20, 12573 0x2a, 0xf9, 0x31, 0xb5, 0xc1, 0x47, 0xb1, 0xa0, 0xa2, 0x8f, 0x43, 0x2e, 0x5b, 0x3a, 0x8b, 0xcb, 12574 0x4e, 0xa4, 0xbb, 0x2b, 0xda, 0x86, 0x79, 0xd3, 0x32, 0x3a, 0x16, 0xa1, 0x74, 0x99, 0x28, 0x6d, 12575 0x4d, 0xd5, 0x89, 0xbb, 0x3e, 0x4e, 0x45, 0x74, 0xf9, 0xf8, 0xa8, 0x32, 0xdf, 0x48, 0x66, 0xc1, 12576 0x69, 0xb2, 0xf2, 0xf3, 0x02, 0x4c, 0x45, 0x33, 0x60, 0x4a, 0x91, 0x2a, 0x9d, 0xa9, 0x48, 0xbd, 12577 0x11, 0x38, 0x0c, 0x4e, 0x05, 0x1f, 0x78, 0xc1, 0x89, 0x1d, 0x88, 0x45, 0x98, 0x14, 0xd1, 0xc0, 12578 0x25, 0x8a, 0x32, 0xdd, 0xdb, 0xfd, 0xed, 0x30, 0x19, 0x47, 0xf9, 0x59, 0xe9, 0xe9, 0x57, 0x94, 12579 0x2e, 0x48, 0x21, 0x5c, 0x7a, 0x2e, 0x46, 0x19, 0x70, 0x5c, 0x06, 0xad, 0xc3, 0x4c, 0x4f, 0x8f, 12580 0x43, 0x39, 0xde, 0x78, 0x59, 0x40, 0xcd, 0x6c, 0xc7, 0x59, 0x70, 0x92, 0x1c, 0xda, 0x0d, 0x55, 12581 0xa3, 0xc3, 0x3c, 0xc2, 0xde, 0xce, 0x7c, 0x76, 0x32, 0x97, 0xa3, 0xe8, 0x21, 0x8c, 0x5b, 0xfc, 12582 0xde, 0xe1, 0x1a, 0xec, 0xd4, 0xee, 0x17, 0x85, 0xd8, 0x38, 0x0e, 0x12, 0x71, 0x98, 0x37, 0xa1, 12583 0xdc, 0x2e, 0x65, 0x2d, 0xb7, 0xe5, 0x7f, 0x94, 0x82, 0x49, 0xc8, 0x2b, 0x81, 0x07, 0xbd, 0x32, 12584 0xc5, 0x24, 0x02, 0xd5, 0x91, 0x91, 0x5c, 0xfd, 0xde, 0x3b, 0x55, 0xf5, 0xeb, 0x27, 0xcf, 0xc1, 12585 0xe5, 0xef, 0x97, 0x12, 0xcc, 0xad, 0x34, 0x1f, 0x5b, 0x46, 0xcf, 0x74, 0xcd, 0xd9, 0x34, 0x9d, 12586 0x75, 0xfd, 0x05, 0x14, 0xac, 0x9e, 0xe6, 0xce, 0xe3, 0x75, 0x77, 0x1e, 0xb8, 0xa7, 0xb1, 0x79, 12587 0xcc, 0x44, 0xa4, 0x9c, 0x49, 0x30, 0x01, 0xb4, 0x01, 0xc3, 0x96, 0xa2, 0x77, 0x88, 0x9b, 0x56, 12588 0xaf, 0x0d, 0xb0, 0x7e, 0x75, 0x19, 0x33, 0xf6, 0x40, 0xf1, 0xc6, 0xa5, 0xb1, 0x40, 0x91, 0xff, 12589 0x48, 0x82, 0xc9, 0x27, 0x5b, 0x5b, 0x8d, 0x55, 0x9d, 0x9f, 0x68, 0xfe, 0xb6, 0x7a, 0x15, 0x0a, 12590 0xa6, 0x62, 0xef, 0x45, 0x33, 0x3d, 0xa3, 0x61, 0x4e, 0x41, 0x1f, 0x42, 0x91, 0x45, 0x12, 0xa2, 12591 0xb7, 0x33, 0x96, 0xda, 0x02, 0xbe, 0xee, 0x08, 0xf9, 0x15, 0xa2, 0x18, 0xc0, 0x2e, 0x9c, 0xbc, 12592 0x0f, 0xb3, 0x01, 0x73, 0xd8, 0x7a, 0x3c, 0x65, 0xd9, 0x11, 0x35, 0x61, 0x88, 0x69, 0x66, 0x39, 12593 0x30, 0x9f, 0xe1, 0x31, 0x33, 0x32, 0x25, 0xbf, 0xd2, 0x61, 0xbf, 0x28, 0x76, 0xb0, 0xe4, 0x75, 12594 0x18, 0xe7, 0x0f, 0xca, 0x86, 0x65, 0xf3, 0x65, 0x41, 0x57, 0x20, 0xdf, 0x55, 0x75, 0x91, 0x67, 12595 0x47, 0x85, 0x4c, 0x9e, 0xe5, 0x08, 0x36, 0xce, 0xc9, 0xca, 0xa1, 0x88, 0x3c, 0x3e, 0x59, 0x39, 12596 0xc4, 0x6c, 0x5c, 0x7e, 0x0c, 0x45, 0xb1, 0xdc, 0x41, 0xa0, 0xfc, 0xc9, 0x40, 0xf9, 0x04, 0xa0, 12597 0x4d, 0x28, 0xae, 0x36, 0xea, 0x9a, 0xe1, 0x54, 0x5d, 0x2d, 0xb5, 0x6d, 0x45, 0xf7, 0x62, 0x69, 12598 0x75, 0x19, 0x63, 0x4e, 0x41, 0x32, 0x0c, 0x93, 0xc3, 0x16, 0x31, 0x6d, 0xee, 0x11, 0x23, 0x75, 12599 0x60, 0xbb, 0xfc, 0x88, 0x8f, 0x60, 0x41, 0x91, 0xff, 0x38, 0x07, 0x45, 0xb1, 0x1c, 0xe7, 0x70, 12600 0x0b, 0x5b, 0x0b, 0xdd, 0xc2, 0xde, 0xcc, 0xe6, 0x1a, 0xa9, 0x57, 0xb0, 0xad, 0xc8, 0x15, 0xec, 12601 0x46, 0x46, 0xbc, 0x93, 0xef, 0x5f, 0x7f, 0x27, 0xc1, 0x44, 0xd8, 0x29, 0xd1, 0x5d, 0x18, 0x65, 12602 0x09, 0x47, 0x6d, 0x91, 0x0d, 0xbf, 0xce, 0xf5, 0x1e, 0x61, 0x9a, 0x3e, 0x09, 0x07, 0xf9, 0x50, 12603 0xc7, 0x13, 0x63, 0x7e, 0x24, 0x26, 0x9d, 0xbe, 0xa4, 0x3d, 0x5b, 0xd5, 0xaa, 0xce, 0xa7, 0x95, 12604 0xea, 0xaa, 0x6e, 0x6f, 0x5a, 0x4d, 0xdb, 0x52, 0xf5, 0x4e, 0x4c, 0x11, 0x77, 0xca, 0x20, 0xb2, 12605 0xfc, 0x0f, 0x12, 0x8c, 0x0a, 0x93, 0xcf, 0xe1, 0x56, 0xf1, 0x1b, 0xe1, 0x5b, 0xc5, 0xb5, 0x8c, 12606 0x07, 0x3c, 0xf9, 0x4a, 0xf1, 0x57, 0xbe, 0xe9, 0xec, 0x48, 0x33, 0xaf, 0xde, 0x33, 0xa8, 0x1d, 12607 0xf5, 0x6a, 0x76, 0x18, 0x31, 0xa7, 0xa0, 0x1e, 0x4c, 0xa9, 0x91, 0x18, 0x20, 0x96, 0xb6, 0x96, 12608 0xcd, 0x12, 0x4f, 0xac, 0x5e, 0x16, 0xf0, 0x53, 0x51, 0x0a, 0x8e, 0xa9, 0x90, 0x09, 0xc4, 0xb8, 12609 0xd0, 0x07, 0x50, 0xd8, 0xb3, 0x6d, 0x33, 0xe1, 0xbd, 0x7a, 0x40, 0xe4, 0xf1, 0x4d, 0x28, 0xf1, 12610 0xd9, 0x6d, 0x6d, 0x35, 0x30, 0x87, 0x92, 0xff, 0xc7, 0x5f, 0x8f, 0xa6, 0xe3, 0xe3, 0x5e, 0x3c, 12611 0x95, 0xce, 0x12, 0x4f, 0x47, 0x93, 0x62, 0x29, 0x7a, 0x02, 0x79, 0x5b, 0xcb, 0x7a, 0x2d, 0x14, 12612 0x88, 0x5b, 0x6b, 0x4d, 0x3f, 0x20, 0x6d, 0xad, 0x35, 0x31, 0x83, 0x40, 0x9b, 0x30, 0xc4, 0xb2, 12613 0x0f, 0x3b, 0x82, 0xf9, 0xec, 0x47, 0x9a, 0xcd, 0xdf, 0x77, 0x08, 0xf6, 0x8b, 0x62, 0x07, 0x47, 12614 0xfe, 0x0c, 0xc6, 0x43, 0xe7, 0x14, 0x7d, 0x0a, 0x63, 0x9a, 0xa1, 0xb4, 0xeb, 0x8a, 0xa6, 0xe8, 12615 0x2d, 0xe2, 0x7e, 0x1c, 0xb8, 0x96, 0x74, 0xc3, 0x58, 0x0b, 0xf0, 0x89, 0x53, 0x3e, 0x2b, 0x94, 12616 0x8c, 0x05, 0x69, 0x38, 0x84, 0x28, 0x2b, 0x00, 0xfe, 0x1c, 0x51, 0x05, 0x86, 0x98, 0x9f, 0x39, 12617 0xf9, 0x64, 0xa4, 0x3e, 0xc2, 0x2c, 0x64, 0xee, 0x47, 0xb1, 0x33, 0x8e, 0x6e, 0x03, 0x50, 0xd2, 12618 0xb2, 0x88, 0xcd, 0x83, 0x41, 0x2e, 0xfc, 0x81, 0xb1, 0xe9, 0x51, 0x70, 0x80, 0x4b, 0xfe, 0x27, 12619 0x09, 0xc6, 0x37, 0x88, 0xfd, 0xb9, 0x61, 0xed, 0x37, 0x0c, 0x4d, 0x6d, 0xf5, 0xcf, 0x21, 0xd8, 12620 0xe2, 0x50, 0xb0, 0x7d, 0x6b, 0xc0, 0xce, 0x84, 0xac, 0x4b, 0x0b, 0xb9, 0xf2, 0xd7, 0x12, 0xcc, 12621 0x87, 0x38, 0x1f, 0xf9, 0x47, 0x77, 0x1b, 0x86, 0x4c, 0xc3, 0xb2, 0xdd, 0x44, 0x7c, 0x2a, 0x85, 12622 0x2c, 0x8c, 0x05, 0x52, 0x31, 0x83, 0xc1, 0x0e, 0x1a, 0x5a, 0x83, 0x9c, 0x6d, 0x08, 0x57, 0x3d, 12623 0x1d, 0x26, 0x21, 0x56, 0x1d, 0x04, 0x66, 0x6e, 0xcb, 0xc0, 0x39, 0xdb, 0x60, 0x1b, 0x51, 0x0e, 12624 0x71, 0x05, 0x83, 0xcf, 0x2b, 0x9a, 0x01, 0x86, 0xc2, 0xae, 0x65, 0x74, 0xcf, 0x3c, 0x07, 0x6f, 12625 0x23, 0x56, 0x2c, 0xa3, 0x8b, 0x39, 0x96, 0xfc, 0x8d, 0x04, 0xd3, 0x21, 0xce, 0x73, 0x08, 0xfc, 12626 0x1f, 0x84, 0x03, 0xff, 0x8d, 0xd3, 0x4c, 0x24, 0x25, 0xfc, 0x7f, 0x93, 0x8b, 0x4c, 0x83, 0x4d, 12627 0x18, 0xed, 0xc2, 0xa8, 0x69, 0xb4, 0x9b, 0x2f, 0xe1, 0x73, 0xe0, 0x24, 0xcb, 0x9b, 0x0d, 0x1f, 12628 0x0b, 0x07, 0x81, 0xd1, 0x21, 0x4c, 0xeb, 0x4a, 0x97, 0x50, 0x53, 0x69, 0x91, 0xe6, 0x4b, 0x78, 12629 0x20, 0xb9, 0xc8, 0xbf, 0x37, 0x44, 0x11, 0x71, 0x5c, 0x09, 0x5a, 0x87, 0xa2, 0x6a, 0xf2, 0x3a, 12630 0x4e, 0xd4, 0x2e, 0x03, 0xb3, 0xa8, 0x53, 0xf5, 0x39, 0xf1, 0x5c, 0xfc, 0xc0, 0x2e, 0x86, 0xfc, 12631 0xd7, 0x51, 0x6f, 0x60, 0xfe, 0x87, 0x1e, 0x43, 0x89, 0x37, 0x66, 0xb4, 0x0c, 0xcd, 0xfd, 0x32, 12632 0xc0, 0x76, 0xb6, 0x21, 0xc6, 0x5e, 0x1c, 0x55, 0x2e, 0x27, 0x3c, 0xfa, 0xba, 0x64, 0xec, 0x09, 12633 0xa3, 0x0d, 0x28, 0x98, 0x3f, 0xa5, 0x82, 0xe1, 0x49, 0x8e, 0x97, 0x2d, 0x1c, 0x47, 0xfe, 0xbd, 12634 0x7c, 0xc4, 0x5c, 0x9e, 0xea, 0x9e, 0xbd, 0xb4, 0x5d, 0xf7, 0x2a, 0xa6, 0xd4, 0x9d, 0xdf, 0x81, 12635 0xa2, 0xc8, 0xf0, 0xc2, 0x99, 0x7f, 0x71, 0x1a, 0x67, 0x0e, 0x66, 0x31, 0xef, 0xc2, 0xe2, 0x0e, 12636 0xba, 0xc0, 0xe8, 0x13, 0x18, 0x26, 0x8e, 0x0a, 0x27, 0x37, 0xde, 0x3b, 0x8d, 0x0a, 0x3f, 0xae, 12637 0xfa, 0x85, 0xaa, 0x18, 0x13, 0xa8, 0xe8, 0x5d, 0xb6, 0x5e, 0x8c, 0x97, 0x5d, 0x02, 0x69, 0xb9, 12638 0xc0, 0xd3, 0xd5, 0x15, 0x67, 0xda, 0xde, 0xf0, 0x8b, 0xa3, 0x0a, 0xf8, 0x3f, 0x71, 0x50, 0x42, 12639 0xfe, 0x17, 0x09, 0xa6, 0xf9, 0x0a, 0xb5, 0x7a, 0x96, 0x6a, 0xf7, 0xcf, 0x2d, 0x31, 0x3d, 0x0d, 12640 0x25, 0xa6, 0x3b, 0x03, 0x96, 0x25, 0x66, 0x61, 0x6a, 0x72, 0xfa, 0x56, 0x82, 0x8b, 0x31, 0xee, 12641 0x73, 0x88, 0x8b, 0xdb, 0xe1, 0xb8, 0xf8, 0xd6, 0x69, 0x27, 0x94, 0x12, 0x1b, 0xff, 0x6b, 0x3a, 12642 0x61, 0x3a, 0xfc, 0xa4, 0xdc, 0x06, 0x30, 0x2d, 0xf5, 0x40, 0xd5, 0x48, 0x47, 0x7c, 0x04, 0x2f, 12643 0x05, 0x5a, 0x9c, 0x3c, 0x0a, 0x0e, 0x70, 0x21, 0x0a, 0x73, 0x6d, 0xb2, 0xab, 0xf4, 0x34, 0x7b, 12644 0xb1, 0xdd, 0x5e, 0x52, 0x4c, 0x65, 0x47, 0xd5, 0x54, 0x5b, 0x15, 0xcf, 0x05, 0x23, 0xf5, 0x87, 12645 0xce, 0xc7, 0xe9, 0x24, 0x8e, 0x17, 0x47, 0x95, 0x2b, 0x49, 0x5f, 0x87, 0x5c, 0x96, 0x3e, 0x4e, 12646 0x81, 0x46, 0x7d, 0x28, 0x5b, 0xe4, 0xb3, 0x9e, 0x6a, 0x91, 0xf6, 0xb2, 0x65, 0x98, 0x21, 0xb5, 12647 0x79, 0xae, 0xf6, 0xd7, 0x8f, 0x8f, 0x2a, 0x65, 0x9c, 0xc2, 0x33, 0x58, 0x71, 0x2a, 0x3c, 0x7a, 12648 0x06, 0x33, 0x8a, 0x68, 0x46, 0x0b, 0x6a, 0x75, 0x4e, 0xc9, 0xfd, 0xe3, 0xa3, 0xca, 0xcc, 0x62, 12649 0x9c, 0x3c, 0x58, 0x61, 0x12, 0x28, 0xaa, 0x41, 0xf1, 0x80, 0xf7, 0xad, 0xd1, 0xf2, 0x10, 0xc7, 12650 0x67, 0x89, 0xa0, 0xe8, 0xb4, 0xb2, 0x31, 0xcc, 0xe1, 0x95, 0x26, 0x3f, 0x7d, 0x2e, 0x17, 0xbb, 12651 0x50, 0xb2, 0x5a, 0x52, 0x9c, 0x78, 0xfe, 0x62, 0x5c, 0xf2, 0xa3, 0xd6, 0x13, 0x9f, 0x84, 0x83, 12652 0x7c, 0xe8, 0x63, 0x18, 0xd9, 0x13, 0xaf, 0x12, 0xb4, 0x5c, 0xcc, 0x94, 0x84, 0x43, 0xaf, 0x18, 12653 0xf5, 0x69, 0xa1, 0x62, 0xc4, 0x1d, 0xa6, 0xd8, 0x47, 0x44, 0x6f, 0x40, 0x91, 0xff, 0x58, 0x5d, 12654 0xe6, 0xcf, 0x71, 0x25, 0x3f, 0xb6, 0x3d, 0x71, 0x86, 0xb1, 0x4b, 0x77, 0x59, 0x57, 0x1b, 0x4b, 12655 0xfc, 0x59, 0x38, 0xc2, 0xba, 0xda, 0x58, 0xc2, 0x2e, 0x1d, 0x7d, 0x0a, 0x45, 0x4a, 0xd6, 0x54, 12656 0xbd, 0x77, 0x58, 0x86, 0x4c, 0x1f, 0x95, 0x9b, 0x8f, 0x38, 0x77, 0xe4, 0x61, 0xcc, 0xd7, 0x20, 12657 0xe8, 0xd8, 0x85, 0x45, 0x7b, 0x30, 0x62, 0xf5, 0xf4, 0x45, 0xba, 0x4d, 0x89, 0x55, 0x1e, 0xe5, 12658 0x3a, 0x06, 0x85, 0x73, 0xec, 0xf2, 0x47, 0xb5, 0x78, 0x2b, 0xe4, 0x71, 0x60, 0x1f, 0x1c, 0xfd, 12659 0xa1, 0x04, 0x88, 0xf6, 0x4c, 0x53, 0x23, 0x5d, 0xa2, 0xdb, 0x8a, 0xc6, 0xdf, 0xe2, 0x68, 0x79, 12660 0x8c, 0xeb, 0x7c, 0x6f, 0xd0, 0xbc, 0x62, 0x82, 0x51, 0xe5, 0xde, 0xa3, 0x77, 0x9c, 0x15, 0x27, 12661 0xe8, 0x65, 0x4b, 0xbb, 0x4b, 0xf9, 0xdf, 0xe5, 0xf1, 0x4c, 0x4b, 0x9b, 0xfc, 0xe6, 0xe8, 0x2f, 12662 0xad, 0xa0, 0x63, 0x17, 0x16, 0x3d, 0x85, 0x39, 0xb7, 0xed, 0x11, 0x1b, 0x86, 0xbd, 0xa2, 0x6a, 12663 0x84, 0xf6, 0xa9, 0x4d, 0xba, 0xe5, 0x09, 0xbe, 0xed, 0x5e, 0xef, 0x07, 0x4e, 0xe4, 0xc2, 0x29, 12664 0xd2, 0xa8, 0x0b, 0x15, 0x37, 0x64, 0xb0, 0xf3, 0xe4, 0xc5, 0xac, 0x47, 0xb4, 0xa5, 0x68, 0xce, 12665 0x77, 0x80, 0x49, 0xae, 0xe0, 0xf5, 0xe3, 0xa3, 0x4a, 0x65, 0xf9, 0x64, 0x56, 0x3c, 0x08, 0x0b, 12666 0x7d, 0x08, 0x65, 0x25, 0x4d, 0xcf, 0x14, 0xd7, 0xf3, 0x1a, 0x8b, 0x43, 0xa9, 0x0a, 0x52, 0xa5, 12667 0x91, 0x0d, 0x53, 0x4a, 0xb8, 0x01, 0x95, 0x96, 0xa7, 0x33, 0x3d, 0x44, 0x46, 0xfa, 0x56, 0xfd, 12668 0xc7, 0x88, 0x08, 0x81, 0xe2, 0x98, 0x06, 0xf4, 0x3b, 0x80, 0x94, 0x68, 0xcf, 0x2c, 0x2d, 0xa3, 12669 0x4c, 0xe9, 0x27, 0xd6, 0x6c, 0xeb, 0xbb, 0x5d, 0x8c, 0x44, 0x71, 0x82, 0x1e, 0xb4, 0x06, 0xb3, 12670 0x62, 0x74, 0x5b, 0xa7, 0xca, 0x2e, 0x69, 0xf6, 0x69, 0xcb, 0xd6, 0x68, 0x79, 0x86, 0xc7, 0x3e, 12671 0xfe, 0xe1, 0x6b, 0x31, 0x81, 0x8e, 0x13, 0xa5, 0xd0, 0x7b, 0x30, 0xb5, 0x6b, 0x58, 0x3b, 0x6a, 12672 0xbb, 0x4d, 0x74, 0x17, 0x69, 0x96, 0x23, 0xcd, 0xb2, 0xd5, 0x58, 0x89, 0xd0, 0x70, 0x8c, 0x1b, 12673 0x51, 0xb8, 0x28, 0x90, 0x1b, 0x96, 0xd1, 0x5a, 0x37, 0x7a, 0xba, 0xed, 0x94, 0x44, 0x17, 0xbd, 12674 0x14, 0x73, 0x71, 0x31, 0x89, 0xe1, 0xc5, 0x51, 0xe5, 0x6a, 0x72, 0x05, 0xec, 0x33, 0xe1, 0x64, 12675 0x6c, 0xb4, 0x07, 0xc0, 0xe3, 0x82, 0x73, 0xfc, 0xe6, 0xf8, 0xf1, 0xbb, 0x9f, 0x25, 0xea, 0x24, 12676 0x9e, 0x40, 0xe7, 0x93, 0x9c, 0x47, 0xc6, 0x01, 0x6c, 0x76, 0x4b, 0x51, 0x22, 0x6d, 0xd5, 0xb4, 12677 0x3c, 0xcf, 0xf7, 0xba, 0x96, 0x6d, 0xaf, 0x3d, 0xb9, 0xc0, 0xa7, 0xa9, 0x28, 0x22, 0x8e, 0x2b, 12678 0x41, 0x26, 0x8c, 0x89, 0x3e, 0xf1, 0x25, 0x4d, 0xa1, 0xb4, 0x5c, 0xe6, 0xb3, 0x7c, 0x30, 0x78, 12679 0x96, 0x9e, 0x48, 0x74, 0x9e, 0x53, 0xc7, 0x47, 0x95, 0xb1, 0x20, 0x03, 0x0e, 0x69, 0xe0, 0x7d, 12680 0x41, 0xe2, 0x2b, 0xd1, 0xf9, 0xf4, 0x56, 0x9f, 0xae, 0x2f, 0xc8, 0x37, 0xed, 0xa5, 0xf5, 0x05, 12681 0x05, 0x20, 0x4f, 0x7e, 0x97, 0xfe, 0xcf, 0x1c, 0xcc, 0xf8, 0xcc, 0x99, 0xfb, 0x82, 0x12, 0x44, 12682 0x7e, 0xd9, 0x5f, 0x3d, 0xb8, 0xbf, 0xfa, 0x6b, 0x09, 0x26, 0xfc, 0xa5, 0xfb, 0xbf, 0xd7, 0xab, 12683 0xe3, 0xdb, 0x96, 0x72, 0x7b, 0xf8, 0xdb, 0x5c, 0x70, 0x02, 0xff, 0xef, 0x1b, 0x46, 0x7e, 0x7a, 12684 0x53, 0xb4, 0xfc, 0x6d, 0x1e, 0xa6, 0xa2, 0xa7, 0x31, 0xd4, 0x57, 0x20, 0x0d, 0xec, 0x2b, 0x68, 12685 0xc0, 0xec, 0x6e, 0x4f, 0xd3, 0xfa, 0x7c, 0x19, 0x02, 0xcd, 0x05, 0xce, 0x77, 0xc1, 0xd7, 0x84, 12686 0xe4, 0xec, 0x4a, 0x02, 0x0f, 0x4e, 0x94, 0x4c, 0xe9, 0x91, 0xc8, 0x9f, 0xa9, 0x47, 0x22, 0xf6, 12687 0xc9, 0xbe, 0x70, 0x8a, 0x4f, 0xf6, 0x89, 0xfd, 0x0e, 0x43, 0x67, 0xe8, 0x77, 0x38, 0x4b, 0x83, 12688 0x42, 0x42, 0x10, 0x1b, 0xd8, 0x2f, 0xfb, 0x1a, 0x5c, 0x12, 0x62, 0x36, 0xef, 0x1d, 0xd0, 0x6d, 12689 0xcb, 0xd0, 0x34, 0x62, 0x2d, 0xf7, 0xba, 0xdd, 0xbe, 0xfc, 0x0e, 0x4c, 0x84, 0xbb, 0x62, 0x9c, 12690 0x9d, 0x76, 0x1a, 0x73, 0xc4, 0xd7, 0xd9, 0xc0, 0x4e, 0x3b, 0xe3, 0xd8, 0xe3, 0x90, 0x7f, 0x5f, 12691 0x82, 0xb9, 0xe4, 0xee, 0x57, 0xa4, 0xc1, 0x44, 0x57, 0x39, 0x0c, 0x76, 0x24, 0x4b, 0x67, 0x7c, 12692 0x37, 0xe3, 0xed, 0x10, 0xeb, 0x21, 0x2c, 0x1c, 0xc1, 0x96, 0x7f, 0x94, 0x60, 0x3e, 0xa5, 0x11, 12693 0xe1, 0x7c, 0x2d, 0x41, 0x1f, 0x41, 0xa9, 0xab, 0x1c, 0x36, 0x7b, 0x56, 0x87, 0x9c, 0xf9, 0xa5, 12694 0x90, 0x47, 0x8c, 0x75, 0x81, 0x82, 0x3d, 0x3c, 0xf9, 0x2f, 0x25, 0xf8, 0x59, 0x6a, 0xf5, 0x84, 12695 0xee, 0x85, 0x7a, 0x26, 0xe4, 0x48, 0xcf, 0x04, 0x8a, 0x0b, 0xbe, 0xa2, 0x96, 0x89, 0x2f, 0x25, 12696 0x28, 0xa7, 0xdd, 0x2c, 0xd1, 0xdd, 0x90, 0x91, 0x3f, 0x8f, 0x18, 0x39, 0x1d, 0x93, 0x7b, 0x45, 12697 0x36, 0xfe, 0xab, 0x04, 0x97, 0x4f, 0xa8, 0xd0, 0xbc, 0xab, 0x12, 0x69, 0x07, 0xb9, 0xf8, 0xa3, 12698 0xb6, 0xf8, 0x22, 0xe6, 0x5f, 0x95, 0x12, 0x78, 0x70, 0xaa, 0x34, 0xda, 0x86, 0x79, 0x71, 0x4f, 12699 0x8b, 0xd2, 0x44, 0xf1, 0xc1, 0x5b, 0xcb, 0x96, 0x93, 0x59, 0x70, 0x9a, 0xac, 0xfc, 0x37, 0x12, 12700 0xcc, 0x25, 0x3f, 0x19, 0xa0, 0xb7, 0x43, 0x4b, 0x5e, 0x89, 0x2c, 0xf9, 0x64, 0x44, 0x4a, 0x2c, 12701 0xf8, 0x27, 0x30, 0x21, 0x1e, 0x16, 0x04, 0x8c, 0x70, 0x66, 0x39, 0x29, 0x45, 0x09, 0x08, 0xb7, 12702 0xbc, 0xe5, 0xc7, 0x24, 0x3c, 0x86, 0x23, 0x68, 0xf2, 0x1f, 0xe4, 0x60, 0xa8, 0xd9, 0x52, 0x34, 12703 0x72, 0x0e, 0xd5, 0xed, 0xfb, 0xa1, 0xea, 0x76, 0xd0, 0x3f, 0x6d, 0x71, 0xab, 0x52, 0x0b, 0x5b, 12704 0x1c, 0x29, 0x6c, 0xdf, 0xcc, 0x84, 0x76, 0x72, 0x4d, 0xfb, 0x6b, 0x30, 0xe2, 0x29, 0x3d, 0x5d, 12705 0xaa, 0x95, 0xff, 0x22, 0x07, 0xa3, 0x01, 0x15, 0xa7, 0x4c, 0xd4, 0xbb, 0xa1, 0x02, 0x27, 0x9f, 12706 0xe1, 0xee, 0x16, 0xd0, 0x55, 0x75, 0x4b, 0x1a, 0xa7, 0xe9, 0xd8, 0x6f, 0x33, 0x8d, 0x57, 0x3a, 12707 0xef, 0xc0, 0x84, 0xad, 0x58, 0x1d, 0x62, 0x7b, 0x9f, 0x35, 0xf2, 0xdc, 0x17, 0xbd, 0x56, 0xf5, 12708 0xad, 0x10, 0x15, 0x47, 0xb8, 0x2f, 0x3d, 0x84, 0xf1, 0x90, 0xb2, 0x53, 0xf5, 0x0c, 0xff, 0xbd, 12709 0x04, 0x3f, 0x1f, 0xf8, 0xe8, 0x84, 0xea, 0xa1, 0x43, 0x52, 0x8d, 0x1c, 0x92, 0x85, 0x74, 0x80, 12710 0x57, 0xd7, 0x7b, 0x56, 0xbf, 0xf9, 0xfc, 0x87, 0x85, 0x0b, 0xdf, 0xfd, 0xb0, 0x70, 0xe1, 0xfb, 12711 0x1f, 0x16, 0x2e, 0xfc, 0xee, 0xf1, 0x82, 0xf4, 0xfc, 0x78, 0x41, 0xfa, 0xee, 0x78, 0x41, 0xfa, 12712 0xfe, 0x78, 0x41, 0xfa, 0xf7, 0xe3, 0x05, 0xe9, 0x4f, 0x7e, 0x5c, 0xb8, 0xf0, 0x51, 0x51, 0xc0, 12713 0xfd, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd3, 0xd0, 0x60, 0xbe, 0x07, 0x3e, 0x00, 0x00, 12714} 12715