blob: 4439535dcb401236bad5b09c3e5b327e06090366 [file] [log] [blame]
Scott Bakere7144bc2019-10-01 14:16:47 -07001/*
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:
girishke7ca43b2019-10-10 12:30:03 +000027 AllowedCSIDriver
Scott Bakere7144bc2019-10-01 14:16:47 -070028 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
girishke7ca43b2019-10-10 12:30:03 +000078 RuntimeClassStrategyOptions
Scott Bakere7144bc2019-10-01 14:16:47 -070079 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
girishke7ca43b2019-10-10 12:30:03 +0000114func (m *AllowedCSIDriver) Reset() { *m = AllowedCSIDriver{} }
115func (*AllowedCSIDriver) ProtoMessage() {}
116func (*AllowedCSIDriver) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
117
Scott Bakere7144bc2019-10-01 14:16:47 -0700118func (m *AllowedFlexVolume) Reset() { *m = AllowedFlexVolume{} }
119func (*AllowedFlexVolume) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000120func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700121
122func (m *AllowedHostPath) Reset() { *m = AllowedHostPath{} }
123func (*AllowedHostPath) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000124func (*AllowedHostPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700125
126func (m *DaemonSet) Reset() { *m = DaemonSet{} }
127func (*DaemonSet) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000128func (*DaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700129
130func (m *DaemonSetCondition) Reset() { *m = DaemonSetCondition{} }
131func (*DaemonSetCondition) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000132func (*DaemonSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700133
134func (m *DaemonSetList) Reset() { *m = DaemonSetList{} }
135func (*DaemonSetList) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000136func (*DaemonSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700137
138func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} }
139func (*DaemonSetSpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000140func (*DaemonSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700141
142func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} }
143func (*DaemonSetStatus) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000144func (*DaemonSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700145
146func (m *DaemonSetUpdateStrategy) Reset() { *m = DaemonSetUpdateStrategy{} }
147func (*DaemonSetUpdateStrategy) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000148func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700149
150func (m *Deployment) Reset() { *m = Deployment{} }
151func (*Deployment) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000152func (*Deployment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700153
154func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} }
155func (*DeploymentCondition) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000156func (*DeploymentCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700157
158func (m *DeploymentList) Reset() { *m = DeploymentList{} }
159func (*DeploymentList) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000160func (*DeploymentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700161
162func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} }
163func (*DeploymentRollback) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000164func (*DeploymentRollback) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700165
166func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} }
167func (*DeploymentSpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000168func (*DeploymentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700169
170func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} }
171func (*DeploymentStatus) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000172func (*DeploymentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700173
174func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} }
175func (*DeploymentStrategy) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000176func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700177
178func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} }
179func (*FSGroupStrategyOptions) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000180func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700181
182func (m *HTTPIngressPath) Reset() { *m = HTTPIngressPath{} }
183func (*HTTPIngressPath) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000184func (*HTTPIngressPath) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700185
186func (m *HTTPIngressRuleValue) Reset() { *m = HTTPIngressRuleValue{} }
187func (*HTTPIngressRuleValue) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000188func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700189
190func (m *HostPortRange) Reset() { *m = HostPortRange{} }
191func (*HostPortRange) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000192func (*HostPortRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700193
194func (m *IDRange) Reset() { *m = IDRange{} }
195func (*IDRange) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000196func (*IDRange) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700197
198func (m *IPBlock) Reset() { *m = IPBlock{} }
199func (*IPBlock) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000200func (*IPBlock) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700201
202func (m *Ingress) Reset() { *m = Ingress{} }
203func (*Ingress) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000204func (*Ingress) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700205
206func (m *IngressBackend) Reset() { *m = IngressBackend{} }
207func (*IngressBackend) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000208func (*IngressBackend) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700209
210func (m *IngressList) Reset() { *m = IngressList{} }
211func (*IngressList) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000212func (*IngressList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700213
214func (m *IngressRule) Reset() { *m = IngressRule{} }
215func (*IngressRule) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000216func (*IngressRule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700217
218func (m *IngressRuleValue) Reset() { *m = IngressRuleValue{} }
219func (*IngressRuleValue) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000220func (*IngressRuleValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700221
222func (m *IngressSpec) Reset() { *m = IngressSpec{} }
223func (*IngressSpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000224func (*IngressSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700225
226func (m *IngressStatus) Reset() { *m = IngressStatus{} }
227func (*IngressStatus) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000228func (*IngressStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{28} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700229
230func (m *IngressTLS) Reset() { *m = IngressTLS{} }
231func (*IngressTLS) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000232func (*IngressTLS) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700233
234func (m *NetworkPolicy) Reset() { *m = NetworkPolicy{} }
235func (*NetworkPolicy) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000236func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700237
238func (m *NetworkPolicyEgressRule) Reset() { *m = NetworkPolicyEgressRule{} }
239func (*NetworkPolicyEgressRule) ProtoMessage() {}
240func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000241 return fileDescriptorGenerated, []int{31}
Scott Bakere7144bc2019-10-01 14:16:47 -0700242}
243
244func (m *NetworkPolicyIngressRule) Reset() { *m = NetworkPolicyIngressRule{} }
245func (*NetworkPolicyIngressRule) ProtoMessage() {}
246func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000247 return fileDescriptorGenerated, []int{32}
Scott Bakere7144bc2019-10-01 14:16:47 -0700248}
249
250func (m *NetworkPolicyList) Reset() { *m = NetworkPolicyList{} }
251func (*NetworkPolicyList) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000252func (*NetworkPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700253
254func (m *NetworkPolicyPeer) Reset() { *m = NetworkPolicyPeer{} }
255func (*NetworkPolicyPeer) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000256func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700257
258func (m *NetworkPolicyPort) Reset() { *m = NetworkPolicyPort{} }
259func (*NetworkPolicyPort) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000260func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700261
262func (m *NetworkPolicySpec) Reset() { *m = NetworkPolicySpec{} }
263func (*NetworkPolicySpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000264func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700265
266func (m *PodSecurityPolicy) Reset() { *m = PodSecurityPolicy{} }
267func (*PodSecurityPolicy) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000268func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{37} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700269
270func (m *PodSecurityPolicyList) Reset() { *m = PodSecurityPolicyList{} }
271func (*PodSecurityPolicyList) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000272func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{38} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700273
274func (m *PodSecurityPolicySpec) Reset() { *m = PodSecurityPolicySpec{} }
275func (*PodSecurityPolicySpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000276func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{39} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700277
278func (m *ReplicaSet) Reset() { *m = ReplicaSet{} }
279func (*ReplicaSet) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000280func (*ReplicaSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{40} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700281
282func (m *ReplicaSetCondition) Reset() { *m = ReplicaSetCondition{} }
283func (*ReplicaSetCondition) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000284func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{41} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700285
286func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} }
287func (*ReplicaSetList) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000288func (*ReplicaSetList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{42} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700289
290func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} }
291func (*ReplicaSetSpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000292func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{43} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700293
294func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} }
295func (*ReplicaSetStatus) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000296func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{44} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700297
298func (m *ReplicationControllerDummy) Reset() { *m = ReplicationControllerDummy{} }
299func (*ReplicationControllerDummy) ProtoMessage() {}
300func (*ReplicationControllerDummy) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000301 return fileDescriptorGenerated, []int{45}
Scott Bakere7144bc2019-10-01 14:16:47 -0700302}
303
304func (m *RollbackConfig) Reset() { *m = RollbackConfig{} }
305func (*RollbackConfig) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000306func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{46} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700307
308func (m *RollingUpdateDaemonSet) Reset() { *m = RollingUpdateDaemonSet{} }
309func (*RollingUpdateDaemonSet) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000310func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{47} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700311
312func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} }
313func (*RollingUpdateDeployment) ProtoMessage() {}
314func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000315 return fileDescriptorGenerated, []int{48}
Scott Bakere7144bc2019-10-01 14:16:47 -0700316}
317
318func (m *RunAsGroupStrategyOptions) Reset() { *m = RunAsGroupStrategyOptions{} }
319func (*RunAsGroupStrategyOptions) ProtoMessage() {}
320func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000321 return fileDescriptorGenerated, []int{49}
Scott Bakere7144bc2019-10-01 14:16:47 -0700322}
323
324func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} }
325func (*RunAsUserStrategyOptions) ProtoMessage() {}
326func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000327 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}
Scott Bakere7144bc2019-10-01 14:16:47 -0700334}
335
336func (m *SELinuxStrategyOptions) Reset() { *m = SELinuxStrategyOptions{} }
337func (*SELinuxStrategyOptions) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000338func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{52} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700339
340func (m *Scale) Reset() { *m = Scale{} }
341func (*Scale) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000342func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{53} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700343
344func (m *ScaleSpec) Reset() { *m = ScaleSpec{} }
345func (*ScaleSpec) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000346func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{54} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700347
348func (m *ScaleStatus) Reset() { *m = ScaleStatus{} }
349func (*ScaleStatus) ProtoMessage() {}
girishke7ca43b2019-10-10 12:30:03 +0000350func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{55} }
Scott Bakere7144bc2019-10-01 14:16:47 -0700351
352func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} }
353func (*SupplementalGroupsStrategyOptions) ProtoMessage() {}
354func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) {
girishke7ca43b2019-10-10 12:30:03 +0000355 return fileDescriptorGenerated, []int{56}
Scott Bakere7144bc2019-10-01 14:16:47 -0700356}
357
358func init() {
girishke7ca43b2019-10-10 12:30:03 +0000359 proto.RegisterType((*AllowedCSIDriver)(nil), "k8s.io.api.extensions.v1beta1.AllowedCSIDriver")
Scott Bakere7144bc2019-10-01 14:16:47 -0700360 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")
girishke7ca43b2019-10-10 12:30:03 +0000410 proto.RegisterType((*RuntimeClassStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RuntimeClassStrategyOptions")
Scott Bakere7144bc2019-10-01 14:16:47 -0700411 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}
girishke7ca43b2019-10-10 12:30:03 +0000417func (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
Scott Bakere7144bc2019-10-01 14:16:47 -0700439func (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 }
girishke7ca43b2019-10-10 12:30:03 +00002215 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 }
Scott Bakere7144bc2019-10-01 14:16:47 -07002241 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()))
girishke7ca43b2019-10-10 12:30:03 +00002262 n49, err := m.ObjectMeta.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002263 if err != nil {
2264 return 0, err
2265 }
2266 i += n49
girishke7ca43b2019-10-10 12:30:03 +00002267 dAtA[i] = 0x12
Scott Bakere7144bc2019-10-01 14:16:47 -07002268 i++
girishke7ca43b2019-10-10 12:30:03 +00002269 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2270 n50, err := m.Spec.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002271 if err != nil {
2272 return 0, err
2273 }
2274 i += n50
girishke7ca43b2019-10-10 12:30:03 +00002275 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
Scott Bakere7144bc2019-10-01 14:16:47 -07002283 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()))
girishke7ca43b2019-10-10 12:30:03 +00002312 n52, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002313 if err != nil {
2314 return 0, err
2315 }
girishke7ca43b2019-10-10 12:30:03 +00002316 i += n52
Scott Bakere7144bc2019-10-01 14:16:47 -07002317 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()))
girishke7ca43b2019-10-10 12:30:03 +00002346 n53, err := m.ListMeta.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002347 if err != nil {
2348 return 0, err
2349 }
girishke7ca43b2019-10-10 12:30:03 +00002350 i += n53
Scott Bakere7144bc2019-10-01 14:16:47 -07002351 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()))
girishke7ca43b2019-10-10 12:30:03 +00002390 n54, err := m.Selector.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002391 if err != nil {
2392 return 0, err
2393 }
girishke7ca43b2019-10-10 12:30:03 +00002394 i += n54
Scott Bakere7144bc2019-10-01 14:16:47 -07002395 }
2396 dAtA[i] = 0x1a
2397 i++
2398 i = encodeVarintGenerated(dAtA, i, uint64(m.Template.Size()))
girishke7ca43b2019-10-10 12:30:03 +00002399 n55, err := m.Template.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002400 if err != nil {
2401 return 0, err
2402 }
girishke7ca43b2019-10-10 12:30:03 +00002403 i += n55
Scott Bakere7144bc2019-10-01 14:16:47 -07002404 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()))
girishke7ca43b2019-10-10 12:30:03 +00002513 n56, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002514 if err != nil {
2515 return 0, err
2516 }
girishke7ca43b2019-10-10 12:30:03 +00002517 i += n56
Scott Bakere7144bc2019-10-01 14:16:47 -07002518 }
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()))
girishke7ca43b2019-10-10 12:30:03 +00002541 n57, err := m.MaxUnavailable.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002542 if err != nil {
2543 return 0, err
2544 }
girishke7ca43b2019-10-10 12:30:03 +00002545 i += n57
Scott Bakere7144bc2019-10-01 14:16:47 -07002546 }
2547 if m.MaxSurge != nil {
2548 dAtA[i] = 0x12
2549 i++
2550 i = encodeVarintGenerated(dAtA, i, uint64(m.MaxSurge.Size()))
girishke7ca43b2019-10-10 12:30:03 +00002551 n58, err := m.MaxSurge.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002552 if err != nil {
2553 return 0, err
2554 }
girishke7ca43b2019-10-10 12:30:03 +00002555 i += n58
Scott Bakere7144bc2019-10-01 14:16:47 -07002556 }
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
girishke7ca43b2019-10-10 12:30:03 +00002628func (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
Scott Bakere7144bc2019-10-01 14:16:47 -07002667func (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()))
girishke7ca43b2019-10-10 12:30:03 +00002690 n59, err := m.SELinuxOptions.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002691 if err != nil {
2692 return 0, err
2693 }
girishke7ca43b2019-10-10 12:30:03 +00002694 i += n59
Scott Bakere7144bc2019-10-01 14:16:47 -07002695 }
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()))
girishke7ca43b2019-10-10 12:30:03 +00002717 n60, err := m.ObjectMeta.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002718 if err != nil {
2719 return 0, err
2720 }
2721 i += n60
girishke7ca43b2019-10-10 12:30:03 +00002722 dAtA[i] = 0x12
Scott Bakere7144bc2019-10-01 14:16:47 -07002723 i++
girishke7ca43b2019-10-10 12:30:03 +00002724 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
2725 n61, err := m.Spec.MarshalTo(dAtA[i:])
Scott Bakere7144bc2019-10-01 14:16:47 -07002726 if err != nil {
2727 return 0, err
2728 }
2729 i += n61
girishke7ca43b2019-10-10 12:30:03 +00002730 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
Scott Bakere7144bc2019-10-01 14:16:47 -07002738 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}
girishke7ca43b2019-10-10 12:30:03 +00002852func (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
Scott Bakere7144bc2019-10-01 14:16:47 -07002860func (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 }
girishke7ca43b2019-10-10 12:30:03 +00003491 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 }
Scott Bakere7144bc2019-10-01 14:16:47 -07003501 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
girishke7ca43b2019-10-10 12:30:03 +00003644func (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
Scott Bakere7144bc2019-10-01 14:16:47 -07003660func (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}
girishke7ca43b2019-10-10 12:30:03 +00003735func (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}
Scott Bakere7144bc2019-10-01 14:16:47 -07003745func (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) + `,`,
girishke7ca43b2019-10-10 12:30:03 +00004236 `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) + `,`,
Scott Bakere7144bc2019-10-01 14:16:47 -07004238 `}`,
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}
girishke7ca43b2019-10-10 12:30:03 +00004369func (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}
Scott Bakere7144bc2019-10-01 14:16:47 -07004380func (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}
girishke7ca43b2019-10-10 12:30:03 +00004454func (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}
Scott Bakere7144bc2019-10-01 14:16:47 -07004533func (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
girishke7ca43b2019-10-10 12:30:03 +000010218 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
Scott Bakere7144bc2019-10-01 14:16:47 -070010282 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}
girishke7ca43b2019-10-10 12:30:03 +000011616func (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}
Scott Bakere7144bc2019-10-01 14:16:47 -070011725func (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{
girishke7ca43b2019-10-10 12:30:03 +000012482 // 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,
Scott Bakere7144bc2019-10-01 14:16:47 -070012714}