1
16
17
18
19
20 package v1alpha1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
29 k8s_io_api_core_v1 "k8s.io/api/core/v1"
30 v11 "k8s.io/api/core/v1"
31 k8s_io_apimachinery_pkg_api_resource "k8s.io/apimachinery/pkg/api/resource"
32 resource "k8s.io/apimachinery/pkg/api/resource"
33
34 math "math"
35 math_bits "math/bits"
36 reflect "reflect"
37 strings "strings"
38 )
39
40
41 var _ = proto.Marshal
42 var _ = fmt.Errorf
43 var _ = math.Inf
44
45
46
47
48
49 const _ = proto.GoGoProtoPackageIsVersion3
50
51 func (m *Overhead) Reset() { *m = Overhead{} }
52 func (*Overhead) ProtoMessage() {}
53 func (*Overhead) Descriptor() ([]byte, []int) {
54 return fileDescriptor_a8fee97bf5273e47, []int{0}
55 }
56 func (m *Overhead) XXX_Unmarshal(b []byte) error {
57 return m.Unmarshal(b)
58 }
59 func (m *Overhead) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
60 b = b[:cap(b)]
61 n, err := m.MarshalToSizedBuffer(b)
62 if err != nil {
63 return nil, err
64 }
65 return b[:n], nil
66 }
67 func (m *Overhead) XXX_Merge(src proto.Message) {
68 xxx_messageInfo_Overhead.Merge(m, src)
69 }
70 func (m *Overhead) XXX_Size() int {
71 return m.Size()
72 }
73 func (m *Overhead) XXX_DiscardUnknown() {
74 xxx_messageInfo_Overhead.DiscardUnknown(m)
75 }
76
77 var xxx_messageInfo_Overhead proto.InternalMessageInfo
78
79 func (m *RuntimeClass) Reset() { *m = RuntimeClass{} }
80 func (*RuntimeClass) ProtoMessage() {}
81 func (*RuntimeClass) Descriptor() ([]byte, []int) {
82 return fileDescriptor_a8fee97bf5273e47, []int{1}
83 }
84 func (m *RuntimeClass) XXX_Unmarshal(b []byte) error {
85 return m.Unmarshal(b)
86 }
87 func (m *RuntimeClass) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
88 b = b[:cap(b)]
89 n, err := m.MarshalToSizedBuffer(b)
90 if err != nil {
91 return nil, err
92 }
93 return b[:n], nil
94 }
95 func (m *RuntimeClass) XXX_Merge(src proto.Message) {
96 xxx_messageInfo_RuntimeClass.Merge(m, src)
97 }
98 func (m *RuntimeClass) XXX_Size() int {
99 return m.Size()
100 }
101 func (m *RuntimeClass) XXX_DiscardUnknown() {
102 xxx_messageInfo_RuntimeClass.DiscardUnknown(m)
103 }
104
105 var xxx_messageInfo_RuntimeClass proto.InternalMessageInfo
106
107 func (m *RuntimeClassList) Reset() { *m = RuntimeClassList{} }
108 func (*RuntimeClassList) ProtoMessage() {}
109 func (*RuntimeClassList) Descriptor() ([]byte, []int) {
110 return fileDescriptor_a8fee97bf5273e47, []int{2}
111 }
112 func (m *RuntimeClassList) XXX_Unmarshal(b []byte) error {
113 return m.Unmarshal(b)
114 }
115 func (m *RuntimeClassList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
116 b = b[:cap(b)]
117 n, err := m.MarshalToSizedBuffer(b)
118 if err != nil {
119 return nil, err
120 }
121 return b[:n], nil
122 }
123 func (m *RuntimeClassList) XXX_Merge(src proto.Message) {
124 xxx_messageInfo_RuntimeClassList.Merge(m, src)
125 }
126 func (m *RuntimeClassList) XXX_Size() int {
127 return m.Size()
128 }
129 func (m *RuntimeClassList) XXX_DiscardUnknown() {
130 xxx_messageInfo_RuntimeClassList.DiscardUnknown(m)
131 }
132
133 var xxx_messageInfo_RuntimeClassList proto.InternalMessageInfo
134
135 func (m *RuntimeClassSpec) Reset() { *m = RuntimeClassSpec{} }
136 func (*RuntimeClassSpec) ProtoMessage() {}
137 func (*RuntimeClassSpec) Descriptor() ([]byte, []int) {
138 return fileDescriptor_a8fee97bf5273e47, []int{3}
139 }
140 func (m *RuntimeClassSpec) XXX_Unmarshal(b []byte) error {
141 return m.Unmarshal(b)
142 }
143 func (m *RuntimeClassSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
144 b = b[:cap(b)]
145 n, err := m.MarshalToSizedBuffer(b)
146 if err != nil {
147 return nil, err
148 }
149 return b[:n], nil
150 }
151 func (m *RuntimeClassSpec) XXX_Merge(src proto.Message) {
152 xxx_messageInfo_RuntimeClassSpec.Merge(m, src)
153 }
154 func (m *RuntimeClassSpec) XXX_Size() int {
155 return m.Size()
156 }
157 func (m *RuntimeClassSpec) XXX_DiscardUnknown() {
158 xxx_messageInfo_RuntimeClassSpec.DiscardUnknown(m)
159 }
160
161 var xxx_messageInfo_RuntimeClassSpec proto.InternalMessageInfo
162
163 func (m *Scheduling) Reset() { *m = Scheduling{} }
164 func (*Scheduling) ProtoMessage() {}
165 func (*Scheduling) Descriptor() ([]byte, []int) {
166 return fileDescriptor_a8fee97bf5273e47, []int{4}
167 }
168 func (m *Scheduling) XXX_Unmarshal(b []byte) error {
169 return m.Unmarshal(b)
170 }
171 func (m *Scheduling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
172 b = b[:cap(b)]
173 n, err := m.MarshalToSizedBuffer(b)
174 if err != nil {
175 return nil, err
176 }
177 return b[:n], nil
178 }
179 func (m *Scheduling) XXX_Merge(src proto.Message) {
180 xxx_messageInfo_Scheduling.Merge(m, src)
181 }
182 func (m *Scheduling) XXX_Size() int {
183 return m.Size()
184 }
185 func (m *Scheduling) XXX_DiscardUnknown() {
186 xxx_messageInfo_Scheduling.DiscardUnknown(m)
187 }
188
189 var xxx_messageInfo_Scheduling proto.InternalMessageInfo
190
191 func init() {
192 proto.RegisterType((*Overhead)(nil), "k8s.io.api.node.v1alpha1.Overhead")
193 proto.RegisterMapType((k8s_io_api_core_v1.ResourceList)(nil), "k8s.io.api.node.v1alpha1.Overhead.PodFixedEntry")
194 proto.RegisterType((*RuntimeClass)(nil), "k8s.io.api.node.v1alpha1.RuntimeClass")
195 proto.RegisterType((*RuntimeClassList)(nil), "k8s.io.api.node.v1alpha1.RuntimeClassList")
196 proto.RegisterType((*RuntimeClassSpec)(nil), "k8s.io.api.node.v1alpha1.RuntimeClassSpec")
197 proto.RegisterType((*Scheduling)(nil), "k8s.io.api.node.v1alpha1.Scheduling")
198 proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.node.v1alpha1.Scheduling.NodeSelectorEntry")
199 }
200
201 func init() {
202 proto.RegisterFile("k8s.io/api/node/v1alpha1/generated.proto", fileDescriptor_a8fee97bf5273e47)
203 }
204
205 var fileDescriptor_a8fee97bf5273e47 = []byte{
206
207 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x3d, 0x6f, 0xd3, 0x4c,
208 0x1c, 0xcf, 0xa5, 0xad, 0x94, 0x5e, 0xd2, 0xaa, 0x8f, 0x9f, 0x0a, 0x45, 0x19, 0x9c, 0xca, 0x42,
209 0x28, 0x42, 0xea, 0x99, 0x56, 0xa8, 0xaa, 0x18, 0x8a, 0x64, 0x5e, 0x04, 0xa2, 0xb4, 0x70, 0x2d,
210 0x0b, 0x62, 0xe0, 0x6a, 0x1f, 0x8e, 0x89, 0xed, 0xb3, 0xec, 0x73, 0x44, 0x36, 0xc4, 0x82, 0xc4,
211 0xc4, 0xc4, 0xb7, 0x81, 0xb9, 0x63, 0x27, 0xd4, 0xa9, 0xa5, 0xe1, 0x3b, 0x30, 0x30, 0xa1, 0xb3,
212 0xcf, 0xc9, 0x25, 0x69, 0x68, 0xd8, 0x7c, 0x77, 0xbf, 0x97, 0xff, 0x6b, 0x02, 0x5b, 0x9d, 0xed,
213 0x04, 0x79, 0xcc, 0x24, 0x91, 0x67, 0x86, 0xcc, 0xa1, 0x66, 0x77, 0x83, 0xf8, 0x51, 0x9b, 0x6c,
214 0x98, 0x2e, 0x0d, 0x69, 0x4c, 0x38, 0x75, 0x50, 0x14, 0x33, 0xce, 0xb4, 0x7a, 0x8e, 0x44, 0x24,
215 0xf2, 0x90, 0x40, 0xa2, 0x02, 0xd9, 0x58, 0x77, 0x3d, 0xde, 0x4e, 0x8f, 0x90, 0xcd, 0x02, 0xd3,
216 0x65, 0x2e, 0x33, 0x33, 0xc2, 0x51, 0xfa, 0x26, 0x3b, 0x65, 0x87, 0xec, 0x2b, 0x17, 0x6a, 0x18,
217 0x8a, 0xa5, 0xcd, 0x62, 0x61, 0x39, 0x6e, 0xd6, 0xb8, 0x3d, 0xc4, 0x04, 0xc4, 0x6e, 0x7b, 0x21,
218 0x8d, 0x7b, 0x66, 0xd4, 0x71, 0x33, 0x52, 0x4c, 0x13, 0x96, 0xc6, 0x36, 0xfd, 0x27, 0x56, 0x62,
219 0x06, 0x94, 0x93, 0xcb, 0xbc, 0xcc, 0x69, 0xac, 0x38, 0x0d, 0xb9, 0x17, 0x4c, 0xda, 0x6c, 0x5d,
220 0x45, 0x48, 0xec, 0x36, 0x0d, 0xc8, 0x38, 0xcf, 0x38, 0x29, 0xc3, 0xca, 0x7e, 0x97, 0xc6, 0x6d,
221 0x4a, 0x1c, 0xed, 0x3b, 0x80, 0x95, 0x88, 0x39, 0x0f, 0xbd, 0x77, 0xd4, 0xa9, 0x83, 0xb5, 0xb9,
222 0x56, 0x75, 0xf3, 0x16, 0x9a, 0x56, 0x62, 0x54, 0xd0, 0xd0, 0x33, 0x49, 0x79, 0x10, 0xf2, 0xb8,
223 0x67, 0x7d, 0x04, 0xc7, 0x67, 0xcd, 0x52, 0xff, 0xac, 0x59, 0x29, 0xee, 0x7f, 0x9f, 0x35, 0x9b,
224 0x93, 0xf5, 0x45, 0x58, 0x96, 0x6c, 0xd7, 0x4b, 0xf8, 0x87, 0xf3, 0xbf, 0x42, 0xf6, 0x48, 0x40,
225 0x3f, 0x9d, 0x37, 0xd7, 0x67, 0xe9, 0x00, 0x7a, 0x9e, 0x92, 0x90, 0x7b, 0xbc, 0x87, 0x07, 0xb9,
226 0x34, 0x3a, 0x70, 0x69, 0x24, 0x48, 0x6d, 0x05, 0xce, 0x75, 0x68, 0xaf, 0x0e, 0xd6, 0x40, 0x6b,
227 0x11, 0x8b, 0x4f, 0xed, 0x3e, 0x5c, 0xe8, 0x12, 0x3f, 0xa5, 0xf5, 0xf2, 0x1a, 0x68, 0x55, 0x37,
228 0x91, 0x92, 0xf7, 0xc0, 0x0b, 0x45, 0x1d, 0x37, 0x2b, 0xc4, 0xa4, 0x57, 0x4e, 0xbe, 0x53, 0xde,
229 0x06, 0xc6, 0x37, 0x00, 0x6b, 0x38, 0xaf, 0xfa, 0x3d, 0x9f, 0x24, 0x89, 0xf6, 0x1a, 0x56, 0x44,
230 0x9f, 0x1d, 0xc2, 0x49, 0xe6, 0x38, 0x5a, 0xd5, 0x09, 0xf5, 0x04, 0x09, 0x34, 0xea, 0x6e, 0xa0,
231 0xfd, 0xa3, 0xb7, 0xd4, 0xe6, 0x4f, 0x29, 0x27, 0x96, 0x26, 0x8b, 0x0a, 0x87, 0x77, 0x78, 0xa0,
232 0xaa, 0xed, 0xc2, 0xf9, 0x24, 0xa2, 0xb6, 0x8c, 0xfd, 0xe6, 0xf4, 0x9e, 0xa9, 0x71, 0x1d, 0x44,
233 0xd4, 0xb6, 0x6a, 0x52, 0x77, 0x5e, 0x9c, 0x70, 0xa6, 0x62, 0x7c, 0x05, 0x70, 0x45, 0x05, 0x8a,
234 0x06, 0x69, 0xaf, 0x26, 0x92, 0x40, 0xb3, 0x25, 0x21, 0xd8, 0x59, 0x0a, 0x2b, 0xc5, 0x5c, 0x14,
235 0x37, 0x4a, 0x02, 0x4f, 0xe0, 0x82, 0xc7, 0x69, 0x90, 0xd4, 0xcb, 0xd9, 0xd4, 0xdd, 0x98, 0x2d,
236 0x03, 0x6b, 0x49, 0x4a, 0x2e, 0x3c, 0x16, 0x64, 0x9c, 0x6b, 0x18, 0xbf, 0xc6, 0xe2, 0x17, 0xa9,
237 0x69, 0x3b, 0x70, 0x59, 0xae, 0xc2, 0x23, 0x12, 0x3a, 0x3e, 0x8d, 0xf3, 0xe6, 0x5b, 0xd7, 0xa4,
238 0xc4, 0x32, 0x1e, 0x79, 0xc5, 0x63, 0x68, 0x6d, 0x17, 0x56, 0x98, 0x1c, 0x78, 0x59, 0x66, 0xe3,
239 0xea, 0xd5, 0xb0, 0x6a, 0x22, 0xdf, 0xe2, 0x84, 0x07, 0x0a, 0xda, 0x21, 0x84, 0x62, 0x21, 0x9d,
240 0xd4, 0xf7, 0x42, 0xb7, 0x3e, 0x97, 0xe9, 0x5d, 0x9f, 0xae, 0x77, 0x30, 0xc0, 0x5a, 0xcb, 0x62,
241 0x08, 0x86, 0x67, 0xac, 0xe8, 0x18, 0x5f, 0xca, 0x50, 0x79, 0xd2, 0x22, 0x58, 0x13, 0x32, 0x07,
242 0xd4, 0xa7, 0x36, 0x67, 0xb1, 0xdc, 0xe8, 0xad, 0x59, 0x6c, 0xd0, 0x9e, 0x42, 0xcc, 0xf7, 0x7a,
243 0x55, 0x16, 0xaa, 0xa6, 0x3e, 0xe1, 0x11, 0x07, 0xed, 0x05, 0xac, 0x72, 0xe6, 0x8b, 0x1f, 0x18,
244 0x8f, 0x85, 0x45, 0x33, 0x75, 0xd5, 0x50, 0x6c, 0xb6, 0x98, 0x8a, 0xc3, 0x01, 0xcc, 0xfa, 0x5f,
245 0x0a, 0x57, 0x87, 0x77, 0x09, 0x56, 0x75, 0x1a, 0x77, 0xe1, 0x7f, 0x13, 0xf1, 0x5c, 0xb2, 0xc2,
246 0xab, 0xea, 0x0a, 0x2f, 0x2a, 0x2b, 0x69, 0xed, 0x1c, 0x5f, 0xe8, 0xa5, 0x93, 0x0b, 0xbd, 0x74,
247 0x7a, 0xa1, 0x97, 0xde, 0xf7, 0x75, 0x70, 0xdc, 0xd7, 0xc1, 0x49, 0x5f, 0x07, 0xa7, 0x7d, 0x1d,
248 0xfc, 0xe8, 0xeb, 0xe0, 0xf3, 0x4f, 0xbd, 0xf4, 0xb2, 0x3e, 0xed, 0x7f, 0xe7, 0x4f, 0x00, 0x00,
249 0x00, 0xff, 0xff, 0xa7, 0x9b, 0x7f, 0x45, 0x92, 0x06, 0x00, 0x00,
250 }
251
252 func (m *Overhead) Marshal() (dAtA []byte, err error) {
253 size := m.Size()
254 dAtA = make([]byte, size)
255 n, err := m.MarshalToSizedBuffer(dAtA[:size])
256 if err != nil {
257 return nil, err
258 }
259 return dAtA[:n], nil
260 }
261
262 func (m *Overhead) MarshalTo(dAtA []byte) (int, error) {
263 size := m.Size()
264 return m.MarshalToSizedBuffer(dAtA[:size])
265 }
266
267 func (m *Overhead) MarshalToSizedBuffer(dAtA []byte) (int, error) {
268 i := len(dAtA)
269 _ = i
270 var l int
271 _ = l
272 if len(m.PodFixed) > 0 {
273 keysForPodFixed := make([]string, 0, len(m.PodFixed))
274 for k := range m.PodFixed {
275 keysForPodFixed = append(keysForPodFixed, string(k))
276 }
277 github_com_gogo_protobuf_sortkeys.Strings(keysForPodFixed)
278 for iNdEx := len(keysForPodFixed) - 1; iNdEx >= 0; iNdEx-- {
279 v := m.PodFixed[k8s_io_api_core_v1.ResourceName(keysForPodFixed[iNdEx])]
280 baseI := i
281 {
282 size, err := ((*resource.Quantity)(&v)).MarshalToSizedBuffer(dAtA[:i])
283 if err != nil {
284 return 0, err
285 }
286 i -= size
287 i = encodeVarintGenerated(dAtA, i, uint64(size))
288 }
289 i--
290 dAtA[i] = 0x12
291 i -= len(keysForPodFixed[iNdEx])
292 copy(dAtA[i:], keysForPodFixed[iNdEx])
293 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForPodFixed[iNdEx])))
294 i--
295 dAtA[i] = 0xa
296 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
297 i--
298 dAtA[i] = 0xa
299 }
300 }
301 return len(dAtA) - i, nil
302 }
303
304 func (m *RuntimeClass) Marshal() (dAtA []byte, err error) {
305 size := m.Size()
306 dAtA = make([]byte, size)
307 n, err := m.MarshalToSizedBuffer(dAtA[:size])
308 if err != nil {
309 return nil, err
310 }
311 return dAtA[:n], nil
312 }
313
314 func (m *RuntimeClass) MarshalTo(dAtA []byte) (int, error) {
315 size := m.Size()
316 return m.MarshalToSizedBuffer(dAtA[:size])
317 }
318
319 func (m *RuntimeClass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
320 i := len(dAtA)
321 _ = i
322 var l int
323 _ = l
324 {
325 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
326 if err != nil {
327 return 0, err
328 }
329 i -= size
330 i = encodeVarintGenerated(dAtA, i, uint64(size))
331 }
332 i--
333 dAtA[i] = 0x12
334 {
335 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
336 if err != nil {
337 return 0, err
338 }
339 i -= size
340 i = encodeVarintGenerated(dAtA, i, uint64(size))
341 }
342 i--
343 dAtA[i] = 0xa
344 return len(dAtA) - i, nil
345 }
346
347 func (m *RuntimeClassList) Marshal() (dAtA []byte, err error) {
348 size := m.Size()
349 dAtA = make([]byte, size)
350 n, err := m.MarshalToSizedBuffer(dAtA[:size])
351 if err != nil {
352 return nil, err
353 }
354 return dAtA[:n], nil
355 }
356
357 func (m *RuntimeClassList) MarshalTo(dAtA []byte) (int, error) {
358 size := m.Size()
359 return m.MarshalToSizedBuffer(dAtA[:size])
360 }
361
362 func (m *RuntimeClassList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
363 i := len(dAtA)
364 _ = i
365 var l int
366 _ = l
367 if len(m.Items) > 0 {
368 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
369 {
370 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
371 if err != nil {
372 return 0, err
373 }
374 i -= size
375 i = encodeVarintGenerated(dAtA, i, uint64(size))
376 }
377 i--
378 dAtA[i] = 0x12
379 }
380 }
381 {
382 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
383 if err != nil {
384 return 0, err
385 }
386 i -= size
387 i = encodeVarintGenerated(dAtA, i, uint64(size))
388 }
389 i--
390 dAtA[i] = 0xa
391 return len(dAtA) - i, nil
392 }
393
394 func (m *RuntimeClassSpec) Marshal() (dAtA []byte, err error) {
395 size := m.Size()
396 dAtA = make([]byte, size)
397 n, err := m.MarshalToSizedBuffer(dAtA[:size])
398 if err != nil {
399 return nil, err
400 }
401 return dAtA[:n], nil
402 }
403
404 func (m *RuntimeClassSpec) MarshalTo(dAtA []byte) (int, error) {
405 size := m.Size()
406 return m.MarshalToSizedBuffer(dAtA[:size])
407 }
408
409 func (m *RuntimeClassSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
410 i := len(dAtA)
411 _ = i
412 var l int
413 _ = l
414 if m.Scheduling != nil {
415 {
416 size, err := m.Scheduling.MarshalToSizedBuffer(dAtA[:i])
417 if err != nil {
418 return 0, err
419 }
420 i -= size
421 i = encodeVarintGenerated(dAtA, i, uint64(size))
422 }
423 i--
424 dAtA[i] = 0x1a
425 }
426 if m.Overhead != nil {
427 {
428 size, err := m.Overhead.MarshalToSizedBuffer(dAtA[:i])
429 if err != nil {
430 return 0, err
431 }
432 i -= size
433 i = encodeVarintGenerated(dAtA, i, uint64(size))
434 }
435 i--
436 dAtA[i] = 0x12
437 }
438 i -= len(m.RuntimeHandler)
439 copy(dAtA[i:], m.RuntimeHandler)
440 i = encodeVarintGenerated(dAtA, i, uint64(len(m.RuntimeHandler)))
441 i--
442 dAtA[i] = 0xa
443 return len(dAtA) - i, nil
444 }
445
446 func (m *Scheduling) Marshal() (dAtA []byte, err error) {
447 size := m.Size()
448 dAtA = make([]byte, size)
449 n, err := m.MarshalToSizedBuffer(dAtA[:size])
450 if err != nil {
451 return nil, err
452 }
453 return dAtA[:n], nil
454 }
455
456 func (m *Scheduling) MarshalTo(dAtA []byte) (int, error) {
457 size := m.Size()
458 return m.MarshalToSizedBuffer(dAtA[:size])
459 }
460
461 func (m *Scheduling) MarshalToSizedBuffer(dAtA []byte) (int, error) {
462 i := len(dAtA)
463 _ = i
464 var l int
465 _ = l
466 if len(m.Tolerations) > 0 {
467 for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
468 {
469 size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
470 if err != nil {
471 return 0, err
472 }
473 i -= size
474 i = encodeVarintGenerated(dAtA, i, uint64(size))
475 }
476 i--
477 dAtA[i] = 0x12
478 }
479 }
480 if len(m.NodeSelector) > 0 {
481 keysForNodeSelector := make([]string, 0, len(m.NodeSelector))
482 for k := range m.NodeSelector {
483 keysForNodeSelector = append(keysForNodeSelector, string(k))
484 }
485 github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
486 for iNdEx := len(keysForNodeSelector) - 1; iNdEx >= 0; iNdEx-- {
487 v := m.NodeSelector[string(keysForNodeSelector[iNdEx])]
488 baseI := i
489 i -= len(v)
490 copy(dAtA[i:], v)
491 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
492 i--
493 dAtA[i] = 0x12
494 i -= len(keysForNodeSelector[iNdEx])
495 copy(dAtA[i:], keysForNodeSelector[iNdEx])
496 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForNodeSelector[iNdEx])))
497 i--
498 dAtA[i] = 0xa
499 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
500 i--
501 dAtA[i] = 0xa
502 }
503 }
504 return len(dAtA) - i, nil
505 }
506
507 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
508 offset -= sovGenerated(v)
509 base := offset
510 for v >= 1<<7 {
511 dAtA[offset] = uint8(v&0x7f | 0x80)
512 v >>= 7
513 offset++
514 }
515 dAtA[offset] = uint8(v)
516 return base
517 }
518 func (m *Overhead) Size() (n int) {
519 if m == nil {
520 return 0
521 }
522 var l int
523 _ = l
524 if len(m.PodFixed) > 0 {
525 for k, v := range m.PodFixed {
526 _ = k
527 _ = v
528 l = ((*resource.Quantity)(&v)).Size()
529 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
530 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
531 }
532 }
533 return n
534 }
535
536 func (m *RuntimeClass) Size() (n int) {
537 if m == nil {
538 return 0
539 }
540 var l int
541 _ = l
542 l = m.ObjectMeta.Size()
543 n += 1 + l + sovGenerated(uint64(l))
544 l = m.Spec.Size()
545 n += 1 + l + sovGenerated(uint64(l))
546 return n
547 }
548
549 func (m *RuntimeClassList) Size() (n int) {
550 if m == nil {
551 return 0
552 }
553 var l int
554 _ = l
555 l = m.ListMeta.Size()
556 n += 1 + l + sovGenerated(uint64(l))
557 if len(m.Items) > 0 {
558 for _, e := range m.Items {
559 l = e.Size()
560 n += 1 + l + sovGenerated(uint64(l))
561 }
562 }
563 return n
564 }
565
566 func (m *RuntimeClassSpec) Size() (n int) {
567 if m == nil {
568 return 0
569 }
570 var l int
571 _ = l
572 l = len(m.RuntimeHandler)
573 n += 1 + l + sovGenerated(uint64(l))
574 if m.Overhead != nil {
575 l = m.Overhead.Size()
576 n += 1 + l + sovGenerated(uint64(l))
577 }
578 if m.Scheduling != nil {
579 l = m.Scheduling.Size()
580 n += 1 + l + sovGenerated(uint64(l))
581 }
582 return n
583 }
584
585 func (m *Scheduling) Size() (n int) {
586 if m == nil {
587 return 0
588 }
589 var l int
590 _ = l
591 if len(m.NodeSelector) > 0 {
592 for k, v := range m.NodeSelector {
593 _ = k
594 _ = v
595 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
596 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
597 }
598 }
599 if len(m.Tolerations) > 0 {
600 for _, e := range m.Tolerations {
601 l = e.Size()
602 n += 1 + l + sovGenerated(uint64(l))
603 }
604 }
605 return n
606 }
607
608 func sovGenerated(x uint64) (n int) {
609 return (math_bits.Len64(x|1) + 6) / 7
610 }
611 func sozGenerated(x uint64) (n int) {
612 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
613 }
614 func (this *Overhead) String() string {
615 if this == nil {
616 return "nil"
617 }
618 keysForPodFixed := make([]string, 0, len(this.PodFixed))
619 for k := range this.PodFixed {
620 keysForPodFixed = append(keysForPodFixed, string(k))
621 }
622 github_com_gogo_protobuf_sortkeys.Strings(keysForPodFixed)
623 mapStringForPodFixed := "k8s_io_api_core_v1.ResourceList{"
624 for _, k := range keysForPodFixed {
625 mapStringForPodFixed += fmt.Sprintf("%v: %v,", k, this.PodFixed[k8s_io_api_core_v1.ResourceName(k)])
626 }
627 mapStringForPodFixed += "}"
628 s := strings.Join([]string{`&Overhead{`,
629 `PodFixed:` + mapStringForPodFixed + `,`,
630 `}`,
631 }, "")
632 return s
633 }
634 func (this *RuntimeClass) String() string {
635 if this == nil {
636 return "nil"
637 }
638 s := strings.Join([]string{`&RuntimeClass{`,
639 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
640 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "RuntimeClassSpec", "RuntimeClassSpec", 1), `&`, ``, 1) + `,`,
641 `}`,
642 }, "")
643 return s
644 }
645 func (this *RuntimeClassList) String() string {
646 if this == nil {
647 return "nil"
648 }
649 repeatedStringForItems := "[]RuntimeClass{"
650 for _, f := range this.Items {
651 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "RuntimeClass", "RuntimeClass", 1), `&`, ``, 1) + ","
652 }
653 repeatedStringForItems += "}"
654 s := strings.Join([]string{`&RuntimeClassList{`,
655 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
656 `Items:` + repeatedStringForItems + `,`,
657 `}`,
658 }, "")
659 return s
660 }
661 func (this *RuntimeClassSpec) String() string {
662 if this == nil {
663 return "nil"
664 }
665 s := strings.Join([]string{`&RuntimeClassSpec{`,
666 `RuntimeHandler:` + fmt.Sprintf("%v", this.RuntimeHandler) + `,`,
667 `Overhead:` + strings.Replace(this.Overhead.String(), "Overhead", "Overhead", 1) + `,`,
668 `Scheduling:` + strings.Replace(this.Scheduling.String(), "Scheduling", "Scheduling", 1) + `,`,
669 `}`,
670 }, "")
671 return s
672 }
673 func (this *Scheduling) String() string {
674 if this == nil {
675 return "nil"
676 }
677 repeatedStringForTolerations := "[]Toleration{"
678 for _, f := range this.Tolerations {
679 repeatedStringForTolerations += fmt.Sprintf("%v", f) + ","
680 }
681 repeatedStringForTolerations += "}"
682 keysForNodeSelector := make([]string, 0, len(this.NodeSelector))
683 for k := range this.NodeSelector {
684 keysForNodeSelector = append(keysForNodeSelector, k)
685 }
686 github_com_gogo_protobuf_sortkeys.Strings(keysForNodeSelector)
687 mapStringForNodeSelector := "map[string]string{"
688 for _, k := range keysForNodeSelector {
689 mapStringForNodeSelector += fmt.Sprintf("%v: %v,", k, this.NodeSelector[k])
690 }
691 mapStringForNodeSelector += "}"
692 s := strings.Join([]string{`&Scheduling{`,
693 `NodeSelector:` + mapStringForNodeSelector + `,`,
694 `Tolerations:` + repeatedStringForTolerations + `,`,
695 `}`,
696 }, "")
697 return s
698 }
699 func valueToStringGenerated(v interface{}) string {
700 rv := reflect.ValueOf(v)
701 if rv.IsNil() {
702 return "nil"
703 }
704 pv := reflect.Indirect(rv).Interface()
705 return fmt.Sprintf("*%v", pv)
706 }
707 func (m *Overhead) Unmarshal(dAtA []byte) error {
708 l := len(dAtA)
709 iNdEx := 0
710 for iNdEx < l {
711 preIndex := iNdEx
712 var wire uint64
713 for shift := uint(0); ; shift += 7 {
714 if shift >= 64 {
715 return ErrIntOverflowGenerated
716 }
717 if iNdEx >= l {
718 return io.ErrUnexpectedEOF
719 }
720 b := dAtA[iNdEx]
721 iNdEx++
722 wire |= uint64(b&0x7F) << shift
723 if b < 0x80 {
724 break
725 }
726 }
727 fieldNum := int32(wire >> 3)
728 wireType := int(wire & 0x7)
729 if wireType == 4 {
730 return fmt.Errorf("proto: Overhead: wiretype end group for non-group")
731 }
732 if fieldNum <= 0 {
733 return fmt.Errorf("proto: Overhead: illegal tag %d (wire type %d)", fieldNum, wire)
734 }
735 switch fieldNum {
736 case 1:
737 if wireType != 2 {
738 return fmt.Errorf("proto: wrong wireType = %d for field PodFixed", wireType)
739 }
740 var msglen int
741 for shift := uint(0); ; shift += 7 {
742 if shift >= 64 {
743 return ErrIntOverflowGenerated
744 }
745 if iNdEx >= l {
746 return io.ErrUnexpectedEOF
747 }
748 b := dAtA[iNdEx]
749 iNdEx++
750 msglen |= int(b&0x7F) << shift
751 if b < 0x80 {
752 break
753 }
754 }
755 if msglen < 0 {
756 return ErrInvalidLengthGenerated
757 }
758 postIndex := iNdEx + msglen
759 if postIndex < 0 {
760 return ErrInvalidLengthGenerated
761 }
762 if postIndex > l {
763 return io.ErrUnexpectedEOF
764 }
765 if m.PodFixed == nil {
766 m.PodFixed = make(k8s_io_api_core_v1.ResourceList)
767 }
768 var mapkey k8s_io_api_core_v1.ResourceName
769 mapvalue := &resource.Quantity{}
770 for iNdEx < postIndex {
771 entryPreIndex := iNdEx
772 var wire uint64
773 for shift := uint(0); ; shift += 7 {
774 if shift >= 64 {
775 return ErrIntOverflowGenerated
776 }
777 if iNdEx >= l {
778 return io.ErrUnexpectedEOF
779 }
780 b := dAtA[iNdEx]
781 iNdEx++
782 wire |= uint64(b&0x7F) << shift
783 if b < 0x80 {
784 break
785 }
786 }
787 fieldNum := int32(wire >> 3)
788 if fieldNum == 1 {
789 var stringLenmapkey uint64
790 for shift := uint(0); ; shift += 7 {
791 if shift >= 64 {
792 return ErrIntOverflowGenerated
793 }
794 if iNdEx >= l {
795 return io.ErrUnexpectedEOF
796 }
797 b := dAtA[iNdEx]
798 iNdEx++
799 stringLenmapkey |= uint64(b&0x7F) << shift
800 if b < 0x80 {
801 break
802 }
803 }
804 intStringLenmapkey := int(stringLenmapkey)
805 if intStringLenmapkey < 0 {
806 return ErrInvalidLengthGenerated
807 }
808 postStringIndexmapkey := iNdEx + intStringLenmapkey
809 if postStringIndexmapkey < 0 {
810 return ErrInvalidLengthGenerated
811 }
812 if postStringIndexmapkey > l {
813 return io.ErrUnexpectedEOF
814 }
815 mapkey = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postStringIndexmapkey])
816 iNdEx = postStringIndexmapkey
817 } else if fieldNum == 2 {
818 var mapmsglen int
819 for shift := uint(0); ; shift += 7 {
820 if shift >= 64 {
821 return ErrIntOverflowGenerated
822 }
823 if iNdEx >= l {
824 return io.ErrUnexpectedEOF
825 }
826 b := dAtA[iNdEx]
827 iNdEx++
828 mapmsglen |= int(b&0x7F) << shift
829 if b < 0x80 {
830 break
831 }
832 }
833 if mapmsglen < 0 {
834 return ErrInvalidLengthGenerated
835 }
836 postmsgIndex := iNdEx + mapmsglen
837 if postmsgIndex < 0 {
838 return ErrInvalidLengthGenerated
839 }
840 if postmsgIndex > l {
841 return io.ErrUnexpectedEOF
842 }
843 mapvalue = &resource.Quantity{}
844 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
845 return err
846 }
847 iNdEx = postmsgIndex
848 } else {
849 iNdEx = entryPreIndex
850 skippy, err := skipGenerated(dAtA[iNdEx:])
851 if err != nil {
852 return err
853 }
854 if (skippy < 0) || (iNdEx+skippy) < 0 {
855 return ErrInvalidLengthGenerated
856 }
857 if (iNdEx + skippy) > postIndex {
858 return io.ErrUnexpectedEOF
859 }
860 iNdEx += skippy
861 }
862 }
863 m.PodFixed[k8s_io_api_core_v1.ResourceName(mapkey)] = ((k8s_io_apimachinery_pkg_api_resource.Quantity)(*mapvalue))
864 iNdEx = postIndex
865 default:
866 iNdEx = preIndex
867 skippy, err := skipGenerated(dAtA[iNdEx:])
868 if err != nil {
869 return err
870 }
871 if (skippy < 0) || (iNdEx+skippy) < 0 {
872 return ErrInvalidLengthGenerated
873 }
874 if (iNdEx + skippy) > l {
875 return io.ErrUnexpectedEOF
876 }
877 iNdEx += skippy
878 }
879 }
880
881 if iNdEx > l {
882 return io.ErrUnexpectedEOF
883 }
884 return nil
885 }
886 func (m *RuntimeClass) Unmarshal(dAtA []byte) error {
887 l := len(dAtA)
888 iNdEx := 0
889 for iNdEx < l {
890 preIndex := iNdEx
891 var wire uint64
892 for shift := uint(0); ; shift += 7 {
893 if shift >= 64 {
894 return ErrIntOverflowGenerated
895 }
896 if iNdEx >= l {
897 return io.ErrUnexpectedEOF
898 }
899 b := dAtA[iNdEx]
900 iNdEx++
901 wire |= uint64(b&0x7F) << shift
902 if b < 0x80 {
903 break
904 }
905 }
906 fieldNum := int32(wire >> 3)
907 wireType := int(wire & 0x7)
908 if wireType == 4 {
909 return fmt.Errorf("proto: RuntimeClass: wiretype end group for non-group")
910 }
911 if fieldNum <= 0 {
912 return fmt.Errorf("proto: RuntimeClass: illegal tag %d (wire type %d)", fieldNum, wire)
913 }
914 switch fieldNum {
915 case 1:
916 if wireType != 2 {
917 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
918 }
919 var msglen int
920 for shift := uint(0); ; shift += 7 {
921 if shift >= 64 {
922 return ErrIntOverflowGenerated
923 }
924 if iNdEx >= l {
925 return io.ErrUnexpectedEOF
926 }
927 b := dAtA[iNdEx]
928 iNdEx++
929 msglen |= int(b&0x7F) << shift
930 if b < 0x80 {
931 break
932 }
933 }
934 if msglen < 0 {
935 return ErrInvalidLengthGenerated
936 }
937 postIndex := iNdEx + msglen
938 if postIndex < 0 {
939 return ErrInvalidLengthGenerated
940 }
941 if postIndex > l {
942 return io.ErrUnexpectedEOF
943 }
944 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
945 return err
946 }
947 iNdEx = postIndex
948 case 2:
949 if wireType != 2 {
950 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
951 }
952 var msglen int
953 for shift := uint(0); ; shift += 7 {
954 if shift >= 64 {
955 return ErrIntOverflowGenerated
956 }
957 if iNdEx >= l {
958 return io.ErrUnexpectedEOF
959 }
960 b := dAtA[iNdEx]
961 iNdEx++
962 msglen |= int(b&0x7F) << shift
963 if b < 0x80 {
964 break
965 }
966 }
967 if msglen < 0 {
968 return ErrInvalidLengthGenerated
969 }
970 postIndex := iNdEx + msglen
971 if postIndex < 0 {
972 return ErrInvalidLengthGenerated
973 }
974 if postIndex > l {
975 return io.ErrUnexpectedEOF
976 }
977 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
978 return err
979 }
980 iNdEx = postIndex
981 default:
982 iNdEx = preIndex
983 skippy, err := skipGenerated(dAtA[iNdEx:])
984 if err != nil {
985 return err
986 }
987 if (skippy < 0) || (iNdEx+skippy) < 0 {
988 return ErrInvalidLengthGenerated
989 }
990 if (iNdEx + skippy) > l {
991 return io.ErrUnexpectedEOF
992 }
993 iNdEx += skippy
994 }
995 }
996
997 if iNdEx > l {
998 return io.ErrUnexpectedEOF
999 }
1000 return nil
1001 }
1002 func (m *RuntimeClassList) Unmarshal(dAtA []byte) error {
1003 l := len(dAtA)
1004 iNdEx := 0
1005 for iNdEx < l {
1006 preIndex := iNdEx
1007 var wire uint64
1008 for shift := uint(0); ; shift += 7 {
1009 if shift >= 64 {
1010 return ErrIntOverflowGenerated
1011 }
1012 if iNdEx >= l {
1013 return io.ErrUnexpectedEOF
1014 }
1015 b := dAtA[iNdEx]
1016 iNdEx++
1017 wire |= uint64(b&0x7F) << shift
1018 if b < 0x80 {
1019 break
1020 }
1021 }
1022 fieldNum := int32(wire >> 3)
1023 wireType := int(wire & 0x7)
1024 if wireType == 4 {
1025 return fmt.Errorf("proto: RuntimeClassList: wiretype end group for non-group")
1026 }
1027 if fieldNum <= 0 {
1028 return fmt.Errorf("proto: RuntimeClassList: illegal tag %d (wire type %d)", fieldNum, wire)
1029 }
1030 switch fieldNum {
1031 case 1:
1032 if wireType != 2 {
1033 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1034 }
1035 var msglen int
1036 for shift := uint(0); ; shift += 7 {
1037 if shift >= 64 {
1038 return ErrIntOverflowGenerated
1039 }
1040 if iNdEx >= l {
1041 return io.ErrUnexpectedEOF
1042 }
1043 b := dAtA[iNdEx]
1044 iNdEx++
1045 msglen |= int(b&0x7F) << shift
1046 if b < 0x80 {
1047 break
1048 }
1049 }
1050 if msglen < 0 {
1051 return ErrInvalidLengthGenerated
1052 }
1053 postIndex := iNdEx + msglen
1054 if postIndex < 0 {
1055 return ErrInvalidLengthGenerated
1056 }
1057 if postIndex > l {
1058 return io.ErrUnexpectedEOF
1059 }
1060 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1061 return err
1062 }
1063 iNdEx = postIndex
1064 case 2:
1065 if wireType != 2 {
1066 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1067 }
1068 var msglen int
1069 for shift := uint(0); ; shift += 7 {
1070 if shift >= 64 {
1071 return ErrIntOverflowGenerated
1072 }
1073 if iNdEx >= l {
1074 return io.ErrUnexpectedEOF
1075 }
1076 b := dAtA[iNdEx]
1077 iNdEx++
1078 msglen |= int(b&0x7F) << shift
1079 if b < 0x80 {
1080 break
1081 }
1082 }
1083 if msglen < 0 {
1084 return ErrInvalidLengthGenerated
1085 }
1086 postIndex := iNdEx + msglen
1087 if postIndex < 0 {
1088 return ErrInvalidLengthGenerated
1089 }
1090 if postIndex > l {
1091 return io.ErrUnexpectedEOF
1092 }
1093 m.Items = append(m.Items, RuntimeClass{})
1094 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1095 return err
1096 }
1097 iNdEx = postIndex
1098 default:
1099 iNdEx = preIndex
1100 skippy, err := skipGenerated(dAtA[iNdEx:])
1101 if err != nil {
1102 return err
1103 }
1104 if (skippy < 0) || (iNdEx+skippy) < 0 {
1105 return ErrInvalidLengthGenerated
1106 }
1107 if (iNdEx + skippy) > l {
1108 return io.ErrUnexpectedEOF
1109 }
1110 iNdEx += skippy
1111 }
1112 }
1113
1114 if iNdEx > l {
1115 return io.ErrUnexpectedEOF
1116 }
1117 return nil
1118 }
1119 func (m *RuntimeClassSpec) Unmarshal(dAtA []byte) error {
1120 l := len(dAtA)
1121 iNdEx := 0
1122 for iNdEx < l {
1123 preIndex := iNdEx
1124 var wire uint64
1125 for shift := uint(0); ; shift += 7 {
1126 if shift >= 64 {
1127 return ErrIntOverflowGenerated
1128 }
1129 if iNdEx >= l {
1130 return io.ErrUnexpectedEOF
1131 }
1132 b := dAtA[iNdEx]
1133 iNdEx++
1134 wire |= uint64(b&0x7F) << shift
1135 if b < 0x80 {
1136 break
1137 }
1138 }
1139 fieldNum := int32(wire >> 3)
1140 wireType := int(wire & 0x7)
1141 if wireType == 4 {
1142 return fmt.Errorf("proto: RuntimeClassSpec: wiretype end group for non-group")
1143 }
1144 if fieldNum <= 0 {
1145 return fmt.Errorf("proto: RuntimeClassSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1146 }
1147 switch fieldNum {
1148 case 1:
1149 if wireType != 2 {
1150 return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandler", wireType)
1151 }
1152 var stringLen uint64
1153 for shift := uint(0); ; shift += 7 {
1154 if shift >= 64 {
1155 return ErrIntOverflowGenerated
1156 }
1157 if iNdEx >= l {
1158 return io.ErrUnexpectedEOF
1159 }
1160 b := dAtA[iNdEx]
1161 iNdEx++
1162 stringLen |= uint64(b&0x7F) << shift
1163 if b < 0x80 {
1164 break
1165 }
1166 }
1167 intStringLen := int(stringLen)
1168 if intStringLen < 0 {
1169 return ErrInvalidLengthGenerated
1170 }
1171 postIndex := iNdEx + intStringLen
1172 if postIndex < 0 {
1173 return ErrInvalidLengthGenerated
1174 }
1175 if postIndex > l {
1176 return io.ErrUnexpectedEOF
1177 }
1178 m.RuntimeHandler = string(dAtA[iNdEx:postIndex])
1179 iNdEx = postIndex
1180 case 2:
1181 if wireType != 2 {
1182 return fmt.Errorf("proto: wrong wireType = %d for field Overhead", wireType)
1183 }
1184 var msglen int
1185 for shift := uint(0); ; shift += 7 {
1186 if shift >= 64 {
1187 return ErrIntOverflowGenerated
1188 }
1189 if iNdEx >= l {
1190 return io.ErrUnexpectedEOF
1191 }
1192 b := dAtA[iNdEx]
1193 iNdEx++
1194 msglen |= int(b&0x7F) << shift
1195 if b < 0x80 {
1196 break
1197 }
1198 }
1199 if msglen < 0 {
1200 return ErrInvalidLengthGenerated
1201 }
1202 postIndex := iNdEx + msglen
1203 if postIndex < 0 {
1204 return ErrInvalidLengthGenerated
1205 }
1206 if postIndex > l {
1207 return io.ErrUnexpectedEOF
1208 }
1209 if m.Overhead == nil {
1210 m.Overhead = &Overhead{}
1211 }
1212 if err := m.Overhead.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1213 return err
1214 }
1215 iNdEx = postIndex
1216 case 3:
1217 if wireType != 2 {
1218 return fmt.Errorf("proto: wrong wireType = %d for field Scheduling", wireType)
1219 }
1220 var msglen int
1221 for shift := uint(0); ; shift += 7 {
1222 if shift >= 64 {
1223 return ErrIntOverflowGenerated
1224 }
1225 if iNdEx >= l {
1226 return io.ErrUnexpectedEOF
1227 }
1228 b := dAtA[iNdEx]
1229 iNdEx++
1230 msglen |= int(b&0x7F) << shift
1231 if b < 0x80 {
1232 break
1233 }
1234 }
1235 if msglen < 0 {
1236 return ErrInvalidLengthGenerated
1237 }
1238 postIndex := iNdEx + msglen
1239 if postIndex < 0 {
1240 return ErrInvalidLengthGenerated
1241 }
1242 if postIndex > l {
1243 return io.ErrUnexpectedEOF
1244 }
1245 if m.Scheduling == nil {
1246 m.Scheduling = &Scheduling{}
1247 }
1248 if err := m.Scheduling.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1249 return err
1250 }
1251 iNdEx = postIndex
1252 default:
1253 iNdEx = preIndex
1254 skippy, err := skipGenerated(dAtA[iNdEx:])
1255 if err != nil {
1256 return err
1257 }
1258 if (skippy < 0) || (iNdEx+skippy) < 0 {
1259 return ErrInvalidLengthGenerated
1260 }
1261 if (iNdEx + skippy) > l {
1262 return io.ErrUnexpectedEOF
1263 }
1264 iNdEx += skippy
1265 }
1266 }
1267
1268 if iNdEx > l {
1269 return io.ErrUnexpectedEOF
1270 }
1271 return nil
1272 }
1273 func (m *Scheduling) Unmarshal(dAtA []byte) error {
1274 l := len(dAtA)
1275 iNdEx := 0
1276 for iNdEx < l {
1277 preIndex := iNdEx
1278 var wire uint64
1279 for shift := uint(0); ; shift += 7 {
1280 if shift >= 64 {
1281 return ErrIntOverflowGenerated
1282 }
1283 if iNdEx >= l {
1284 return io.ErrUnexpectedEOF
1285 }
1286 b := dAtA[iNdEx]
1287 iNdEx++
1288 wire |= uint64(b&0x7F) << shift
1289 if b < 0x80 {
1290 break
1291 }
1292 }
1293 fieldNum := int32(wire >> 3)
1294 wireType := int(wire & 0x7)
1295 if wireType == 4 {
1296 return fmt.Errorf("proto: Scheduling: wiretype end group for non-group")
1297 }
1298 if fieldNum <= 0 {
1299 return fmt.Errorf("proto: Scheduling: illegal tag %d (wire type %d)", fieldNum, wire)
1300 }
1301 switch fieldNum {
1302 case 1:
1303 if wireType != 2 {
1304 return fmt.Errorf("proto: wrong wireType = %d for field NodeSelector", wireType)
1305 }
1306 var msglen int
1307 for shift := uint(0); ; shift += 7 {
1308 if shift >= 64 {
1309 return ErrIntOverflowGenerated
1310 }
1311 if iNdEx >= l {
1312 return io.ErrUnexpectedEOF
1313 }
1314 b := dAtA[iNdEx]
1315 iNdEx++
1316 msglen |= int(b&0x7F) << shift
1317 if b < 0x80 {
1318 break
1319 }
1320 }
1321 if msglen < 0 {
1322 return ErrInvalidLengthGenerated
1323 }
1324 postIndex := iNdEx + msglen
1325 if postIndex < 0 {
1326 return ErrInvalidLengthGenerated
1327 }
1328 if postIndex > l {
1329 return io.ErrUnexpectedEOF
1330 }
1331 if m.NodeSelector == nil {
1332 m.NodeSelector = make(map[string]string)
1333 }
1334 var mapkey string
1335 var mapvalue string
1336 for iNdEx < postIndex {
1337 entryPreIndex := iNdEx
1338 var wire uint64
1339 for shift := uint(0); ; shift += 7 {
1340 if shift >= 64 {
1341 return ErrIntOverflowGenerated
1342 }
1343 if iNdEx >= l {
1344 return io.ErrUnexpectedEOF
1345 }
1346 b := dAtA[iNdEx]
1347 iNdEx++
1348 wire |= uint64(b&0x7F) << shift
1349 if b < 0x80 {
1350 break
1351 }
1352 }
1353 fieldNum := int32(wire >> 3)
1354 if fieldNum == 1 {
1355 var stringLenmapkey uint64
1356 for shift := uint(0); ; shift += 7 {
1357 if shift >= 64 {
1358 return ErrIntOverflowGenerated
1359 }
1360 if iNdEx >= l {
1361 return io.ErrUnexpectedEOF
1362 }
1363 b := dAtA[iNdEx]
1364 iNdEx++
1365 stringLenmapkey |= uint64(b&0x7F) << shift
1366 if b < 0x80 {
1367 break
1368 }
1369 }
1370 intStringLenmapkey := int(stringLenmapkey)
1371 if intStringLenmapkey < 0 {
1372 return ErrInvalidLengthGenerated
1373 }
1374 postStringIndexmapkey := iNdEx + intStringLenmapkey
1375 if postStringIndexmapkey < 0 {
1376 return ErrInvalidLengthGenerated
1377 }
1378 if postStringIndexmapkey > l {
1379 return io.ErrUnexpectedEOF
1380 }
1381 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1382 iNdEx = postStringIndexmapkey
1383 } else if fieldNum == 2 {
1384 var stringLenmapvalue uint64
1385 for shift := uint(0); ; shift += 7 {
1386 if shift >= 64 {
1387 return ErrIntOverflowGenerated
1388 }
1389 if iNdEx >= l {
1390 return io.ErrUnexpectedEOF
1391 }
1392 b := dAtA[iNdEx]
1393 iNdEx++
1394 stringLenmapvalue |= uint64(b&0x7F) << shift
1395 if b < 0x80 {
1396 break
1397 }
1398 }
1399 intStringLenmapvalue := int(stringLenmapvalue)
1400 if intStringLenmapvalue < 0 {
1401 return ErrInvalidLengthGenerated
1402 }
1403 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
1404 if postStringIndexmapvalue < 0 {
1405 return ErrInvalidLengthGenerated
1406 }
1407 if postStringIndexmapvalue > l {
1408 return io.ErrUnexpectedEOF
1409 }
1410 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
1411 iNdEx = postStringIndexmapvalue
1412 } else {
1413 iNdEx = entryPreIndex
1414 skippy, err := skipGenerated(dAtA[iNdEx:])
1415 if err != nil {
1416 return err
1417 }
1418 if (skippy < 0) || (iNdEx+skippy) < 0 {
1419 return ErrInvalidLengthGenerated
1420 }
1421 if (iNdEx + skippy) > postIndex {
1422 return io.ErrUnexpectedEOF
1423 }
1424 iNdEx += skippy
1425 }
1426 }
1427 m.NodeSelector[mapkey] = mapvalue
1428 iNdEx = postIndex
1429 case 2:
1430 if wireType != 2 {
1431 return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
1432 }
1433 var msglen int
1434 for shift := uint(0); ; shift += 7 {
1435 if shift >= 64 {
1436 return ErrIntOverflowGenerated
1437 }
1438 if iNdEx >= l {
1439 return io.ErrUnexpectedEOF
1440 }
1441 b := dAtA[iNdEx]
1442 iNdEx++
1443 msglen |= int(b&0x7F) << shift
1444 if b < 0x80 {
1445 break
1446 }
1447 }
1448 if msglen < 0 {
1449 return ErrInvalidLengthGenerated
1450 }
1451 postIndex := iNdEx + msglen
1452 if postIndex < 0 {
1453 return ErrInvalidLengthGenerated
1454 }
1455 if postIndex > l {
1456 return io.ErrUnexpectedEOF
1457 }
1458 m.Tolerations = append(m.Tolerations, v11.Toleration{})
1459 if err := m.Tolerations[len(m.Tolerations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1460 return err
1461 }
1462 iNdEx = postIndex
1463 default:
1464 iNdEx = preIndex
1465 skippy, err := skipGenerated(dAtA[iNdEx:])
1466 if err != nil {
1467 return err
1468 }
1469 if (skippy < 0) || (iNdEx+skippy) < 0 {
1470 return ErrInvalidLengthGenerated
1471 }
1472 if (iNdEx + skippy) > l {
1473 return io.ErrUnexpectedEOF
1474 }
1475 iNdEx += skippy
1476 }
1477 }
1478
1479 if iNdEx > l {
1480 return io.ErrUnexpectedEOF
1481 }
1482 return nil
1483 }
1484 func skipGenerated(dAtA []byte) (n int, err error) {
1485 l := len(dAtA)
1486 iNdEx := 0
1487 depth := 0
1488 for iNdEx < l {
1489 var wire uint64
1490 for shift := uint(0); ; shift += 7 {
1491 if shift >= 64 {
1492 return 0, ErrIntOverflowGenerated
1493 }
1494 if iNdEx >= l {
1495 return 0, io.ErrUnexpectedEOF
1496 }
1497 b := dAtA[iNdEx]
1498 iNdEx++
1499 wire |= (uint64(b) & 0x7F) << shift
1500 if b < 0x80 {
1501 break
1502 }
1503 }
1504 wireType := int(wire & 0x7)
1505 switch wireType {
1506 case 0:
1507 for shift := uint(0); ; shift += 7 {
1508 if shift >= 64 {
1509 return 0, ErrIntOverflowGenerated
1510 }
1511 if iNdEx >= l {
1512 return 0, io.ErrUnexpectedEOF
1513 }
1514 iNdEx++
1515 if dAtA[iNdEx-1] < 0x80 {
1516 break
1517 }
1518 }
1519 case 1:
1520 iNdEx += 8
1521 case 2:
1522 var length int
1523 for shift := uint(0); ; shift += 7 {
1524 if shift >= 64 {
1525 return 0, ErrIntOverflowGenerated
1526 }
1527 if iNdEx >= l {
1528 return 0, io.ErrUnexpectedEOF
1529 }
1530 b := dAtA[iNdEx]
1531 iNdEx++
1532 length |= (int(b) & 0x7F) << shift
1533 if b < 0x80 {
1534 break
1535 }
1536 }
1537 if length < 0 {
1538 return 0, ErrInvalidLengthGenerated
1539 }
1540 iNdEx += length
1541 case 3:
1542 depth++
1543 case 4:
1544 if depth == 0 {
1545 return 0, ErrUnexpectedEndOfGroupGenerated
1546 }
1547 depth--
1548 case 5:
1549 iNdEx += 4
1550 default:
1551 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1552 }
1553 if iNdEx < 0 {
1554 return 0, ErrInvalidLengthGenerated
1555 }
1556 if depth == 0 {
1557 return iNdEx, nil
1558 }
1559 }
1560 return 0, io.ErrUnexpectedEOF
1561 }
1562
1563 var (
1564 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1565 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1566 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
1567 )
1568
View as plain text