1
16
17
18
19
20 package v1beta1
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 resource "k8s.io/apimachinery/pkg/api/resource"
32 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
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 *CSIDriver) Reset() { *m = CSIDriver{} }
52 func (*CSIDriver) ProtoMessage() {}
53 func (*CSIDriver) Descriptor() ([]byte, []int) {
54 return fileDescriptor_73e4f72503e71065, []int{0}
55 }
56 func (m *CSIDriver) XXX_Unmarshal(b []byte) error {
57 return m.Unmarshal(b)
58 }
59 func (m *CSIDriver) 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 *CSIDriver) XXX_Merge(src proto.Message) {
68 xxx_messageInfo_CSIDriver.Merge(m, src)
69 }
70 func (m *CSIDriver) XXX_Size() int {
71 return m.Size()
72 }
73 func (m *CSIDriver) XXX_DiscardUnknown() {
74 xxx_messageInfo_CSIDriver.DiscardUnknown(m)
75 }
76
77 var xxx_messageInfo_CSIDriver proto.InternalMessageInfo
78
79 func (m *CSIDriverList) Reset() { *m = CSIDriverList{} }
80 func (*CSIDriverList) ProtoMessage() {}
81 func (*CSIDriverList) Descriptor() ([]byte, []int) {
82 return fileDescriptor_73e4f72503e71065, []int{1}
83 }
84 func (m *CSIDriverList) XXX_Unmarshal(b []byte) error {
85 return m.Unmarshal(b)
86 }
87 func (m *CSIDriverList) 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 *CSIDriverList) XXX_Merge(src proto.Message) {
96 xxx_messageInfo_CSIDriverList.Merge(m, src)
97 }
98 func (m *CSIDriverList) XXX_Size() int {
99 return m.Size()
100 }
101 func (m *CSIDriverList) XXX_DiscardUnknown() {
102 xxx_messageInfo_CSIDriverList.DiscardUnknown(m)
103 }
104
105 var xxx_messageInfo_CSIDriverList proto.InternalMessageInfo
106
107 func (m *CSIDriverSpec) Reset() { *m = CSIDriverSpec{} }
108 func (*CSIDriverSpec) ProtoMessage() {}
109 func (*CSIDriverSpec) Descriptor() ([]byte, []int) {
110 return fileDescriptor_73e4f72503e71065, []int{2}
111 }
112 func (m *CSIDriverSpec) XXX_Unmarshal(b []byte) error {
113 return m.Unmarshal(b)
114 }
115 func (m *CSIDriverSpec) 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 *CSIDriverSpec) XXX_Merge(src proto.Message) {
124 xxx_messageInfo_CSIDriverSpec.Merge(m, src)
125 }
126 func (m *CSIDriverSpec) XXX_Size() int {
127 return m.Size()
128 }
129 func (m *CSIDriverSpec) XXX_DiscardUnknown() {
130 xxx_messageInfo_CSIDriverSpec.DiscardUnknown(m)
131 }
132
133 var xxx_messageInfo_CSIDriverSpec proto.InternalMessageInfo
134
135 func (m *CSINode) Reset() { *m = CSINode{} }
136 func (*CSINode) ProtoMessage() {}
137 func (*CSINode) Descriptor() ([]byte, []int) {
138 return fileDescriptor_73e4f72503e71065, []int{3}
139 }
140 func (m *CSINode) XXX_Unmarshal(b []byte) error {
141 return m.Unmarshal(b)
142 }
143 func (m *CSINode) 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 *CSINode) XXX_Merge(src proto.Message) {
152 xxx_messageInfo_CSINode.Merge(m, src)
153 }
154 func (m *CSINode) XXX_Size() int {
155 return m.Size()
156 }
157 func (m *CSINode) XXX_DiscardUnknown() {
158 xxx_messageInfo_CSINode.DiscardUnknown(m)
159 }
160
161 var xxx_messageInfo_CSINode proto.InternalMessageInfo
162
163 func (m *CSINodeDriver) Reset() { *m = CSINodeDriver{} }
164 func (*CSINodeDriver) ProtoMessage() {}
165 func (*CSINodeDriver) Descriptor() ([]byte, []int) {
166 return fileDescriptor_73e4f72503e71065, []int{4}
167 }
168 func (m *CSINodeDriver) XXX_Unmarshal(b []byte) error {
169 return m.Unmarshal(b)
170 }
171 func (m *CSINodeDriver) 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 *CSINodeDriver) XXX_Merge(src proto.Message) {
180 xxx_messageInfo_CSINodeDriver.Merge(m, src)
181 }
182 func (m *CSINodeDriver) XXX_Size() int {
183 return m.Size()
184 }
185 func (m *CSINodeDriver) XXX_DiscardUnknown() {
186 xxx_messageInfo_CSINodeDriver.DiscardUnknown(m)
187 }
188
189 var xxx_messageInfo_CSINodeDriver proto.InternalMessageInfo
190
191 func (m *CSINodeList) Reset() { *m = CSINodeList{} }
192 func (*CSINodeList) ProtoMessage() {}
193 func (*CSINodeList) Descriptor() ([]byte, []int) {
194 return fileDescriptor_73e4f72503e71065, []int{5}
195 }
196 func (m *CSINodeList) XXX_Unmarshal(b []byte) error {
197 return m.Unmarshal(b)
198 }
199 func (m *CSINodeList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
200 b = b[:cap(b)]
201 n, err := m.MarshalToSizedBuffer(b)
202 if err != nil {
203 return nil, err
204 }
205 return b[:n], nil
206 }
207 func (m *CSINodeList) XXX_Merge(src proto.Message) {
208 xxx_messageInfo_CSINodeList.Merge(m, src)
209 }
210 func (m *CSINodeList) XXX_Size() int {
211 return m.Size()
212 }
213 func (m *CSINodeList) XXX_DiscardUnknown() {
214 xxx_messageInfo_CSINodeList.DiscardUnknown(m)
215 }
216
217 var xxx_messageInfo_CSINodeList proto.InternalMessageInfo
218
219 func (m *CSINodeSpec) Reset() { *m = CSINodeSpec{} }
220 func (*CSINodeSpec) ProtoMessage() {}
221 func (*CSINodeSpec) Descriptor() ([]byte, []int) {
222 return fileDescriptor_73e4f72503e71065, []int{6}
223 }
224 func (m *CSINodeSpec) XXX_Unmarshal(b []byte) error {
225 return m.Unmarshal(b)
226 }
227 func (m *CSINodeSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
228 b = b[:cap(b)]
229 n, err := m.MarshalToSizedBuffer(b)
230 if err != nil {
231 return nil, err
232 }
233 return b[:n], nil
234 }
235 func (m *CSINodeSpec) XXX_Merge(src proto.Message) {
236 xxx_messageInfo_CSINodeSpec.Merge(m, src)
237 }
238 func (m *CSINodeSpec) XXX_Size() int {
239 return m.Size()
240 }
241 func (m *CSINodeSpec) XXX_DiscardUnknown() {
242 xxx_messageInfo_CSINodeSpec.DiscardUnknown(m)
243 }
244
245 var xxx_messageInfo_CSINodeSpec proto.InternalMessageInfo
246
247 func (m *CSIStorageCapacity) Reset() { *m = CSIStorageCapacity{} }
248 func (*CSIStorageCapacity) ProtoMessage() {}
249 func (*CSIStorageCapacity) Descriptor() ([]byte, []int) {
250 return fileDescriptor_73e4f72503e71065, []int{7}
251 }
252 func (m *CSIStorageCapacity) XXX_Unmarshal(b []byte) error {
253 return m.Unmarshal(b)
254 }
255 func (m *CSIStorageCapacity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
256 b = b[:cap(b)]
257 n, err := m.MarshalToSizedBuffer(b)
258 if err != nil {
259 return nil, err
260 }
261 return b[:n], nil
262 }
263 func (m *CSIStorageCapacity) XXX_Merge(src proto.Message) {
264 xxx_messageInfo_CSIStorageCapacity.Merge(m, src)
265 }
266 func (m *CSIStorageCapacity) XXX_Size() int {
267 return m.Size()
268 }
269 func (m *CSIStorageCapacity) XXX_DiscardUnknown() {
270 xxx_messageInfo_CSIStorageCapacity.DiscardUnknown(m)
271 }
272
273 var xxx_messageInfo_CSIStorageCapacity proto.InternalMessageInfo
274
275 func (m *CSIStorageCapacityList) Reset() { *m = CSIStorageCapacityList{} }
276 func (*CSIStorageCapacityList) ProtoMessage() {}
277 func (*CSIStorageCapacityList) Descriptor() ([]byte, []int) {
278 return fileDescriptor_73e4f72503e71065, []int{8}
279 }
280 func (m *CSIStorageCapacityList) XXX_Unmarshal(b []byte) error {
281 return m.Unmarshal(b)
282 }
283 func (m *CSIStorageCapacityList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
284 b = b[:cap(b)]
285 n, err := m.MarshalToSizedBuffer(b)
286 if err != nil {
287 return nil, err
288 }
289 return b[:n], nil
290 }
291 func (m *CSIStorageCapacityList) XXX_Merge(src proto.Message) {
292 xxx_messageInfo_CSIStorageCapacityList.Merge(m, src)
293 }
294 func (m *CSIStorageCapacityList) XXX_Size() int {
295 return m.Size()
296 }
297 func (m *CSIStorageCapacityList) XXX_DiscardUnknown() {
298 xxx_messageInfo_CSIStorageCapacityList.DiscardUnknown(m)
299 }
300
301 var xxx_messageInfo_CSIStorageCapacityList proto.InternalMessageInfo
302
303 func (m *StorageClass) Reset() { *m = StorageClass{} }
304 func (*StorageClass) ProtoMessage() {}
305 func (*StorageClass) Descriptor() ([]byte, []int) {
306 return fileDescriptor_73e4f72503e71065, []int{9}
307 }
308 func (m *StorageClass) XXX_Unmarshal(b []byte) error {
309 return m.Unmarshal(b)
310 }
311 func (m *StorageClass) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
312 b = b[:cap(b)]
313 n, err := m.MarshalToSizedBuffer(b)
314 if err != nil {
315 return nil, err
316 }
317 return b[:n], nil
318 }
319 func (m *StorageClass) XXX_Merge(src proto.Message) {
320 xxx_messageInfo_StorageClass.Merge(m, src)
321 }
322 func (m *StorageClass) XXX_Size() int {
323 return m.Size()
324 }
325 func (m *StorageClass) XXX_DiscardUnknown() {
326 xxx_messageInfo_StorageClass.DiscardUnknown(m)
327 }
328
329 var xxx_messageInfo_StorageClass proto.InternalMessageInfo
330
331 func (m *StorageClassList) Reset() { *m = StorageClassList{} }
332 func (*StorageClassList) ProtoMessage() {}
333 func (*StorageClassList) Descriptor() ([]byte, []int) {
334 return fileDescriptor_73e4f72503e71065, []int{10}
335 }
336 func (m *StorageClassList) XXX_Unmarshal(b []byte) error {
337 return m.Unmarshal(b)
338 }
339 func (m *StorageClassList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
340 b = b[:cap(b)]
341 n, err := m.MarshalToSizedBuffer(b)
342 if err != nil {
343 return nil, err
344 }
345 return b[:n], nil
346 }
347 func (m *StorageClassList) XXX_Merge(src proto.Message) {
348 xxx_messageInfo_StorageClassList.Merge(m, src)
349 }
350 func (m *StorageClassList) XXX_Size() int {
351 return m.Size()
352 }
353 func (m *StorageClassList) XXX_DiscardUnknown() {
354 xxx_messageInfo_StorageClassList.DiscardUnknown(m)
355 }
356
357 var xxx_messageInfo_StorageClassList proto.InternalMessageInfo
358
359 func (m *TokenRequest) Reset() { *m = TokenRequest{} }
360 func (*TokenRequest) ProtoMessage() {}
361 func (*TokenRequest) Descriptor() ([]byte, []int) {
362 return fileDescriptor_73e4f72503e71065, []int{11}
363 }
364 func (m *TokenRequest) XXX_Unmarshal(b []byte) error {
365 return m.Unmarshal(b)
366 }
367 func (m *TokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
368 b = b[:cap(b)]
369 n, err := m.MarshalToSizedBuffer(b)
370 if err != nil {
371 return nil, err
372 }
373 return b[:n], nil
374 }
375 func (m *TokenRequest) XXX_Merge(src proto.Message) {
376 xxx_messageInfo_TokenRequest.Merge(m, src)
377 }
378 func (m *TokenRequest) XXX_Size() int {
379 return m.Size()
380 }
381 func (m *TokenRequest) XXX_DiscardUnknown() {
382 xxx_messageInfo_TokenRequest.DiscardUnknown(m)
383 }
384
385 var xxx_messageInfo_TokenRequest proto.InternalMessageInfo
386
387 func (m *VolumeAttachment) Reset() { *m = VolumeAttachment{} }
388 func (*VolumeAttachment) ProtoMessage() {}
389 func (*VolumeAttachment) Descriptor() ([]byte, []int) {
390 return fileDescriptor_73e4f72503e71065, []int{12}
391 }
392 func (m *VolumeAttachment) XXX_Unmarshal(b []byte) error {
393 return m.Unmarshal(b)
394 }
395 func (m *VolumeAttachment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
396 b = b[:cap(b)]
397 n, err := m.MarshalToSizedBuffer(b)
398 if err != nil {
399 return nil, err
400 }
401 return b[:n], nil
402 }
403 func (m *VolumeAttachment) XXX_Merge(src proto.Message) {
404 xxx_messageInfo_VolumeAttachment.Merge(m, src)
405 }
406 func (m *VolumeAttachment) XXX_Size() int {
407 return m.Size()
408 }
409 func (m *VolumeAttachment) XXX_DiscardUnknown() {
410 xxx_messageInfo_VolumeAttachment.DiscardUnknown(m)
411 }
412
413 var xxx_messageInfo_VolumeAttachment proto.InternalMessageInfo
414
415 func (m *VolumeAttachmentList) Reset() { *m = VolumeAttachmentList{} }
416 func (*VolumeAttachmentList) ProtoMessage() {}
417 func (*VolumeAttachmentList) Descriptor() ([]byte, []int) {
418 return fileDescriptor_73e4f72503e71065, []int{13}
419 }
420 func (m *VolumeAttachmentList) XXX_Unmarshal(b []byte) error {
421 return m.Unmarshal(b)
422 }
423 func (m *VolumeAttachmentList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
424 b = b[:cap(b)]
425 n, err := m.MarshalToSizedBuffer(b)
426 if err != nil {
427 return nil, err
428 }
429 return b[:n], nil
430 }
431 func (m *VolumeAttachmentList) XXX_Merge(src proto.Message) {
432 xxx_messageInfo_VolumeAttachmentList.Merge(m, src)
433 }
434 func (m *VolumeAttachmentList) XXX_Size() int {
435 return m.Size()
436 }
437 func (m *VolumeAttachmentList) XXX_DiscardUnknown() {
438 xxx_messageInfo_VolumeAttachmentList.DiscardUnknown(m)
439 }
440
441 var xxx_messageInfo_VolumeAttachmentList proto.InternalMessageInfo
442
443 func (m *VolumeAttachmentSource) Reset() { *m = VolumeAttachmentSource{} }
444 func (*VolumeAttachmentSource) ProtoMessage() {}
445 func (*VolumeAttachmentSource) Descriptor() ([]byte, []int) {
446 return fileDescriptor_73e4f72503e71065, []int{14}
447 }
448 func (m *VolumeAttachmentSource) XXX_Unmarshal(b []byte) error {
449 return m.Unmarshal(b)
450 }
451 func (m *VolumeAttachmentSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
452 b = b[:cap(b)]
453 n, err := m.MarshalToSizedBuffer(b)
454 if err != nil {
455 return nil, err
456 }
457 return b[:n], nil
458 }
459 func (m *VolumeAttachmentSource) XXX_Merge(src proto.Message) {
460 xxx_messageInfo_VolumeAttachmentSource.Merge(m, src)
461 }
462 func (m *VolumeAttachmentSource) XXX_Size() int {
463 return m.Size()
464 }
465 func (m *VolumeAttachmentSource) XXX_DiscardUnknown() {
466 xxx_messageInfo_VolumeAttachmentSource.DiscardUnknown(m)
467 }
468
469 var xxx_messageInfo_VolumeAttachmentSource proto.InternalMessageInfo
470
471 func (m *VolumeAttachmentSpec) Reset() { *m = VolumeAttachmentSpec{} }
472 func (*VolumeAttachmentSpec) ProtoMessage() {}
473 func (*VolumeAttachmentSpec) Descriptor() ([]byte, []int) {
474 return fileDescriptor_73e4f72503e71065, []int{15}
475 }
476 func (m *VolumeAttachmentSpec) XXX_Unmarshal(b []byte) error {
477 return m.Unmarshal(b)
478 }
479 func (m *VolumeAttachmentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
480 b = b[:cap(b)]
481 n, err := m.MarshalToSizedBuffer(b)
482 if err != nil {
483 return nil, err
484 }
485 return b[:n], nil
486 }
487 func (m *VolumeAttachmentSpec) XXX_Merge(src proto.Message) {
488 xxx_messageInfo_VolumeAttachmentSpec.Merge(m, src)
489 }
490 func (m *VolumeAttachmentSpec) XXX_Size() int {
491 return m.Size()
492 }
493 func (m *VolumeAttachmentSpec) XXX_DiscardUnknown() {
494 xxx_messageInfo_VolumeAttachmentSpec.DiscardUnknown(m)
495 }
496
497 var xxx_messageInfo_VolumeAttachmentSpec proto.InternalMessageInfo
498
499 func (m *VolumeAttachmentStatus) Reset() { *m = VolumeAttachmentStatus{} }
500 func (*VolumeAttachmentStatus) ProtoMessage() {}
501 func (*VolumeAttachmentStatus) Descriptor() ([]byte, []int) {
502 return fileDescriptor_73e4f72503e71065, []int{16}
503 }
504 func (m *VolumeAttachmentStatus) XXX_Unmarshal(b []byte) error {
505 return m.Unmarshal(b)
506 }
507 func (m *VolumeAttachmentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
508 b = b[:cap(b)]
509 n, err := m.MarshalToSizedBuffer(b)
510 if err != nil {
511 return nil, err
512 }
513 return b[:n], nil
514 }
515 func (m *VolumeAttachmentStatus) XXX_Merge(src proto.Message) {
516 xxx_messageInfo_VolumeAttachmentStatus.Merge(m, src)
517 }
518 func (m *VolumeAttachmentStatus) XXX_Size() int {
519 return m.Size()
520 }
521 func (m *VolumeAttachmentStatus) XXX_DiscardUnknown() {
522 xxx_messageInfo_VolumeAttachmentStatus.DiscardUnknown(m)
523 }
524
525 var xxx_messageInfo_VolumeAttachmentStatus proto.InternalMessageInfo
526
527 func (m *VolumeError) Reset() { *m = VolumeError{} }
528 func (*VolumeError) ProtoMessage() {}
529 func (*VolumeError) Descriptor() ([]byte, []int) {
530 return fileDescriptor_73e4f72503e71065, []int{17}
531 }
532 func (m *VolumeError) XXX_Unmarshal(b []byte) error {
533 return m.Unmarshal(b)
534 }
535 func (m *VolumeError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
536 b = b[:cap(b)]
537 n, err := m.MarshalToSizedBuffer(b)
538 if err != nil {
539 return nil, err
540 }
541 return b[:n], nil
542 }
543 func (m *VolumeError) XXX_Merge(src proto.Message) {
544 xxx_messageInfo_VolumeError.Merge(m, src)
545 }
546 func (m *VolumeError) XXX_Size() int {
547 return m.Size()
548 }
549 func (m *VolumeError) XXX_DiscardUnknown() {
550 xxx_messageInfo_VolumeError.DiscardUnknown(m)
551 }
552
553 var xxx_messageInfo_VolumeError proto.InternalMessageInfo
554
555 func (m *VolumeNodeResources) Reset() { *m = VolumeNodeResources{} }
556 func (*VolumeNodeResources) ProtoMessage() {}
557 func (*VolumeNodeResources) Descriptor() ([]byte, []int) {
558 return fileDescriptor_73e4f72503e71065, []int{18}
559 }
560 func (m *VolumeNodeResources) XXX_Unmarshal(b []byte) error {
561 return m.Unmarshal(b)
562 }
563 func (m *VolumeNodeResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
564 b = b[:cap(b)]
565 n, err := m.MarshalToSizedBuffer(b)
566 if err != nil {
567 return nil, err
568 }
569 return b[:n], nil
570 }
571 func (m *VolumeNodeResources) XXX_Merge(src proto.Message) {
572 xxx_messageInfo_VolumeNodeResources.Merge(m, src)
573 }
574 func (m *VolumeNodeResources) XXX_Size() int {
575 return m.Size()
576 }
577 func (m *VolumeNodeResources) XXX_DiscardUnknown() {
578 xxx_messageInfo_VolumeNodeResources.DiscardUnknown(m)
579 }
580
581 var xxx_messageInfo_VolumeNodeResources proto.InternalMessageInfo
582
583 func init() {
584 proto.RegisterType((*CSIDriver)(nil), "k8s.io.api.storage.v1beta1.CSIDriver")
585 proto.RegisterType((*CSIDriverList)(nil), "k8s.io.api.storage.v1beta1.CSIDriverList")
586 proto.RegisterType((*CSIDriverSpec)(nil), "k8s.io.api.storage.v1beta1.CSIDriverSpec")
587 proto.RegisterType((*CSINode)(nil), "k8s.io.api.storage.v1beta1.CSINode")
588 proto.RegisterType((*CSINodeDriver)(nil), "k8s.io.api.storage.v1beta1.CSINodeDriver")
589 proto.RegisterType((*CSINodeList)(nil), "k8s.io.api.storage.v1beta1.CSINodeList")
590 proto.RegisterType((*CSINodeSpec)(nil), "k8s.io.api.storage.v1beta1.CSINodeSpec")
591 proto.RegisterType((*CSIStorageCapacity)(nil), "k8s.io.api.storage.v1beta1.CSIStorageCapacity")
592 proto.RegisterType((*CSIStorageCapacityList)(nil), "k8s.io.api.storage.v1beta1.CSIStorageCapacityList")
593 proto.RegisterType((*StorageClass)(nil), "k8s.io.api.storage.v1beta1.StorageClass")
594 proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.storage.v1beta1.StorageClass.ParametersEntry")
595 proto.RegisterType((*StorageClassList)(nil), "k8s.io.api.storage.v1beta1.StorageClassList")
596 proto.RegisterType((*TokenRequest)(nil), "k8s.io.api.storage.v1beta1.TokenRequest")
597 proto.RegisterType((*VolumeAttachment)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachment")
598 proto.RegisterType((*VolumeAttachmentList)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentList")
599 proto.RegisterType((*VolumeAttachmentSource)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentSource")
600 proto.RegisterType((*VolumeAttachmentSpec)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentSpec")
601 proto.RegisterType((*VolumeAttachmentStatus)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentStatus")
602 proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentStatus.AttachmentMetadataEntry")
603 proto.RegisterType((*VolumeError)(nil), "k8s.io.api.storage.v1beta1.VolumeError")
604 proto.RegisterType((*VolumeNodeResources)(nil), "k8s.io.api.storage.v1beta1.VolumeNodeResources")
605 }
606
607 func init() {
608 proto.RegisterFile("k8s.io/api/storage/v1beta1/generated.proto", fileDescriptor_73e4f72503e71065)
609 }
610
611 var fileDescriptor_73e4f72503e71065 = []byte{
612
613 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4d, 0x6f, 0x1b, 0xc5,
614 0x1b, 0xcf, 0xc6, 0xce, 0xdb, 0x38, 0x69, 0x92, 0x49, 0xda, 0xbf, 0xff, 0x3e, 0xd8, 0x91, 0x11,
615 0x34, 0xad, 0xca, 0xba, 0x0d, 0xa5, 0xaa, 0x2a, 0x55, 0x22, 0x9b, 0x04, 0xea, 0x36, 0x4e, 0xd3,
616 0x71, 0x54, 0x55, 0x15, 0x07, 0xc6, 0xeb, 0x89, 0x33, 0x8d, 0xf7, 0xa5, 0x3b, 0xe3, 0x10, 0x73,
617 0x82, 0x0b, 0x67, 0xc4, 0x81, 0x4f, 0xc0, 0x57, 0x00, 0x09, 0x2e, 0x1c, 0xa9, 0x84, 0x84, 0x2a,
618 0x2e, 0xf4, 0x64, 0x51, 0xf3, 0x11, 0x90, 0x38, 0x44, 0x1c, 0xd0, 0xcc, 0x8e, 0xbd, 0x6f, 0x76,
619 0x93, 0x70, 0xf0, 0xcd, 0xf3, 0xbc, 0xfc, 0x9e, 0x67, 0xe6, 0x79, 0x5d, 0x83, 0xab, 0x87, 0xb7,
620 0x99, 0x4e, 0x9d, 0x12, 0x76, 0x69, 0x89, 0x71, 0xc7, 0xc3, 0x0d, 0x52, 0x3a, 0xba, 0x51, 0x23,
621 0x1c, 0xdf, 0x28, 0x35, 0x88, 0x4d, 0x3c, 0xcc, 0x49, 0x5d, 0x77, 0x3d, 0x87, 0x3b, 0x30, 0xe7,
622 0xcb, 0xea, 0xd8, 0xa5, 0xba, 0x92, 0xd5, 0x95, 0x6c, 0xee, 0xdd, 0x06, 0xe5, 0x07, 0xad, 0x9a,
623 0x6e, 0x3a, 0x56, 0xa9, 0xe1, 0x34, 0x9c, 0x92, 0x54, 0xa9, 0xb5, 0xf6, 0xe5, 0x49, 0x1e, 0xe4,
624 0x2f, 0x1f, 0x2a, 0x57, 0x0c, 0x99, 0x35, 0x1d, 0x4f, 0xd8, 0x8c, 0x9b, 0xcb, 0xdd, 0x0c, 0x64,
625 0x2c, 0x6c, 0x1e, 0x50, 0x9b, 0x78, 0xed, 0x92, 0x7b, 0xd8, 0x90, 0x4a, 0x1e, 0x61, 0x4e, 0xcb,
626 0x33, 0xc9, 0xb9, 0xb4, 0x58, 0xc9, 0x22, 0x1c, 0x0f, 0xb2, 0x55, 0x1a, 0xa6, 0xe5, 0xb5, 0x6c,
627 0x4e, 0xad, 0xa4, 0x99, 0x5b, 0xa7, 0x29, 0x30, 0xf3, 0x80, 0x58, 0x38, 0xae, 0x57, 0xfc, 0x51,
628 0x03, 0x33, 0x1b, 0xd5, 0xf2, 0xa6, 0x47, 0x8f, 0x88, 0x07, 0x3f, 0x01, 0xd3, 0xc2, 0xa3, 0x3a,
629 0xe6, 0x38, 0xab, 0xad, 0x68, 0xab, 0x99, 0xb5, 0xeb, 0x7a, 0xf0, 0xc8, 0x7d, 0x60, 0xdd, 0x3d,
630 0x6c, 0x08, 0x02, 0xd3, 0x85, 0xb4, 0x7e, 0x74, 0x43, 0x7f, 0x58, 0x7b, 0x46, 0x4c, 0x5e, 0x21,
631 0x1c, 0x1b, 0xf0, 0x45, 0xa7, 0x30, 0xd6, 0xed, 0x14, 0x40, 0x40, 0x43, 0x7d, 0x54, 0xf8, 0x00,
632 0xa4, 0x99, 0x4b, 0xcc, 0xec, 0xb8, 0x44, 0xbf, 0xa2, 0x0f, 0x0f, 0xa1, 0xde, 0x77, 0xab, 0xea,
633 0x12, 0xd3, 0x98, 0x55, 0xb0, 0x69, 0x71, 0x42, 0x12, 0xa4, 0xf8, 0x83, 0x06, 0xe6, 0xfa, 0x52,
634 0xdb, 0x94, 0x71, 0xf8, 0x71, 0xe2, 0x02, 0xfa, 0xd9, 0x2e, 0x20, 0xb4, 0xa5, 0xfb, 0x0b, 0xca,
635 0xce, 0x74, 0x8f, 0x12, 0x72, 0xfe, 0x3e, 0x98, 0xa0, 0x9c, 0x58, 0x2c, 0x3b, 0xbe, 0x92, 0x5a,
636 0xcd, 0xac, 0xbd, 0x7d, 0x26, 0xef, 0x8d, 0x39, 0x85, 0x38, 0x51, 0x16, 0xba, 0xc8, 0x87, 0x28,
637 0xfe, 0x9e, 0x0e, 0xf9, 0x2e, 0xee, 0x04, 0xef, 0x80, 0x0b, 0x98, 0x73, 0x6c, 0x1e, 0x20, 0xf2,
638 0xbc, 0x45, 0x3d, 0x52, 0x97, 0x37, 0x98, 0x36, 0x60, 0xb7, 0x53, 0xb8, 0xb0, 0x1e, 0xe1, 0xa0,
639 0x98, 0xa4, 0xd0, 0x75, 0x9d, 0x7a, 0xd9, 0xde, 0x77, 0x1e, 0xda, 0x15, 0xa7, 0x65, 0x73, 0xf9,
640 0xc0, 0x4a, 0x77, 0x37, 0xc2, 0x41, 0x31, 0x49, 0x68, 0x82, 0xe5, 0x23, 0xa7, 0xd9, 0xb2, 0xc8,
641 0x36, 0xdd, 0x27, 0x66, 0xdb, 0x6c, 0x92, 0x8a, 0x53, 0x27, 0x2c, 0x9b, 0x5a, 0x49, 0xad, 0xce,
642 0x18, 0xa5, 0x6e, 0xa7, 0xb0, 0xfc, 0x78, 0x00, 0xff, 0xa4, 0x53, 0x58, 0x1a, 0x40, 0x47, 0x03,
643 0xc1, 0xe0, 0x5d, 0x30, 0xaf, 0x5e, 0x68, 0x03, 0xbb, 0xd8, 0xa4, 0xbc, 0x9d, 0x4d, 0x4b, 0x0f,
644 0x97, 0xba, 0x9d, 0xc2, 0x7c, 0x35, 0xca, 0x42, 0x71, 0x59, 0x78, 0x0f, 0xcc, 0xed, 0xb3, 0x8f,
645 0x3c, 0xa7, 0xe5, 0xee, 0x3a, 0x4d, 0x6a, 0xb6, 0xb3, 0x13, 0x2b, 0xda, 0xea, 0x8c, 0x51, 0xec,
646 0x76, 0x0a, 0x73, 0x1f, 0x56, 0x43, 0x8c, 0x93, 0x38, 0x01, 0x45, 0x15, 0x21, 0x01, 0x73, 0xdc,
647 0x39, 0x24, 0xb6, 0x78, 0x3a, 0xc2, 0x38, 0xcb, 0x4e, 0xca, 0x58, 0xae, 0xbe, 0x29, 0x96, 0x7b,
648 0x21, 0x05, 0xe3, 0xa2, 0x0a, 0xe7, 0x5c, 0x98, 0xca, 0x50, 0x14, 0x15, 0x6e, 0x80, 0x45, 0xcf,
649 0x0f, 0x0e, 0x43, 0xc4, 0x6d, 0xd5, 0x9a, 0x94, 0x1d, 0x64, 0xa7, 0xe4, 0x8d, 0x2f, 0x76, 0x3b,
650 0x85, 0x45, 0x14, 0x67, 0xa2, 0xa4, 0x3c, 0xbc, 0x09, 0x66, 0x19, 0xd9, 0xa6, 0x76, 0xeb, 0xd8,
651 0x8f, 0xe9, 0xb4, 0xd4, 0x5f, 0xe8, 0x76, 0x0a, 0xb3, 0xd5, 0xad, 0x80, 0x8e, 0x22, 0x52, 0xc5,
652 0xef, 0x35, 0x30, 0xb5, 0x51, 0x2d, 0xef, 0x38, 0x75, 0x32, 0x82, 0x82, 0x2e, 0x47, 0x0a, 0xfa,
653 0xf2, 0x29, 0x25, 0x21, 0x9c, 0x1a, 0x5a, 0xce, 0x7f, 0xf9, 0xe5, 0x2c, 0x64, 0x54, 0x3f, 0x5a,
654 0x01, 0x69, 0x1b, 0x5b, 0x44, 0xba, 0x3e, 0x13, 0xe8, 0xec, 0x60, 0x8b, 0x20, 0xc9, 0x81, 0xef,
655 0x80, 0x49, 0xdb, 0xa9, 0x93, 0xf2, 0xa6, 0x74, 0x60, 0xc6, 0xb8, 0xa0, 0x64, 0x26, 0x77, 0x24,
656 0x15, 0x29, 0xae, 0x78, 0x4a, 0xee, 0xb8, 0x4e, 0xd3, 0x69, 0xb4, 0x1f, 0x90, 0x76, 0x2f, 0xb9,
657 0xe5, 0x53, 0xee, 0x85, 0xe8, 0x28, 0x22, 0x05, 0x6b, 0x20, 0x83, 0x9b, 0x4d, 0xc7, 0xc4, 0x1c,
658 0xd7, 0x9a, 0x44, 0x66, 0x6c, 0x66, 0xad, 0xf4, 0xa6, 0x3b, 0xfa, 0x15, 0x21, 0x8c, 0x23, 0x35,
659 0x11, 0x98, 0x31, 0xdf, 0xed, 0x14, 0x32, 0xeb, 0x01, 0x0e, 0x0a, 0x83, 0x16, 0xbf, 0xd3, 0x40,
660 0x46, 0xdd, 0x7a, 0x04, 0x2d, 0xec, 0x5e, 0xb4, 0x85, 0xbd, 0x75, 0x86, 0x78, 0x0d, 0x69, 0x60,
661 0x66, 0xdf, 0x6d, 0xd9, 0xbd, 0xf6, 0xc0, 0x54, 0x5d, 0x06, 0x8d, 0x65, 0x35, 0x09, 0x7d, 0xe5,
662 0x0c, 0xd0, 0xaa, 0x43, 0xce, 0x2b, 0x03, 0x53, 0xfe, 0x99, 0xa1, 0x1e, 0x54, 0xf1, 0xef, 0x14,
663 0x80, 0x1b, 0xd5, 0x72, 0xac, 0x3f, 0x8c, 0x20, 0xad, 0x29, 0x98, 0x15, 0x99, 0xd3, 0xcb, 0x0d,
664 0x95, 0xde, 0xef, 0x9d, 0x31, 0x12, 0xb8, 0x46, 0x9a, 0x55, 0xd2, 0x24, 0x26, 0x77, 0x3c, 0x3f,
665 0xc9, 0x76, 0x42, 0x60, 0x28, 0x02, 0x0d, 0x37, 0xc1, 0x42, 0xaf, 0xdd, 0x35, 0x31, 0x63, 0x22,
666 0xb9, 0xb3, 0x29, 0x99, 0xcc, 0x59, 0xe5, 0xe2, 0x42, 0x35, 0xc6, 0x47, 0x09, 0x0d, 0xf8, 0x04,
667 0x4c, 0x9b, 0xe1, 0xce, 0x7a, 0x4a, 0xda, 0xe8, 0xbd, 0x85, 0x45, 0x7f, 0xd4, 0xc2, 0x36, 0xa7,
668 0xbc, 0x6d, 0xcc, 0x8a, 0x94, 0xe9, 0xb7, 0xe0, 0x3e, 0x1a, 0x64, 0x60, 0xd1, 0xc2, 0xc7, 0xd4,
669 0x6a, 0x59, 0x7e, 0x72, 0x57, 0xe9, 0x67, 0x44, 0xf6, 0xdf, 0xf3, 0x9b, 0x90, 0xad, 0xaf, 0x12,
670 0x07, 0x43, 0x49, 0xfc, 0xe2, 0x2f, 0x1a, 0xb8, 0x94, 0x0c, 0xfc, 0x08, 0x0a, 0xa4, 0x1a, 0x2d,
671 0x10, 0xfd, 0x94, 0x2c, 0x8e, 0x39, 0x38, 0xa4, 0x56, 0xbe, 0x9e, 0x04, 0xb3, 0xe1, 0x18, 0x8e,
672 0x20, 0x81, 0xdf, 0x07, 0x19, 0xd7, 0x73, 0x8e, 0x28, 0xa3, 0x8e, 0x4d, 0x3c, 0xd5, 0x1d, 0x97,
673 0x94, 0x4a, 0x66, 0x37, 0x60, 0xa1, 0xb0, 0x1c, 0x6c, 0x02, 0xe0, 0x62, 0x0f, 0x5b, 0x84, 0x8b,
674 0x4a, 0x4e, 0xc9, 0x37, 0xb8, 0xfd, 0xa6, 0x37, 0x08, 0x5f, 0x4b, 0xdf, 0xed, 0xab, 0x6e, 0xd9,
675 0xdc, 0x6b, 0x07, 0x2e, 0x06, 0x0c, 0x14, 0xc2, 0x87, 0x87, 0x60, 0xce, 0x23, 0x66, 0x13, 0x53,
676 0x4b, 0x8d, 0xf5, 0xb4, 0x74, 0x73, 0x4b, 0x8c, 0x57, 0x14, 0x66, 0x9c, 0x74, 0x0a, 0xd7, 0x93,
677 0x2b, 0xba, 0xbe, 0x4b, 0x3c, 0x46, 0x19, 0x27, 0x36, 0xf7, 0x53, 0x27, 0xa2, 0x83, 0xa2, 0xd8,
678 0x62, 0x04, 0x58, 0x62, 0x40, 0x3e, 0x74, 0x39, 0x75, 0x6c, 0x96, 0x9d, 0x08, 0x46, 0x40, 0x25,
679 0x44, 0x47, 0x11, 0x29, 0xb8, 0x0d, 0x96, 0x45, 0xb7, 0xfe, 0xd4, 0x37, 0xb0, 0x75, 0xec, 0x62,
680 0x5b, 0x3c, 0x55, 0x76, 0x52, 0xce, 0xe2, 0xac, 0xd8, 0x8e, 0xd6, 0x07, 0xf0, 0xd1, 0x40, 0x2d,
681 0xf8, 0x04, 0x2c, 0xfa, 0xeb, 0x91, 0x41, 0xed, 0x3a, 0xb5, 0x1b, 0x62, 0x39, 0x92, 0x6b, 0xc1,
682 0x8c, 0x71, 0x55, 0xd4, 0xc6, 0xe3, 0x38, 0xf3, 0x64, 0x10, 0x11, 0x25, 0x41, 0xe0, 0x73, 0xb0,
683 0x28, 0x2d, 0x92, 0xba, 0x6a, 0x2c, 0x94, 0xb0, 0xec, 0x74, 0x72, 0xb7, 0x11, 0x4f, 0x27, 0x12,
684 0xa9, 0xd7, 0x7e, 0x7a, 0x6d, 0x6a, 0x8f, 0x78, 0x96, 0xf1, 0x7f, 0x15, 0xaf, 0xc5, 0xf5, 0x38,
685 0x14, 0x4a, 0xa2, 0xe7, 0xee, 0x82, 0xf9, 0x58, 0xc0, 0xe1, 0x02, 0x48, 0x1d, 0x92, 0xb6, 0x3f,
686 0xaf, 0x91, 0xf8, 0x09, 0x97, 0xc1, 0xc4, 0x11, 0x6e, 0xb6, 0x88, 0x9f, 0x81, 0xc8, 0x3f, 0xdc,
687 0x19, 0xbf, 0xad, 0x15, 0x7f, 0xd2, 0x40, 0xa4, 0xb1, 0x8d, 0xa0, 0xb8, 0x2b, 0xd1, 0xe2, 0x5e,
688 0x3d, 0x6b, 0x62, 0x0f, 0x29, 0xeb, 0x2f, 0x34, 0x30, 0x1b, 0xde, 0x02, 0xe1, 0x35, 0x30, 0x8d,
689 0x5b, 0x75, 0x4a, 0x6c, 0xb3, 0xb7, 0xb3, 0xf4, 0xbd, 0x59, 0x57, 0x74, 0xd4, 0x97, 0x10, 0x3b,
690 0x22, 0x39, 0x76, 0xa9, 0x87, 0x45, 0xa6, 0x55, 0x89, 0xe9, 0xd8, 0x75, 0x26, 0x9f, 0x29, 0xe5,
691 0x37, 0xca, 0xad, 0x38, 0x13, 0x25, 0xe5, 0x8b, 0xdf, 0x8e, 0x83, 0x05, 0x3f, 0x41, 0xfc, 0x4f,
692 0x04, 0x8b, 0xd8, 0x7c, 0x04, 0xed, 0x05, 0x45, 0xd6, 0xbe, 0xeb, 0xa7, 0xaf, 0x44, 0x81, 0x77,
693 0xc3, 0xf6, 0x3f, 0xf8, 0x14, 0x4c, 0x32, 0x8e, 0x79, 0x8b, 0xc9, 0xf1, 0x97, 0x59, 0x5b, 0x3b,
694 0x17, 0xaa, 0xd4, 0x0c, 0xf6, 0x3f, 0xff, 0x8c, 0x14, 0x62, 0xf1, 0x67, 0x0d, 0x2c, 0xc7, 0x55,
695 0x46, 0x90, 0x70, 0x8f, 0xa2, 0x09, 0x77, 0xed, 0x3c, 0x37, 0x1a, 0x92, 0x74, 0xbf, 0x69, 0xe0,
696 0x52, 0xe2, 0xf2, 0x72, 0xce, 0x8a, 0x5e, 0xe5, 0xc6, 0x3a, 0xe2, 0x4e, 0xb0, 0x3e, 0xcb, 0x5e,
697 0xb5, 0x3b, 0x80, 0x8f, 0x06, 0x6a, 0xc1, 0x67, 0x60, 0x81, 0xda, 0x4d, 0x6a, 0x13, 0x35, 0x96,
698 0x83, 0x70, 0x0f, 0x6c, 0x28, 0x71, 0x64, 0x19, 0xe6, 0x65, 0xb1, 0xbd, 0x94, 0x63, 0x28, 0x28,
699 0x81, 0x5b, 0xfc, 0x75, 0x40, 0x78, 0xe4, 0x5a, 0x29, 0x2a, 0x4a, 0x52, 0x88, 0x97, 0xa8, 0x28,
700 0x45, 0x47, 0x7d, 0x09, 0x99, 0x41, 0xf2, 0x29, 0x94, 0xa3, 0xe7, 0xcb, 0x20, 0xa9, 0x19, 0xca,
701 0x20, 0x79, 0x46, 0x0a, 0x51, 0x78, 0x22, 0xd6, 0xb6, 0xd0, 0x7a, 0xd6, 0xf7, 0x64, 0x47, 0xd1,
702 0x51, 0x5f, 0xa2, 0xf8, 0x4f, 0x6a, 0x40, 0x94, 0x64, 0x2a, 0x86, 0xae, 0xd4, 0xfb, 0xc2, 0x8f,
703 0x5f, 0xa9, 0xde, 0xbf, 0x52, 0x1d, 0x7e, 0xa3, 0x01, 0x88, 0xfb, 0x10, 0x95, 0x5e, 0xaa, 0xfa,
704 0xf9, 0x74, 0xff, 0xfc, 0x15, 0xa2, 0xaf, 0x27, 0xc0, 0xfc, 0x59, 0x9d, 0x53, 0x4e, 0xc0, 0xa4,
705 0x00, 0x1a, 0xe0, 0x01, 0xa4, 0x20, 0xe3, 0x53, 0xb7, 0x3c, 0xcf, 0xf1, 0x54, 0xc9, 0x5e, 0x3e,
706 0xdd, 0x21, 0x29, 0x6e, 0xe4, 0xe5, 0x37, 0x51, 0xa0, 0x7f, 0xd2, 0x29, 0x64, 0x42, 0x7c, 0x14,
707 0xc6, 0x16, 0xa6, 0xea, 0x24, 0x30, 0x95, 0xfe, 0x0f, 0xa6, 0x36, 0xc9, 0x70, 0x53, 0x21, 0xec,
708 0xdc, 0x16, 0xf8, 0xdf, 0x90, 0x07, 0x3a, 0xd7, 0x6c, 0xfb, 0x52, 0x03, 0x61, 0x1b, 0x70, 0x1b,
709 0xa4, 0x39, 0x55, 0x95, 0x98, 0x59, 0xbb, 0x7a, 0xb6, 0x0e, 0xb3, 0x47, 0x2d, 0x12, 0x34, 0x4a,
710 0x71, 0x42, 0x12, 0x05, 0x5e, 0x01, 0x53, 0x16, 0x61, 0x0c, 0x37, 0x94, 0xe5, 0xe0, 0x03, 0xaa,
711 0xe2, 0x93, 0x51, 0x8f, 0x5f, 0xbc, 0x05, 0x96, 0x06, 0x7c, 0x92, 0xc2, 0x02, 0x98, 0x30, 0xe5,
712 0x5f, 0x0a, 0xc2, 0xa1, 0x09, 0x63, 0x46, 0x74, 0x99, 0x0d, 0xf9, 0x5f, 0x82, 0x4f, 0x37, 0x3e,
713 0x78, 0xf1, 0x3a, 0x3f, 0xf6, 0xf2, 0x75, 0x7e, 0xec, 0xd5, 0xeb, 0xfc, 0xd8, 0xe7, 0xdd, 0xbc,
714 0xf6, 0xa2, 0x9b, 0xd7, 0x5e, 0x76, 0xf3, 0xda, 0xab, 0x6e, 0x5e, 0xfb, 0xa3, 0x9b, 0xd7, 0xbe,
715 0xfa, 0x33, 0x3f, 0xf6, 0x34, 0x37, 0xfc, 0xdf, 0xda, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x12,
716 0x41, 0x18, 0xc9, 0xca, 0x15, 0x00, 0x00,
717 }
718
719 func (m *CSIDriver) Marshal() (dAtA []byte, err error) {
720 size := m.Size()
721 dAtA = make([]byte, size)
722 n, err := m.MarshalToSizedBuffer(dAtA[:size])
723 if err != nil {
724 return nil, err
725 }
726 return dAtA[:n], nil
727 }
728
729 func (m *CSIDriver) MarshalTo(dAtA []byte) (int, error) {
730 size := m.Size()
731 return m.MarshalToSizedBuffer(dAtA[:size])
732 }
733
734 func (m *CSIDriver) MarshalToSizedBuffer(dAtA []byte) (int, error) {
735 i := len(dAtA)
736 _ = i
737 var l int
738 _ = l
739 {
740 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
741 if err != nil {
742 return 0, err
743 }
744 i -= size
745 i = encodeVarintGenerated(dAtA, i, uint64(size))
746 }
747 i--
748 dAtA[i] = 0x12
749 {
750 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
751 if err != nil {
752 return 0, err
753 }
754 i -= size
755 i = encodeVarintGenerated(dAtA, i, uint64(size))
756 }
757 i--
758 dAtA[i] = 0xa
759 return len(dAtA) - i, nil
760 }
761
762 func (m *CSIDriverList) Marshal() (dAtA []byte, err error) {
763 size := m.Size()
764 dAtA = make([]byte, size)
765 n, err := m.MarshalToSizedBuffer(dAtA[:size])
766 if err != nil {
767 return nil, err
768 }
769 return dAtA[:n], nil
770 }
771
772 func (m *CSIDriverList) MarshalTo(dAtA []byte) (int, error) {
773 size := m.Size()
774 return m.MarshalToSizedBuffer(dAtA[:size])
775 }
776
777 func (m *CSIDriverList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
778 i := len(dAtA)
779 _ = i
780 var l int
781 _ = l
782 if len(m.Items) > 0 {
783 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
784 {
785 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
786 if err != nil {
787 return 0, err
788 }
789 i -= size
790 i = encodeVarintGenerated(dAtA, i, uint64(size))
791 }
792 i--
793 dAtA[i] = 0x12
794 }
795 }
796 {
797 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
798 if err != nil {
799 return 0, err
800 }
801 i -= size
802 i = encodeVarintGenerated(dAtA, i, uint64(size))
803 }
804 i--
805 dAtA[i] = 0xa
806 return len(dAtA) - i, nil
807 }
808
809 func (m *CSIDriverSpec) Marshal() (dAtA []byte, err error) {
810 size := m.Size()
811 dAtA = make([]byte, size)
812 n, err := m.MarshalToSizedBuffer(dAtA[:size])
813 if err != nil {
814 return nil, err
815 }
816 return dAtA[:n], nil
817 }
818
819 func (m *CSIDriverSpec) MarshalTo(dAtA []byte) (int, error) {
820 size := m.Size()
821 return m.MarshalToSizedBuffer(dAtA[:size])
822 }
823
824 func (m *CSIDriverSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
825 i := len(dAtA)
826 _ = i
827 var l int
828 _ = l
829 if m.SELinuxMount != nil {
830 i--
831 if *m.SELinuxMount {
832 dAtA[i] = 1
833 } else {
834 dAtA[i] = 0
835 }
836 i--
837 dAtA[i] = 0x40
838 }
839 if m.RequiresRepublish != nil {
840 i--
841 if *m.RequiresRepublish {
842 dAtA[i] = 1
843 } else {
844 dAtA[i] = 0
845 }
846 i--
847 dAtA[i] = 0x38
848 }
849 if len(m.TokenRequests) > 0 {
850 for iNdEx := len(m.TokenRequests) - 1; iNdEx >= 0; iNdEx-- {
851 {
852 size, err := m.TokenRequests[iNdEx].MarshalToSizedBuffer(dAtA[:i])
853 if err != nil {
854 return 0, err
855 }
856 i -= size
857 i = encodeVarintGenerated(dAtA, i, uint64(size))
858 }
859 i--
860 dAtA[i] = 0x32
861 }
862 }
863 if m.FSGroupPolicy != nil {
864 i -= len(*m.FSGroupPolicy)
865 copy(dAtA[i:], *m.FSGroupPolicy)
866 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.FSGroupPolicy)))
867 i--
868 dAtA[i] = 0x2a
869 }
870 if m.StorageCapacity != nil {
871 i--
872 if *m.StorageCapacity {
873 dAtA[i] = 1
874 } else {
875 dAtA[i] = 0
876 }
877 i--
878 dAtA[i] = 0x20
879 }
880 if len(m.VolumeLifecycleModes) > 0 {
881 for iNdEx := len(m.VolumeLifecycleModes) - 1; iNdEx >= 0; iNdEx-- {
882 i -= len(m.VolumeLifecycleModes[iNdEx])
883 copy(dAtA[i:], m.VolumeLifecycleModes[iNdEx])
884 i = encodeVarintGenerated(dAtA, i, uint64(len(m.VolumeLifecycleModes[iNdEx])))
885 i--
886 dAtA[i] = 0x1a
887 }
888 }
889 if m.PodInfoOnMount != nil {
890 i--
891 if *m.PodInfoOnMount {
892 dAtA[i] = 1
893 } else {
894 dAtA[i] = 0
895 }
896 i--
897 dAtA[i] = 0x10
898 }
899 if m.AttachRequired != nil {
900 i--
901 if *m.AttachRequired {
902 dAtA[i] = 1
903 } else {
904 dAtA[i] = 0
905 }
906 i--
907 dAtA[i] = 0x8
908 }
909 return len(dAtA) - i, nil
910 }
911
912 func (m *CSINode) Marshal() (dAtA []byte, err error) {
913 size := m.Size()
914 dAtA = make([]byte, size)
915 n, err := m.MarshalToSizedBuffer(dAtA[:size])
916 if err != nil {
917 return nil, err
918 }
919 return dAtA[:n], nil
920 }
921
922 func (m *CSINode) MarshalTo(dAtA []byte) (int, error) {
923 size := m.Size()
924 return m.MarshalToSizedBuffer(dAtA[:size])
925 }
926
927 func (m *CSINode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
928 i := len(dAtA)
929 _ = i
930 var l int
931 _ = l
932 {
933 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
934 if err != nil {
935 return 0, err
936 }
937 i -= size
938 i = encodeVarintGenerated(dAtA, i, uint64(size))
939 }
940 i--
941 dAtA[i] = 0x12
942 {
943 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
944 if err != nil {
945 return 0, err
946 }
947 i -= size
948 i = encodeVarintGenerated(dAtA, i, uint64(size))
949 }
950 i--
951 dAtA[i] = 0xa
952 return len(dAtA) - i, nil
953 }
954
955 func (m *CSINodeDriver) Marshal() (dAtA []byte, err error) {
956 size := m.Size()
957 dAtA = make([]byte, size)
958 n, err := m.MarshalToSizedBuffer(dAtA[:size])
959 if err != nil {
960 return nil, err
961 }
962 return dAtA[:n], nil
963 }
964
965 func (m *CSINodeDriver) MarshalTo(dAtA []byte) (int, error) {
966 size := m.Size()
967 return m.MarshalToSizedBuffer(dAtA[:size])
968 }
969
970 func (m *CSINodeDriver) MarshalToSizedBuffer(dAtA []byte) (int, error) {
971 i := len(dAtA)
972 _ = i
973 var l int
974 _ = l
975 if m.Allocatable != nil {
976 {
977 size, err := m.Allocatable.MarshalToSizedBuffer(dAtA[:i])
978 if err != nil {
979 return 0, err
980 }
981 i -= size
982 i = encodeVarintGenerated(dAtA, i, uint64(size))
983 }
984 i--
985 dAtA[i] = 0x22
986 }
987 if len(m.TopologyKeys) > 0 {
988 for iNdEx := len(m.TopologyKeys) - 1; iNdEx >= 0; iNdEx-- {
989 i -= len(m.TopologyKeys[iNdEx])
990 copy(dAtA[i:], m.TopologyKeys[iNdEx])
991 i = encodeVarintGenerated(dAtA, i, uint64(len(m.TopologyKeys[iNdEx])))
992 i--
993 dAtA[i] = 0x1a
994 }
995 }
996 i -= len(m.NodeID)
997 copy(dAtA[i:], m.NodeID)
998 i = encodeVarintGenerated(dAtA, i, uint64(len(m.NodeID)))
999 i--
1000 dAtA[i] = 0x12
1001 i -= len(m.Name)
1002 copy(dAtA[i:], m.Name)
1003 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
1004 i--
1005 dAtA[i] = 0xa
1006 return len(dAtA) - i, nil
1007 }
1008
1009 func (m *CSINodeList) Marshal() (dAtA []byte, err error) {
1010 size := m.Size()
1011 dAtA = make([]byte, size)
1012 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1013 if err != nil {
1014 return nil, err
1015 }
1016 return dAtA[:n], nil
1017 }
1018
1019 func (m *CSINodeList) MarshalTo(dAtA []byte) (int, error) {
1020 size := m.Size()
1021 return m.MarshalToSizedBuffer(dAtA[:size])
1022 }
1023
1024 func (m *CSINodeList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1025 i := len(dAtA)
1026 _ = i
1027 var l int
1028 _ = l
1029 if len(m.Items) > 0 {
1030 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1031 {
1032 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1033 if err != nil {
1034 return 0, err
1035 }
1036 i -= size
1037 i = encodeVarintGenerated(dAtA, i, uint64(size))
1038 }
1039 i--
1040 dAtA[i] = 0x12
1041 }
1042 }
1043 {
1044 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1045 if err != nil {
1046 return 0, err
1047 }
1048 i -= size
1049 i = encodeVarintGenerated(dAtA, i, uint64(size))
1050 }
1051 i--
1052 dAtA[i] = 0xa
1053 return len(dAtA) - i, nil
1054 }
1055
1056 func (m *CSINodeSpec) Marshal() (dAtA []byte, err error) {
1057 size := m.Size()
1058 dAtA = make([]byte, size)
1059 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1060 if err != nil {
1061 return nil, err
1062 }
1063 return dAtA[:n], nil
1064 }
1065
1066 func (m *CSINodeSpec) MarshalTo(dAtA []byte) (int, error) {
1067 size := m.Size()
1068 return m.MarshalToSizedBuffer(dAtA[:size])
1069 }
1070
1071 func (m *CSINodeSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1072 i := len(dAtA)
1073 _ = i
1074 var l int
1075 _ = l
1076 if len(m.Drivers) > 0 {
1077 for iNdEx := len(m.Drivers) - 1; iNdEx >= 0; iNdEx-- {
1078 {
1079 size, err := m.Drivers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1080 if err != nil {
1081 return 0, err
1082 }
1083 i -= size
1084 i = encodeVarintGenerated(dAtA, i, uint64(size))
1085 }
1086 i--
1087 dAtA[i] = 0xa
1088 }
1089 }
1090 return len(dAtA) - i, nil
1091 }
1092
1093 func (m *CSIStorageCapacity) Marshal() (dAtA []byte, err error) {
1094 size := m.Size()
1095 dAtA = make([]byte, size)
1096 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1097 if err != nil {
1098 return nil, err
1099 }
1100 return dAtA[:n], nil
1101 }
1102
1103 func (m *CSIStorageCapacity) MarshalTo(dAtA []byte) (int, error) {
1104 size := m.Size()
1105 return m.MarshalToSizedBuffer(dAtA[:size])
1106 }
1107
1108 func (m *CSIStorageCapacity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1109 i := len(dAtA)
1110 _ = i
1111 var l int
1112 _ = l
1113 if m.MaximumVolumeSize != nil {
1114 {
1115 size, err := m.MaximumVolumeSize.MarshalToSizedBuffer(dAtA[:i])
1116 if err != nil {
1117 return 0, err
1118 }
1119 i -= size
1120 i = encodeVarintGenerated(dAtA, i, uint64(size))
1121 }
1122 i--
1123 dAtA[i] = 0x2a
1124 }
1125 if m.Capacity != nil {
1126 {
1127 size, err := m.Capacity.MarshalToSizedBuffer(dAtA[:i])
1128 if err != nil {
1129 return 0, err
1130 }
1131 i -= size
1132 i = encodeVarintGenerated(dAtA, i, uint64(size))
1133 }
1134 i--
1135 dAtA[i] = 0x22
1136 }
1137 i -= len(m.StorageClassName)
1138 copy(dAtA[i:], m.StorageClassName)
1139 i = encodeVarintGenerated(dAtA, i, uint64(len(m.StorageClassName)))
1140 i--
1141 dAtA[i] = 0x1a
1142 if m.NodeTopology != nil {
1143 {
1144 size, err := m.NodeTopology.MarshalToSizedBuffer(dAtA[:i])
1145 if err != nil {
1146 return 0, err
1147 }
1148 i -= size
1149 i = encodeVarintGenerated(dAtA, i, uint64(size))
1150 }
1151 i--
1152 dAtA[i] = 0x12
1153 }
1154 {
1155 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1156 if err != nil {
1157 return 0, err
1158 }
1159 i -= size
1160 i = encodeVarintGenerated(dAtA, i, uint64(size))
1161 }
1162 i--
1163 dAtA[i] = 0xa
1164 return len(dAtA) - i, nil
1165 }
1166
1167 func (m *CSIStorageCapacityList) Marshal() (dAtA []byte, err error) {
1168 size := m.Size()
1169 dAtA = make([]byte, size)
1170 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1171 if err != nil {
1172 return nil, err
1173 }
1174 return dAtA[:n], nil
1175 }
1176
1177 func (m *CSIStorageCapacityList) MarshalTo(dAtA []byte) (int, error) {
1178 size := m.Size()
1179 return m.MarshalToSizedBuffer(dAtA[:size])
1180 }
1181
1182 func (m *CSIStorageCapacityList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1183 i := len(dAtA)
1184 _ = i
1185 var l int
1186 _ = l
1187 if len(m.Items) > 0 {
1188 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1189 {
1190 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1191 if err != nil {
1192 return 0, err
1193 }
1194 i -= size
1195 i = encodeVarintGenerated(dAtA, i, uint64(size))
1196 }
1197 i--
1198 dAtA[i] = 0x12
1199 }
1200 }
1201 {
1202 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1203 if err != nil {
1204 return 0, err
1205 }
1206 i -= size
1207 i = encodeVarintGenerated(dAtA, i, uint64(size))
1208 }
1209 i--
1210 dAtA[i] = 0xa
1211 return len(dAtA) - i, nil
1212 }
1213
1214 func (m *StorageClass) Marshal() (dAtA []byte, err error) {
1215 size := m.Size()
1216 dAtA = make([]byte, size)
1217 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1218 if err != nil {
1219 return nil, err
1220 }
1221 return dAtA[:n], nil
1222 }
1223
1224 func (m *StorageClass) MarshalTo(dAtA []byte) (int, error) {
1225 size := m.Size()
1226 return m.MarshalToSizedBuffer(dAtA[:size])
1227 }
1228
1229 func (m *StorageClass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1230 i := len(dAtA)
1231 _ = i
1232 var l int
1233 _ = l
1234 if len(m.AllowedTopologies) > 0 {
1235 for iNdEx := len(m.AllowedTopologies) - 1; iNdEx >= 0; iNdEx-- {
1236 {
1237 size, err := m.AllowedTopologies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1238 if err != nil {
1239 return 0, err
1240 }
1241 i -= size
1242 i = encodeVarintGenerated(dAtA, i, uint64(size))
1243 }
1244 i--
1245 dAtA[i] = 0x42
1246 }
1247 }
1248 if m.VolumeBindingMode != nil {
1249 i -= len(*m.VolumeBindingMode)
1250 copy(dAtA[i:], *m.VolumeBindingMode)
1251 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.VolumeBindingMode)))
1252 i--
1253 dAtA[i] = 0x3a
1254 }
1255 if m.AllowVolumeExpansion != nil {
1256 i--
1257 if *m.AllowVolumeExpansion {
1258 dAtA[i] = 1
1259 } else {
1260 dAtA[i] = 0
1261 }
1262 i--
1263 dAtA[i] = 0x30
1264 }
1265 if len(m.MountOptions) > 0 {
1266 for iNdEx := len(m.MountOptions) - 1; iNdEx >= 0; iNdEx-- {
1267 i -= len(m.MountOptions[iNdEx])
1268 copy(dAtA[i:], m.MountOptions[iNdEx])
1269 i = encodeVarintGenerated(dAtA, i, uint64(len(m.MountOptions[iNdEx])))
1270 i--
1271 dAtA[i] = 0x2a
1272 }
1273 }
1274 if m.ReclaimPolicy != nil {
1275 i -= len(*m.ReclaimPolicy)
1276 copy(dAtA[i:], *m.ReclaimPolicy)
1277 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ReclaimPolicy)))
1278 i--
1279 dAtA[i] = 0x22
1280 }
1281 if len(m.Parameters) > 0 {
1282 keysForParameters := make([]string, 0, len(m.Parameters))
1283 for k := range m.Parameters {
1284 keysForParameters = append(keysForParameters, string(k))
1285 }
1286 github_com_gogo_protobuf_sortkeys.Strings(keysForParameters)
1287 for iNdEx := len(keysForParameters) - 1; iNdEx >= 0; iNdEx-- {
1288 v := m.Parameters[string(keysForParameters[iNdEx])]
1289 baseI := i
1290 i -= len(v)
1291 copy(dAtA[i:], v)
1292 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1293 i--
1294 dAtA[i] = 0x12
1295 i -= len(keysForParameters[iNdEx])
1296 copy(dAtA[i:], keysForParameters[iNdEx])
1297 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForParameters[iNdEx])))
1298 i--
1299 dAtA[i] = 0xa
1300 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
1301 i--
1302 dAtA[i] = 0x1a
1303 }
1304 }
1305 i -= len(m.Provisioner)
1306 copy(dAtA[i:], m.Provisioner)
1307 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Provisioner)))
1308 i--
1309 dAtA[i] = 0x12
1310 {
1311 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1312 if err != nil {
1313 return 0, err
1314 }
1315 i -= size
1316 i = encodeVarintGenerated(dAtA, i, uint64(size))
1317 }
1318 i--
1319 dAtA[i] = 0xa
1320 return len(dAtA) - i, nil
1321 }
1322
1323 func (m *StorageClassList) Marshal() (dAtA []byte, err error) {
1324 size := m.Size()
1325 dAtA = make([]byte, size)
1326 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1327 if err != nil {
1328 return nil, err
1329 }
1330 return dAtA[:n], nil
1331 }
1332
1333 func (m *StorageClassList) MarshalTo(dAtA []byte) (int, error) {
1334 size := m.Size()
1335 return m.MarshalToSizedBuffer(dAtA[:size])
1336 }
1337
1338 func (m *StorageClassList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1339 i := len(dAtA)
1340 _ = i
1341 var l int
1342 _ = l
1343 if len(m.Items) > 0 {
1344 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1345 {
1346 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1347 if err != nil {
1348 return 0, err
1349 }
1350 i -= size
1351 i = encodeVarintGenerated(dAtA, i, uint64(size))
1352 }
1353 i--
1354 dAtA[i] = 0x12
1355 }
1356 }
1357 {
1358 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1359 if err != nil {
1360 return 0, err
1361 }
1362 i -= size
1363 i = encodeVarintGenerated(dAtA, i, uint64(size))
1364 }
1365 i--
1366 dAtA[i] = 0xa
1367 return len(dAtA) - i, nil
1368 }
1369
1370 func (m *TokenRequest) Marshal() (dAtA []byte, err error) {
1371 size := m.Size()
1372 dAtA = make([]byte, size)
1373 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1374 if err != nil {
1375 return nil, err
1376 }
1377 return dAtA[:n], nil
1378 }
1379
1380 func (m *TokenRequest) MarshalTo(dAtA []byte) (int, error) {
1381 size := m.Size()
1382 return m.MarshalToSizedBuffer(dAtA[:size])
1383 }
1384
1385 func (m *TokenRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1386 i := len(dAtA)
1387 _ = i
1388 var l int
1389 _ = l
1390 if m.ExpirationSeconds != nil {
1391 i = encodeVarintGenerated(dAtA, i, uint64(*m.ExpirationSeconds))
1392 i--
1393 dAtA[i] = 0x10
1394 }
1395 i -= len(m.Audience)
1396 copy(dAtA[i:], m.Audience)
1397 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Audience)))
1398 i--
1399 dAtA[i] = 0xa
1400 return len(dAtA) - i, nil
1401 }
1402
1403 func (m *VolumeAttachment) Marshal() (dAtA []byte, err error) {
1404 size := m.Size()
1405 dAtA = make([]byte, size)
1406 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1407 if err != nil {
1408 return nil, err
1409 }
1410 return dAtA[:n], nil
1411 }
1412
1413 func (m *VolumeAttachment) MarshalTo(dAtA []byte) (int, error) {
1414 size := m.Size()
1415 return m.MarshalToSizedBuffer(dAtA[:size])
1416 }
1417
1418 func (m *VolumeAttachment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1419 i := len(dAtA)
1420 _ = i
1421 var l int
1422 _ = l
1423 {
1424 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
1425 if err != nil {
1426 return 0, err
1427 }
1428 i -= size
1429 i = encodeVarintGenerated(dAtA, i, uint64(size))
1430 }
1431 i--
1432 dAtA[i] = 0x1a
1433 {
1434 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
1435 if err != nil {
1436 return 0, err
1437 }
1438 i -= size
1439 i = encodeVarintGenerated(dAtA, i, uint64(size))
1440 }
1441 i--
1442 dAtA[i] = 0x12
1443 {
1444 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
1445 if err != nil {
1446 return 0, err
1447 }
1448 i -= size
1449 i = encodeVarintGenerated(dAtA, i, uint64(size))
1450 }
1451 i--
1452 dAtA[i] = 0xa
1453 return len(dAtA) - i, nil
1454 }
1455
1456 func (m *VolumeAttachmentList) Marshal() (dAtA []byte, err error) {
1457 size := m.Size()
1458 dAtA = make([]byte, size)
1459 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1460 if err != nil {
1461 return nil, err
1462 }
1463 return dAtA[:n], nil
1464 }
1465
1466 func (m *VolumeAttachmentList) MarshalTo(dAtA []byte) (int, error) {
1467 size := m.Size()
1468 return m.MarshalToSizedBuffer(dAtA[:size])
1469 }
1470
1471 func (m *VolumeAttachmentList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1472 i := len(dAtA)
1473 _ = i
1474 var l int
1475 _ = l
1476 if len(m.Items) > 0 {
1477 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
1478 {
1479 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
1480 if err != nil {
1481 return 0, err
1482 }
1483 i -= size
1484 i = encodeVarintGenerated(dAtA, i, uint64(size))
1485 }
1486 i--
1487 dAtA[i] = 0x12
1488 }
1489 }
1490 {
1491 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
1492 if err != nil {
1493 return 0, err
1494 }
1495 i -= size
1496 i = encodeVarintGenerated(dAtA, i, uint64(size))
1497 }
1498 i--
1499 dAtA[i] = 0xa
1500 return len(dAtA) - i, nil
1501 }
1502
1503 func (m *VolumeAttachmentSource) Marshal() (dAtA []byte, err error) {
1504 size := m.Size()
1505 dAtA = make([]byte, size)
1506 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1507 if err != nil {
1508 return nil, err
1509 }
1510 return dAtA[:n], nil
1511 }
1512
1513 func (m *VolumeAttachmentSource) MarshalTo(dAtA []byte) (int, error) {
1514 size := m.Size()
1515 return m.MarshalToSizedBuffer(dAtA[:size])
1516 }
1517
1518 func (m *VolumeAttachmentSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1519 i := len(dAtA)
1520 _ = i
1521 var l int
1522 _ = l
1523 if m.InlineVolumeSpec != nil {
1524 {
1525 size, err := m.InlineVolumeSpec.MarshalToSizedBuffer(dAtA[:i])
1526 if err != nil {
1527 return 0, err
1528 }
1529 i -= size
1530 i = encodeVarintGenerated(dAtA, i, uint64(size))
1531 }
1532 i--
1533 dAtA[i] = 0x12
1534 }
1535 if m.PersistentVolumeName != nil {
1536 i -= len(*m.PersistentVolumeName)
1537 copy(dAtA[i:], *m.PersistentVolumeName)
1538 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PersistentVolumeName)))
1539 i--
1540 dAtA[i] = 0xa
1541 }
1542 return len(dAtA) - i, nil
1543 }
1544
1545 func (m *VolumeAttachmentSpec) Marshal() (dAtA []byte, err error) {
1546 size := m.Size()
1547 dAtA = make([]byte, size)
1548 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1549 if err != nil {
1550 return nil, err
1551 }
1552 return dAtA[:n], nil
1553 }
1554
1555 func (m *VolumeAttachmentSpec) MarshalTo(dAtA []byte) (int, error) {
1556 size := m.Size()
1557 return m.MarshalToSizedBuffer(dAtA[:size])
1558 }
1559
1560 func (m *VolumeAttachmentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1561 i := len(dAtA)
1562 _ = i
1563 var l int
1564 _ = l
1565 i -= len(m.NodeName)
1566 copy(dAtA[i:], m.NodeName)
1567 i = encodeVarintGenerated(dAtA, i, uint64(len(m.NodeName)))
1568 i--
1569 dAtA[i] = 0x1a
1570 {
1571 size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
1572 if err != nil {
1573 return 0, err
1574 }
1575 i -= size
1576 i = encodeVarintGenerated(dAtA, i, uint64(size))
1577 }
1578 i--
1579 dAtA[i] = 0x12
1580 i -= len(m.Attacher)
1581 copy(dAtA[i:], m.Attacher)
1582 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Attacher)))
1583 i--
1584 dAtA[i] = 0xa
1585 return len(dAtA) - i, nil
1586 }
1587
1588 func (m *VolumeAttachmentStatus) Marshal() (dAtA []byte, err error) {
1589 size := m.Size()
1590 dAtA = make([]byte, size)
1591 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1592 if err != nil {
1593 return nil, err
1594 }
1595 return dAtA[:n], nil
1596 }
1597
1598 func (m *VolumeAttachmentStatus) MarshalTo(dAtA []byte) (int, error) {
1599 size := m.Size()
1600 return m.MarshalToSizedBuffer(dAtA[:size])
1601 }
1602
1603 func (m *VolumeAttachmentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1604 i := len(dAtA)
1605 _ = i
1606 var l int
1607 _ = l
1608 if m.DetachError != nil {
1609 {
1610 size, err := m.DetachError.MarshalToSizedBuffer(dAtA[:i])
1611 if err != nil {
1612 return 0, err
1613 }
1614 i -= size
1615 i = encodeVarintGenerated(dAtA, i, uint64(size))
1616 }
1617 i--
1618 dAtA[i] = 0x22
1619 }
1620 if m.AttachError != nil {
1621 {
1622 size, err := m.AttachError.MarshalToSizedBuffer(dAtA[:i])
1623 if err != nil {
1624 return 0, err
1625 }
1626 i -= size
1627 i = encodeVarintGenerated(dAtA, i, uint64(size))
1628 }
1629 i--
1630 dAtA[i] = 0x1a
1631 }
1632 if len(m.AttachmentMetadata) > 0 {
1633 keysForAttachmentMetadata := make([]string, 0, len(m.AttachmentMetadata))
1634 for k := range m.AttachmentMetadata {
1635 keysForAttachmentMetadata = append(keysForAttachmentMetadata, string(k))
1636 }
1637 github_com_gogo_protobuf_sortkeys.Strings(keysForAttachmentMetadata)
1638 for iNdEx := len(keysForAttachmentMetadata) - 1; iNdEx >= 0; iNdEx-- {
1639 v := m.AttachmentMetadata[string(keysForAttachmentMetadata[iNdEx])]
1640 baseI := i
1641 i -= len(v)
1642 copy(dAtA[i:], v)
1643 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
1644 i--
1645 dAtA[i] = 0x12
1646 i -= len(keysForAttachmentMetadata[iNdEx])
1647 copy(dAtA[i:], keysForAttachmentMetadata[iNdEx])
1648 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAttachmentMetadata[iNdEx])))
1649 i--
1650 dAtA[i] = 0xa
1651 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
1652 i--
1653 dAtA[i] = 0x12
1654 }
1655 }
1656 i--
1657 if m.Attached {
1658 dAtA[i] = 1
1659 } else {
1660 dAtA[i] = 0
1661 }
1662 i--
1663 dAtA[i] = 0x8
1664 return len(dAtA) - i, nil
1665 }
1666
1667 func (m *VolumeError) Marshal() (dAtA []byte, err error) {
1668 size := m.Size()
1669 dAtA = make([]byte, size)
1670 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1671 if err != nil {
1672 return nil, err
1673 }
1674 return dAtA[:n], nil
1675 }
1676
1677 func (m *VolumeError) MarshalTo(dAtA []byte) (int, error) {
1678 size := m.Size()
1679 return m.MarshalToSizedBuffer(dAtA[:size])
1680 }
1681
1682 func (m *VolumeError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1683 i := len(dAtA)
1684 _ = i
1685 var l int
1686 _ = l
1687 i -= len(m.Message)
1688 copy(dAtA[i:], m.Message)
1689 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
1690 i--
1691 dAtA[i] = 0x12
1692 {
1693 size, err := m.Time.MarshalToSizedBuffer(dAtA[:i])
1694 if err != nil {
1695 return 0, err
1696 }
1697 i -= size
1698 i = encodeVarintGenerated(dAtA, i, uint64(size))
1699 }
1700 i--
1701 dAtA[i] = 0xa
1702 return len(dAtA) - i, nil
1703 }
1704
1705 func (m *VolumeNodeResources) Marshal() (dAtA []byte, err error) {
1706 size := m.Size()
1707 dAtA = make([]byte, size)
1708 n, err := m.MarshalToSizedBuffer(dAtA[:size])
1709 if err != nil {
1710 return nil, err
1711 }
1712 return dAtA[:n], nil
1713 }
1714
1715 func (m *VolumeNodeResources) MarshalTo(dAtA []byte) (int, error) {
1716 size := m.Size()
1717 return m.MarshalToSizedBuffer(dAtA[:size])
1718 }
1719
1720 func (m *VolumeNodeResources) MarshalToSizedBuffer(dAtA []byte) (int, error) {
1721 i := len(dAtA)
1722 _ = i
1723 var l int
1724 _ = l
1725 if m.Count != nil {
1726 i = encodeVarintGenerated(dAtA, i, uint64(*m.Count))
1727 i--
1728 dAtA[i] = 0x8
1729 }
1730 return len(dAtA) - i, nil
1731 }
1732
1733 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
1734 offset -= sovGenerated(v)
1735 base := offset
1736 for v >= 1<<7 {
1737 dAtA[offset] = uint8(v&0x7f | 0x80)
1738 v >>= 7
1739 offset++
1740 }
1741 dAtA[offset] = uint8(v)
1742 return base
1743 }
1744 func (m *CSIDriver) Size() (n int) {
1745 if m == nil {
1746 return 0
1747 }
1748 var l int
1749 _ = l
1750 l = m.ObjectMeta.Size()
1751 n += 1 + l + sovGenerated(uint64(l))
1752 l = m.Spec.Size()
1753 n += 1 + l + sovGenerated(uint64(l))
1754 return n
1755 }
1756
1757 func (m *CSIDriverList) Size() (n int) {
1758 if m == nil {
1759 return 0
1760 }
1761 var l int
1762 _ = l
1763 l = m.ListMeta.Size()
1764 n += 1 + l + sovGenerated(uint64(l))
1765 if len(m.Items) > 0 {
1766 for _, e := range m.Items {
1767 l = e.Size()
1768 n += 1 + l + sovGenerated(uint64(l))
1769 }
1770 }
1771 return n
1772 }
1773
1774 func (m *CSIDriverSpec) Size() (n int) {
1775 if m == nil {
1776 return 0
1777 }
1778 var l int
1779 _ = l
1780 if m.AttachRequired != nil {
1781 n += 2
1782 }
1783 if m.PodInfoOnMount != nil {
1784 n += 2
1785 }
1786 if len(m.VolumeLifecycleModes) > 0 {
1787 for _, s := range m.VolumeLifecycleModes {
1788 l = len(s)
1789 n += 1 + l + sovGenerated(uint64(l))
1790 }
1791 }
1792 if m.StorageCapacity != nil {
1793 n += 2
1794 }
1795 if m.FSGroupPolicy != nil {
1796 l = len(*m.FSGroupPolicy)
1797 n += 1 + l + sovGenerated(uint64(l))
1798 }
1799 if len(m.TokenRequests) > 0 {
1800 for _, e := range m.TokenRequests {
1801 l = e.Size()
1802 n += 1 + l + sovGenerated(uint64(l))
1803 }
1804 }
1805 if m.RequiresRepublish != nil {
1806 n += 2
1807 }
1808 if m.SELinuxMount != nil {
1809 n += 2
1810 }
1811 return n
1812 }
1813
1814 func (m *CSINode) Size() (n int) {
1815 if m == nil {
1816 return 0
1817 }
1818 var l int
1819 _ = l
1820 l = m.ObjectMeta.Size()
1821 n += 1 + l + sovGenerated(uint64(l))
1822 l = m.Spec.Size()
1823 n += 1 + l + sovGenerated(uint64(l))
1824 return n
1825 }
1826
1827 func (m *CSINodeDriver) Size() (n int) {
1828 if m == nil {
1829 return 0
1830 }
1831 var l int
1832 _ = l
1833 l = len(m.Name)
1834 n += 1 + l + sovGenerated(uint64(l))
1835 l = len(m.NodeID)
1836 n += 1 + l + sovGenerated(uint64(l))
1837 if len(m.TopologyKeys) > 0 {
1838 for _, s := range m.TopologyKeys {
1839 l = len(s)
1840 n += 1 + l + sovGenerated(uint64(l))
1841 }
1842 }
1843 if m.Allocatable != nil {
1844 l = m.Allocatable.Size()
1845 n += 1 + l + sovGenerated(uint64(l))
1846 }
1847 return n
1848 }
1849
1850 func (m *CSINodeList) Size() (n int) {
1851 if m == nil {
1852 return 0
1853 }
1854 var l int
1855 _ = l
1856 l = m.ListMeta.Size()
1857 n += 1 + l + sovGenerated(uint64(l))
1858 if len(m.Items) > 0 {
1859 for _, e := range m.Items {
1860 l = e.Size()
1861 n += 1 + l + sovGenerated(uint64(l))
1862 }
1863 }
1864 return n
1865 }
1866
1867 func (m *CSINodeSpec) Size() (n int) {
1868 if m == nil {
1869 return 0
1870 }
1871 var l int
1872 _ = l
1873 if len(m.Drivers) > 0 {
1874 for _, e := range m.Drivers {
1875 l = e.Size()
1876 n += 1 + l + sovGenerated(uint64(l))
1877 }
1878 }
1879 return n
1880 }
1881
1882 func (m *CSIStorageCapacity) Size() (n int) {
1883 if m == nil {
1884 return 0
1885 }
1886 var l int
1887 _ = l
1888 l = m.ObjectMeta.Size()
1889 n += 1 + l + sovGenerated(uint64(l))
1890 if m.NodeTopology != nil {
1891 l = m.NodeTopology.Size()
1892 n += 1 + l + sovGenerated(uint64(l))
1893 }
1894 l = len(m.StorageClassName)
1895 n += 1 + l + sovGenerated(uint64(l))
1896 if m.Capacity != nil {
1897 l = m.Capacity.Size()
1898 n += 1 + l + sovGenerated(uint64(l))
1899 }
1900 if m.MaximumVolumeSize != nil {
1901 l = m.MaximumVolumeSize.Size()
1902 n += 1 + l + sovGenerated(uint64(l))
1903 }
1904 return n
1905 }
1906
1907 func (m *CSIStorageCapacityList) Size() (n int) {
1908 if m == nil {
1909 return 0
1910 }
1911 var l int
1912 _ = l
1913 l = m.ListMeta.Size()
1914 n += 1 + l + sovGenerated(uint64(l))
1915 if len(m.Items) > 0 {
1916 for _, e := range m.Items {
1917 l = e.Size()
1918 n += 1 + l + sovGenerated(uint64(l))
1919 }
1920 }
1921 return n
1922 }
1923
1924 func (m *StorageClass) Size() (n int) {
1925 if m == nil {
1926 return 0
1927 }
1928 var l int
1929 _ = l
1930 l = m.ObjectMeta.Size()
1931 n += 1 + l + sovGenerated(uint64(l))
1932 l = len(m.Provisioner)
1933 n += 1 + l + sovGenerated(uint64(l))
1934 if len(m.Parameters) > 0 {
1935 for k, v := range m.Parameters {
1936 _ = k
1937 _ = v
1938 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
1939 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
1940 }
1941 }
1942 if m.ReclaimPolicy != nil {
1943 l = len(*m.ReclaimPolicy)
1944 n += 1 + l + sovGenerated(uint64(l))
1945 }
1946 if len(m.MountOptions) > 0 {
1947 for _, s := range m.MountOptions {
1948 l = len(s)
1949 n += 1 + l + sovGenerated(uint64(l))
1950 }
1951 }
1952 if m.AllowVolumeExpansion != nil {
1953 n += 2
1954 }
1955 if m.VolumeBindingMode != nil {
1956 l = len(*m.VolumeBindingMode)
1957 n += 1 + l + sovGenerated(uint64(l))
1958 }
1959 if len(m.AllowedTopologies) > 0 {
1960 for _, e := range m.AllowedTopologies {
1961 l = e.Size()
1962 n += 1 + l + sovGenerated(uint64(l))
1963 }
1964 }
1965 return n
1966 }
1967
1968 func (m *StorageClassList) Size() (n int) {
1969 if m == nil {
1970 return 0
1971 }
1972 var l int
1973 _ = l
1974 l = m.ListMeta.Size()
1975 n += 1 + l + sovGenerated(uint64(l))
1976 if len(m.Items) > 0 {
1977 for _, e := range m.Items {
1978 l = e.Size()
1979 n += 1 + l + sovGenerated(uint64(l))
1980 }
1981 }
1982 return n
1983 }
1984
1985 func (m *TokenRequest) Size() (n int) {
1986 if m == nil {
1987 return 0
1988 }
1989 var l int
1990 _ = l
1991 l = len(m.Audience)
1992 n += 1 + l + sovGenerated(uint64(l))
1993 if m.ExpirationSeconds != nil {
1994 n += 1 + sovGenerated(uint64(*m.ExpirationSeconds))
1995 }
1996 return n
1997 }
1998
1999 func (m *VolumeAttachment) Size() (n int) {
2000 if m == nil {
2001 return 0
2002 }
2003 var l int
2004 _ = l
2005 l = m.ObjectMeta.Size()
2006 n += 1 + l + sovGenerated(uint64(l))
2007 l = m.Spec.Size()
2008 n += 1 + l + sovGenerated(uint64(l))
2009 l = m.Status.Size()
2010 n += 1 + l + sovGenerated(uint64(l))
2011 return n
2012 }
2013
2014 func (m *VolumeAttachmentList) Size() (n int) {
2015 if m == nil {
2016 return 0
2017 }
2018 var l int
2019 _ = l
2020 l = m.ListMeta.Size()
2021 n += 1 + l + sovGenerated(uint64(l))
2022 if len(m.Items) > 0 {
2023 for _, e := range m.Items {
2024 l = e.Size()
2025 n += 1 + l + sovGenerated(uint64(l))
2026 }
2027 }
2028 return n
2029 }
2030
2031 func (m *VolumeAttachmentSource) Size() (n int) {
2032 if m == nil {
2033 return 0
2034 }
2035 var l int
2036 _ = l
2037 if m.PersistentVolumeName != nil {
2038 l = len(*m.PersistentVolumeName)
2039 n += 1 + l + sovGenerated(uint64(l))
2040 }
2041 if m.InlineVolumeSpec != nil {
2042 l = m.InlineVolumeSpec.Size()
2043 n += 1 + l + sovGenerated(uint64(l))
2044 }
2045 return n
2046 }
2047
2048 func (m *VolumeAttachmentSpec) Size() (n int) {
2049 if m == nil {
2050 return 0
2051 }
2052 var l int
2053 _ = l
2054 l = len(m.Attacher)
2055 n += 1 + l + sovGenerated(uint64(l))
2056 l = m.Source.Size()
2057 n += 1 + l + sovGenerated(uint64(l))
2058 l = len(m.NodeName)
2059 n += 1 + l + sovGenerated(uint64(l))
2060 return n
2061 }
2062
2063 func (m *VolumeAttachmentStatus) Size() (n int) {
2064 if m == nil {
2065 return 0
2066 }
2067 var l int
2068 _ = l
2069 n += 2
2070 if len(m.AttachmentMetadata) > 0 {
2071 for k, v := range m.AttachmentMetadata {
2072 _ = k
2073 _ = v
2074 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
2075 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
2076 }
2077 }
2078 if m.AttachError != nil {
2079 l = m.AttachError.Size()
2080 n += 1 + l + sovGenerated(uint64(l))
2081 }
2082 if m.DetachError != nil {
2083 l = m.DetachError.Size()
2084 n += 1 + l + sovGenerated(uint64(l))
2085 }
2086 return n
2087 }
2088
2089 func (m *VolumeError) Size() (n int) {
2090 if m == nil {
2091 return 0
2092 }
2093 var l int
2094 _ = l
2095 l = m.Time.Size()
2096 n += 1 + l + sovGenerated(uint64(l))
2097 l = len(m.Message)
2098 n += 1 + l + sovGenerated(uint64(l))
2099 return n
2100 }
2101
2102 func (m *VolumeNodeResources) Size() (n int) {
2103 if m == nil {
2104 return 0
2105 }
2106 var l int
2107 _ = l
2108 if m.Count != nil {
2109 n += 1 + sovGenerated(uint64(*m.Count))
2110 }
2111 return n
2112 }
2113
2114 func sovGenerated(x uint64) (n int) {
2115 return (math_bits.Len64(x|1) + 6) / 7
2116 }
2117 func sozGenerated(x uint64) (n int) {
2118 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
2119 }
2120 func (this *CSIDriver) String() string {
2121 if this == nil {
2122 return "nil"
2123 }
2124 s := strings.Join([]string{`&CSIDriver{`,
2125 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2126 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CSIDriverSpec", "CSIDriverSpec", 1), `&`, ``, 1) + `,`,
2127 `}`,
2128 }, "")
2129 return s
2130 }
2131 func (this *CSIDriverList) String() string {
2132 if this == nil {
2133 return "nil"
2134 }
2135 repeatedStringForItems := "[]CSIDriver{"
2136 for _, f := range this.Items {
2137 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CSIDriver", "CSIDriver", 1), `&`, ``, 1) + ","
2138 }
2139 repeatedStringForItems += "}"
2140 s := strings.Join([]string{`&CSIDriverList{`,
2141 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2142 `Items:` + repeatedStringForItems + `,`,
2143 `}`,
2144 }, "")
2145 return s
2146 }
2147 func (this *CSIDriverSpec) String() string {
2148 if this == nil {
2149 return "nil"
2150 }
2151 repeatedStringForTokenRequests := "[]TokenRequest{"
2152 for _, f := range this.TokenRequests {
2153 repeatedStringForTokenRequests += strings.Replace(strings.Replace(f.String(), "TokenRequest", "TokenRequest", 1), `&`, ``, 1) + ","
2154 }
2155 repeatedStringForTokenRequests += "}"
2156 s := strings.Join([]string{`&CSIDriverSpec{`,
2157 `AttachRequired:` + valueToStringGenerated(this.AttachRequired) + `,`,
2158 `PodInfoOnMount:` + valueToStringGenerated(this.PodInfoOnMount) + `,`,
2159 `VolumeLifecycleModes:` + fmt.Sprintf("%v", this.VolumeLifecycleModes) + `,`,
2160 `StorageCapacity:` + valueToStringGenerated(this.StorageCapacity) + `,`,
2161 `FSGroupPolicy:` + valueToStringGenerated(this.FSGroupPolicy) + `,`,
2162 `TokenRequests:` + repeatedStringForTokenRequests + `,`,
2163 `RequiresRepublish:` + valueToStringGenerated(this.RequiresRepublish) + `,`,
2164 `SELinuxMount:` + valueToStringGenerated(this.SELinuxMount) + `,`,
2165 `}`,
2166 }, "")
2167 return s
2168 }
2169 func (this *CSINode) String() string {
2170 if this == nil {
2171 return "nil"
2172 }
2173 s := strings.Join([]string{`&CSINode{`,
2174 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2175 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CSINodeSpec", "CSINodeSpec", 1), `&`, ``, 1) + `,`,
2176 `}`,
2177 }, "")
2178 return s
2179 }
2180 func (this *CSINodeDriver) String() string {
2181 if this == nil {
2182 return "nil"
2183 }
2184 s := strings.Join([]string{`&CSINodeDriver{`,
2185 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
2186 `NodeID:` + fmt.Sprintf("%v", this.NodeID) + `,`,
2187 `TopologyKeys:` + fmt.Sprintf("%v", this.TopologyKeys) + `,`,
2188 `Allocatable:` + strings.Replace(this.Allocatable.String(), "VolumeNodeResources", "VolumeNodeResources", 1) + `,`,
2189 `}`,
2190 }, "")
2191 return s
2192 }
2193 func (this *CSINodeList) String() string {
2194 if this == nil {
2195 return "nil"
2196 }
2197 repeatedStringForItems := "[]CSINode{"
2198 for _, f := range this.Items {
2199 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CSINode", "CSINode", 1), `&`, ``, 1) + ","
2200 }
2201 repeatedStringForItems += "}"
2202 s := strings.Join([]string{`&CSINodeList{`,
2203 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2204 `Items:` + repeatedStringForItems + `,`,
2205 `}`,
2206 }, "")
2207 return s
2208 }
2209 func (this *CSINodeSpec) String() string {
2210 if this == nil {
2211 return "nil"
2212 }
2213 repeatedStringForDrivers := "[]CSINodeDriver{"
2214 for _, f := range this.Drivers {
2215 repeatedStringForDrivers += strings.Replace(strings.Replace(f.String(), "CSINodeDriver", "CSINodeDriver", 1), `&`, ``, 1) + ","
2216 }
2217 repeatedStringForDrivers += "}"
2218 s := strings.Join([]string{`&CSINodeSpec{`,
2219 `Drivers:` + repeatedStringForDrivers + `,`,
2220 `}`,
2221 }, "")
2222 return s
2223 }
2224 func (this *CSIStorageCapacity) String() string {
2225 if this == nil {
2226 return "nil"
2227 }
2228 s := strings.Join([]string{`&CSIStorageCapacity{`,
2229 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2230 `NodeTopology:` + strings.Replace(fmt.Sprintf("%v", this.NodeTopology), "LabelSelector", "v1.LabelSelector", 1) + `,`,
2231 `StorageClassName:` + fmt.Sprintf("%v", this.StorageClassName) + `,`,
2232 `Capacity:` + strings.Replace(fmt.Sprintf("%v", this.Capacity), "Quantity", "resource.Quantity", 1) + `,`,
2233 `MaximumVolumeSize:` + strings.Replace(fmt.Sprintf("%v", this.MaximumVolumeSize), "Quantity", "resource.Quantity", 1) + `,`,
2234 `}`,
2235 }, "")
2236 return s
2237 }
2238 func (this *CSIStorageCapacityList) String() string {
2239 if this == nil {
2240 return "nil"
2241 }
2242 repeatedStringForItems := "[]CSIStorageCapacity{"
2243 for _, f := range this.Items {
2244 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CSIStorageCapacity", "CSIStorageCapacity", 1), `&`, ``, 1) + ","
2245 }
2246 repeatedStringForItems += "}"
2247 s := strings.Join([]string{`&CSIStorageCapacityList{`,
2248 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2249 `Items:` + repeatedStringForItems + `,`,
2250 `}`,
2251 }, "")
2252 return s
2253 }
2254 func (this *StorageClass) String() string {
2255 if this == nil {
2256 return "nil"
2257 }
2258 repeatedStringForAllowedTopologies := "[]TopologySelectorTerm{"
2259 for _, f := range this.AllowedTopologies {
2260 repeatedStringForAllowedTopologies += fmt.Sprintf("%v", f) + ","
2261 }
2262 repeatedStringForAllowedTopologies += "}"
2263 keysForParameters := make([]string, 0, len(this.Parameters))
2264 for k := range this.Parameters {
2265 keysForParameters = append(keysForParameters, k)
2266 }
2267 github_com_gogo_protobuf_sortkeys.Strings(keysForParameters)
2268 mapStringForParameters := "map[string]string{"
2269 for _, k := range keysForParameters {
2270 mapStringForParameters += fmt.Sprintf("%v: %v,", k, this.Parameters[k])
2271 }
2272 mapStringForParameters += "}"
2273 s := strings.Join([]string{`&StorageClass{`,
2274 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2275 `Provisioner:` + fmt.Sprintf("%v", this.Provisioner) + `,`,
2276 `Parameters:` + mapStringForParameters + `,`,
2277 `ReclaimPolicy:` + valueToStringGenerated(this.ReclaimPolicy) + `,`,
2278 `MountOptions:` + fmt.Sprintf("%v", this.MountOptions) + `,`,
2279 `AllowVolumeExpansion:` + valueToStringGenerated(this.AllowVolumeExpansion) + `,`,
2280 `VolumeBindingMode:` + valueToStringGenerated(this.VolumeBindingMode) + `,`,
2281 `AllowedTopologies:` + repeatedStringForAllowedTopologies + `,`,
2282 `}`,
2283 }, "")
2284 return s
2285 }
2286 func (this *StorageClassList) String() string {
2287 if this == nil {
2288 return "nil"
2289 }
2290 repeatedStringForItems := "[]StorageClass{"
2291 for _, f := range this.Items {
2292 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "StorageClass", "StorageClass", 1), `&`, ``, 1) + ","
2293 }
2294 repeatedStringForItems += "}"
2295 s := strings.Join([]string{`&StorageClassList{`,
2296 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2297 `Items:` + repeatedStringForItems + `,`,
2298 `}`,
2299 }, "")
2300 return s
2301 }
2302 func (this *TokenRequest) String() string {
2303 if this == nil {
2304 return "nil"
2305 }
2306 s := strings.Join([]string{`&TokenRequest{`,
2307 `Audience:` + fmt.Sprintf("%v", this.Audience) + `,`,
2308 `ExpirationSeconds:` + valueToStringGenerated(this.ExpirationSeconds) + `,`,
2309 `}`,
2310 }, "")
2311 return s
2312 }
2313 func (this *VolumeAttachment) String() string {
2314 if this == nil {
2315 return "nil"
2316 }
2317 s := strings.Join([]string{`&VolumeAttachment{`,
2318 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
2319 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "VolumeAttachmentSpec", "VolumeAttachmentSpec", 1), `&`, ``, 1) + `,`,
2320 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "VolumeAttachmentStatus", "VolumeAttachmentStatus", 1), `&`, ``, 1) + `,`,
2321 `}`,
2322 }, "")
2323 return s
2324 }
2325 func (this *VolumeAttachmentList) String() string {
2326 if this == nil {
2327 return "nil"
2328 }
2329 repeatedStringForItems := "[]VolumeAttachment{"
2330 for _, f := range this.Items {
2331 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "VolumeAttachment", "VolumeAttachment", 1), `&`, ``, 1) + ","
2332 }
2333 repeatedStringForItems += "}"
2334 s := strings.Join([]string{`&VolumeAttachmentList{`,
2335 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
2336 `Items:` + repeatedStringForItems + `,`,
2337 `}`,
2338 }, "")
2339 return s
2340 }
2341 func (this *VolumeAttachmentSource) String() string {
2342 if this == nil {
2343 return "nil"
2344 }
2345 s := strings.Join([]string{`&VolumeAttachmentSource{`,
2346 `PersistentVolumeName:` + valueToStringGenerated(this.PersistentVolumeName) + `,`,
2347 `InlineVolumeSpec:` + strings.Replace(fmt.Sprintf("%v", this.InlineVolumeSpec), "PersistentVolumeSpec", "v11.PersistentVolumeSpec", 1) + `,`,
2348 `}`,
2349 }, "")
2350 return s
2351 }
2352 func (this *VolumeAttachmentSpec) String() string {
2353 if this == nil {
2354 return "nil"
2355 }
2356 s := strings.Join([]string{`&VolumeAttachmentSpec{`,
2357 `Attacher:` + fmt.Sprintf("%v", this.Attacher) + `,`,
2358 `Source:` + strings.Replace(strings.Replace(this.Source.String(), "VolumeAttachmentSource", "VolumeAttachmentSource", 1), `&`, ``, 1) + `,`,
2359 `NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
2360 `}`,
2361 }, "")
2362 return s
2363 }
2364 func (this *VolumeAttachmentStatus) String() string {
2365 if this == nil {
2366 return "nil"
2367 }
2368 keysForAttachmentMetadata := make([]string, 0, len(this.AttachmentMetadata))
2369 for k := range this.AttachmentMetadata {
2370 keysForAttachmentMetadata = append(keysForAttachmentMetadata, k)
2371 }
2372 github_com_gogo_protobuf_sortkeys.Strings(keysForAttachmentMetadata)
2373 mapStringForAttachmentMetadata := "map[string]string{"
2374 for _, k := range keysForAttachmentMetadata {
2375 mapStringForAttachmentMetadata += fmt.Sprintf("%v: %v,", k, this.AttachmentMetadata[k])
2376 }
2377 mapStringForAttachmentMetadata += "}"
2378 s := strings.Join([]string{`&VolumeAttachmentStatus{`,
2379 `Attached:` + fmt.Sprintf("%v", this.Attached) + `,`,
2380 `AttachmentMetadata:` + mapStringForAttachmentMetadata + `,`,
2381 `AttachError:` + strings.Replace(this.AttachError.String(), "VolumeError", "VolumeError", 1) + `,`,
2382 `DetachError:` + strings.Replace(this.DetachError.String(), "VolumeError", "VolumeError", 1) + `,`,
2383 `}`,
2384 }, "")
2385 return s
2386 }
2387 func (this *VolumeError) String() string {
2388 if this == nil {
2389 return "nil"
2390 }
2391 s := strings.Join([]string{`&VolumeError{`,
2392 `Time:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Time), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
2393 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
2394 `}`,
2395 }, "")
2396 return s
2397 }
2398 func (this *VolumeNodeResources) String() string {
2399 if this == nil {
2400 return "nil"
2401 }
2402 s := strings.Join([]string{`&VolumeNodeResources{`,
2403 `Count:` + valueToStringGenerated(this.Count) + `,`,
2404 `}`,
2405 }, "")
2406 return s
2407 }
2408 func valueToStringGenerated(v interface{}) string {
2409 rv := reflect.ValueOf(v)
2410 if rv.IsNil() {
2411 return "nil"
2412 }
2413 pv := reflect.Indirect(rv).Interface()
2414 return fmt.Sprintf("*%v", pv)
2415 }
2416 func (m *CSIDriver) Unmarshal(dAtA []byte) error {
2417 l := len(dAtA)
2418 iNdEx := 0
2419 for iNdEx < l {
2420 preIndex := iNdEx
2421 var wire uint64
2422 for shift := uint(0); ; shift += 7 {
2423 if shift >= 64 {
2424 return ErrIntOverflowGenerated
2425 }
2426 if iNdEx >= l {
2427 return io.ErrUnexpectedEOF
2428 }
2429 b := dAtA[iNdEx]
2430 iNdEx++
2431 wire |= uint64(b&0x7F) << shift
2432 if b < 0x80 {
2433 break
2434 }
2435 }
2436 fieldNum := int32(wire >> 3)
2437 wireType := int(wire & 0x7)
2438 if wireType == 4 {
2439 return fmt.Errorf("proto: CSIDriver: wiretype end group for non-group")
2440 }
2441 if fieldNum <= 0 {
2442 return fmt.Errorf("proto: CSIDriver: illegal tag %d (wire type %d)", fieldNum, wire)
2443 }
2444 switch fieldNum {
2445 case 1:
2446 if wireType != 2 {
2447 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2448 }
2449 var msglen int
2450 for shift := uint(0); ; shift += 7 {
2451 if shift >= 64 {
2452 return ErrIntOverflowGenerated
2453 }
2454 if iNdEx >= l {
2455 return io.ErrUnexpectedEOF
2456 }
2457 b := dAtA[iNdEx]
2458 iNdEx++
2459 msglen |= int(b&0x7F) << shift
2460 if b < 0x80 {
2461 break
2462 }
2463 }
2464 if msglen < 0 {
2465 return ErrInvalidLengthGenerated
2466 }
2467 postIndex := iNdEx + msglen
2468 if postIndex < 0 {
2469 return ErrInvalidLengthGenerated
2470 }
2471 if postIndex > l {
2472 return io.ErrUnexpectedEOF
2473 }
2474 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2475 return err
2476 }
2477 iNdEx = postIndex
2478 case 2:
2479 if wireType != 2 {
2480 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2481 }
2482 var msglen int
2483 for shift := uint(0); ; shift += 7 {
2484 if shift >= 64 {
2485 return ErrIntOverflowGenerated
2486 }
2487 if iNdEx >= l {
2488 return io.ErrUnexpectedEOF
2489 }
2490 b := dAtA[iNdEx]
2491 iNdEx++
2492 msglen |= int(b&0x7F) << shift
2493 if b < 0x80 {
2494 break
2495 }
2496 }
2497 if msglen < 0 {
2498 return ErrInvalidLengthGenerated
2499 }
2500 postIndex := iNdEx + msglen
2501 if postIndex < 0 {
2502 return ErrInvalidLengthGenerated
2503 }
2504 if postIndex > l {
2505 return io.ErrUnexpectedEOF
2506 }
2507 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2508 return err
2509 }
2510 iNdEx = postIndex
2511 default:
2512 iNdEx = preIndex
2513 skippy, err := skipGenerated(dAtA[iNdEx:])
2514 if err != nil {
2515 return err
2516 }
2517 if (skippy < 0) || (iNdEx+skippy) < 0 {
2518 return ErrInvalidLengthGenerated
2519 }
2520 if (iNdEx + skippy) > l {
2521 return io.ErrUnexpectedEOF
2522 }
2523 iNdEx += skippy
2524 }
2525 }
2526
2527 if iNdEx > l {
2528 return io.ErrUnexpectedEOF
2529 }
2530 return nil
2531 }
2532 func (m *CSIDriverList) Unmarshal(dAtA []byte) error {
2533 l := len(dAtA)
2534 iNdEx := 0
2535 for iNdEx < l {
2536 preIndex := iNdEx
2537 var wire uint64
2538 for shift := uint(0); ; shift += 7 {
2539 if shift >= 64 {
2540 return ErrIntOverflowGenerated
2541 }
2542 if iNdEx >= l {
2543 return io.ErrUnexpectedEOF
2544 }
2545 b := dAtA[iNdEx]
2546 iNdEx++
2547 wire |= uint64(b&0x7F) << shift
2548 if b < 0x80 {
2549 break
2550 }
2551 }
2552 fieldNum := int32(wire >> 3)
2553 wireType := int(wire & 0x7)
2554 if wireType == 4 {
2555 return fmt.Errorf("proto: CSIDriverList: wiretype end group for non-group")
2556 }
2557 if fieldNum <= 0 {
2558 return fmt.Errorf("proto: CSIDriverList: illegal tag %d (wire type %d)", fieldNum, wire)
2559 }
2560 switch fieldNum {
2561 case 1:
2562 if wireType != 2 {
2563 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2564 }
2565 var msglen int
2566 for shift := uint(0); ; shift += 7 {
2567 if shift >= 64 {
2568 return ErrIntOverflowGenerated
2569 }
2570 if iNdEx >= l {
2571 return io.ErrUnexpectedEOF
2572 }
2573 b := dAtA[iNdEx]
2574 iNdEx++
2575 msglen |= int(b&0x7F) << shift
2576 if b < 0x80 {
2577 break
2578 }
2579 }
2580 if msglen < 0 {
2581 return ErrInvalidLengthGenerated
2582 }
2583 postIndex := iNdEx + msglen
2584 if postIndex < 0 {
2585 return ErrInvalidLengthGenerated
2586 }
2587 if postIndex > l {
2588 return io.ErrUnexpectedEOF
2589 }
2590 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2591 return err
2592 }
2593 iNdEx = postIndex
2594 case 2:
2595 if wireType != 2 {
2596 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2597 }
2598 var msglen int
2599 for shift := uint(0); ; shift += 7 {
2600 if shift >= 64 {
2601 return ErrIntOverflowGenerated
2602 }
2603 if iNdEx >= l {
2604 return io.ErrUnexpectedEOF
2605 }
2606 b := dAtA[iNdEx]
2607 iNdEx++
2608 msglen |= int(b&0x7F) << shift
2609 if b < 0x80 {
2610 break
2611 }
2612 }
2613 if msglen < 0 {
2614 return ErrInvalidLengthGenerated
2615 }
2616 postIndex := iNdEx + msglen
2617 if postIndex < 0 {
2618 return ErrInvalidLengthGenerated
2619 }
2620 if postIndex > l {
2621 return io.ErrUnexpectedEOF
2622 }
2623 m.Items = append(m.Items, CSIDriver{})
2624 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2625 return err
2626 }
2627 iNdEx = postIndex
2628 default:
2629 iNdEx = preIndex
2630 skippy, err := skipGenerated(dAtA[iNdEx:])
2631 if err != nil {
2632 return err
2633 }
2634 if (skippy < 0) || (iNdEx+skippy) < 0 {
2635 return ErrInvalidLengthGenerated
2636 }
2637 if (iNdEx + skippy) > l {
2638 return io.ErrUnexpectedEOF
2639 }
2640 iNdEx += skippy
2641 }
2642 }
2643
2644 if iNdEx > l {
2645 return io.ErrUnexpectedEOF
2646 }
2647 return nil
2648 }
2649 func (m *CSIDriverSpec) Unmarshal(dAtA []byte) error {
2650 l := len(dAtA)
2651 iNdEx := 0
2652 for iNdEx < l {
2653 preIndex := iNdEx
2654 var wire uint64
2655 for shift := uint(0); ; shift += 7 {
2656 if shift >= 64 {
2657 return ErrIntOverflowGenerated
2658 }
2659 if iNdEx >= l {
2660 return io.ErrUnexpectedEOF
2661 }
2662 b := dAtA[iNdEx]
2663 iNdEx++
2664 wire |= uint64(b&0x7F) << shift
2665 if b < 0x80 {
2666 break
2667 }
2668 }
2669 fieldNum := int32(wire >> 3)
2670 wireType := int(wire & 0x7)
2671 if wireType == 4 {
2672 return fmt.Errorf("proto: CSIDriverSpec: wiretype end group for non-group")
2673 }
2674 if fieldNum <= 0 {
2675 return fmt.Errorf("proto: CSIDriverSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2676 }
2677 switch fieldNum {
2678 case 1:
2679 if wireType != 0 {
2680 return fmt.Errorf("proto: wrong wireType = %d for field AttachRequired", wireType)
2681 }
2682 var v int
2683 for shift := uint(0); ; shift += 7 {
2684 if shift >= 64 {
2685 return ErrIntOverflowGenerated
2686 }
2687 if iNdEx >= l {
2688 return io.ErrUnexpectedEOF
2689 }
2690 b := dAtA[iNdEx]
2691 iNdEx++
2692 v |= int(b&0x7F) << shift
2693 if b < 0x80 {
2694 break
2695 }
2696 }
2697 b := bool(v != 0)
2698 m.AttachRequired = &b
2699 case 2:
2700 if wireType != 0 {
2701 return fmt.Errorf("proto: wrong wireType = %d for field PodInfoOnMount", wireType)
2702 }
2703 var v int
2704 for shift := uint(0); ; shift += 7 {
2705 if shift >= 64 {
2706 return ErrIntOverflowGenerated
2707 }
2708 if iNdEx >= l {
2709 return io.ErrUnexpectedEOF
2710 }
2711 b := dAtA[iNdEx]
2712 iNdEx++
2713 v |= int(b&0x7F) << shift
2714 if b < 0x80 {
2715 break
2716 }
2717 }
2718 b := bool(v != 0)
2719 m.PodInfoOnMount = &b
2720 case 3:
2721 if wireType != 2 {
2722 return fmt.Errorf("proto: wrong wireType = %d for field VolumeLifecycleModes", wireType)
2723 }
2724 var stringLen uint64
2725 for shift := uint(0); ; shift += 7 {
2726 if shift >= 64 {
2727 return ErrIntOverflowGenerated
2728 }
2729 if iNdEx >= l {
2730 return io.ErrUnexpectedEOF
2731 }
2732 b := dAtA[iNdEx]
2733 iNdEx++
2734 stringLen |= uint64(b&0x7F) << shift
2735 if b < 0x80 {
2736 break
2737 }
2738 }
2739 intStringLen := int(stringLen)
2740 if intStringLen < 0 {
2741 return ErrInvalidLengthGenerated
2742 }
2743 postIndex := iNdEx + intStringLen
2744 if postIndex < 0 {
2745 return ErrInvalidLengthGenerated
2746 }
2747 if postIndex > l {
2748 return io.ErrUnexpectedEOF
2749 }
2750 m.VolumeLifecycleModes = append(m.VolumeLifecycleModes, VolumeLifecycleMode(dAtA[iNdEx:postIndex]))
2751 iNdEx = postIndex
2752 case 4:
2753 if wireType != 0 {
2754 return fmt.Errorf("proto: wrong wireType = %d for field StorageCapacity", wireType)
2755 }
2756 var v int
2757 for shift := uint(0); ; shift += 7 {
2758 if shift >= 64 {
2759 return ErrIntOverflowGenerated
2760 }
2761 if iNdEx >= l {
2762 return io.ErrUnexpectedEOF
2763 }
2764 b := dAtA[iNdEx]
2765 iNdEx++
2766 v |= int(b&0x7F) << shift
2767 if b < 0x80 {
2768 break
2769 }
2770 }
2771 b := bool(v != 0)
2772 m.StorageCapacity = &b
2773 case 5:
2774 if wireType != 2 {
2775 return fmt.Errorf("proto: wrong wireType = %d for field FSGroupPolicy", wireType)
2776 }
2777 var stringLen uint64
2778 for shift := uint(0); ; shift += 7 {
2779 if shift >= 64 {
2780 return ErrIntOverflowGenerated
2781 }
2782 if iNdEx >= l {
2783 return io.ErrUnexpectedEOF
2784 }
2785 b := dAtA[iNdEx]
2786 iNdEx++
2787 stringLen |= uint64(b&0x7F) << shift
2788 if b < 0x80 {
2789 break
2790 }
2791 }
2792 intStringLen := int(stringLen)
2793 if intStringLen < 0 {
2794 return ErrInvalidLengthGenerated
2795 }
2796 postIndex := iNdEx + intStringLen
2797 if postIndex < 0 {
2798 return ErrInvalidLengthGenerated
2799 }
2800 if postIndex > l {
2801 return io.ErrUnexpectedEOF
2802 }
2803 s := FSGroupPolicy(dAtA[iNdEx:postIndex])
2804 m.FSGroupPolicy = &s
2805 iNdEx = postIndex
2806 case 6:
2807 if wireType != 2 {
2808 return fmt.Errorf("proto: wrong wireType = %d for field TokenRequests", wireType)
2809 }
2810 var msglen int
2811 for shift := uint(0); ; shift += 7 {
2812 if shift >= 64 {
2813 return ErrIntOverflowGenerated
2814 }
2815 if iNdEx >= l {
2816 return io.ErrUnexpectedEOF
2817 }
2818 b := dAtA[iNdEx]
2819 iNdEx++
2820 msglen |= int(b&0x7F) << shift
2821 if b < 0x80 {
2822 break
2823 }
2824 }
2825 if msglen < 0 {
2826 return ErrInvalidLengthGenerated
2827 }
2828 postIndex := iNdEx + msglen
2829 if postIndex < 0 {
2830 return ErrInvalidLengthGenerated
2831 }
2832 if postIndex > l {
2833 return io.ErrUnexpectedEOF
2834 }
2835 m.TokenRequests = append(m.TokenRequests, TokenRequest{})
2836 if err := m.TokenRequests[len(m.TokenRequests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2837 return err
2838 }
2839 iNdEx = postIndex
2840 case 7:
2841 if wireType != 0 {
2842 return fmt.Errorf("proto: wrong wireType = %d for field RequiresRepublish", wireType)
2843 }
2844 var v int
2845 for shift := uint(0); ; shift += 7 {
2846 if shift >= 64 {
2847 return ErrIntOverflowGenerated
2848 }
2849 if iNdEx >= l {
2850 return io.ErrUnexpectedEOF
2851 }
2852 b := dAtA[iNdEx]
2853 iNdEx++
2854 v |= int(b&0x7F) << shift
2855 if b < 0x80 {
2856 break
2857 }
2858 }
2859 b := bool(v != 0)
2860 m.RequiresRepublish = &b
2861 case 8:
2862 if wireType != 0 {
2863 return fmt.Errorf("proto: wrong wireType = %d for field SELinuxMount", wireType)
2864 }
2865 var v int
2866 for shift := uint(0); ; shift += 7 {
2867 if shift >= 64 {
2868 return ErrIntOverflowGenerated
2869 }
2870 if iNdEx >= l {
2871 return io.ErrUnexpectedEOF
2872 }
2873 b := dAtA[iNdEx]
2874 iNdEx++
2875 v |= int(b&0x7F) << shift
2876 if b < 0x80 {
2877 break
2878 }
2879 }
2880 b := bool(v != 0)
2881 m.SELinuxMount = &b
2882 default:
2883 iNdEx = preIndex
2884 skippy, err := skipGenerated(dAtA[iNdEx:])
2885 if err != nil {
2886 return err
2887 }
2888 if (skippy < 0) || (iNdEx+skippy) < 0 {
2889 return ErrInvalidLengthGenerated
2890 }
2891 if (iNdEx + skippy) > l {
2892 return io.ErrUnexpectedEOF
2893 }
2894 iNdEx += skippy
2895 }
2896 }
2897
2898 if iNdEx > l {
2899 return io.ErrUnexpectedEOF
2900 }
2901 return nil
2902 }
2903 func (m *CSINode) Unmarshal(dAtA []byte) error {
2904 l := len(dAtA)
2905 iNdEx := 0
2906 for iNdEx < l {
2907 preIndex := iNdEx
2908 var wire uint64
2909 for shift := uint(0); ; shift += 7 {
2910 if shift >= 64 {
2911 return ErrIntOverflowGenerated
2912 }
2913 if iNdEx >= l {
2914 return io.ErrUnexpectedEOF
2915 }
2916 b := dAtA[iNdEx]
2917 iNdEx++
2918 wire |= uint64(b&0x7F) << shift
2919 if b < 0x80 {
2920 break
2921 }
2922 }
2923 fieldNum := int32(wire >> 3)
2924 wireType := int(wire & 0x7)
2925 if wireType == 4 {
2926 return fmt.Errorf("proto: CSINode: wiretype end group for non-group")
2927 }
2928 if fieldNum <= 0 {
2929 return fmt.Errorf("proto: CSINode: illegal tag %d (wire type %d)", fieldNum, wire)
2930 }
2931 switch fieldNum {
2932 case 1:
2933 if wireType != 2 {
2934 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2935 }
2936 var msglen int
2937 for shift := uint(0); ; shift += 7 {
2938 if shift >= 64 {
2939 return ErrIntOverflowGenerated
2940 }
2941 if iNdEx >= l {
2942 return io.ErrUnexpectedEOF
2943 }
2944 b := dAtA[iNdEx]
2945 iNdEx++
2946 msglen |= int(b&0x7F) << shift
2947 if b < 0x80 {
2948 break
2949 }
2950 }
2951 if msglen < 0 {
2952 return ErrInvalidLengthGenerated
2953 }
2954 postIndex := iNdEx + msglen
2955 if postIndex < 0 {
2956 return ErrInvalidLengthGenerated
2957 }
2958 if postIndex > l {
2959 return io.ErrUnexpectedEOF
2960 }
2961 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2962 return err
2963 }
2964 iNdEx = postIndex
2965 case 2:
2966 if wireType != 2 {
2967 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2968 }
2969 var msglen int
2970 for shift := uint(0); ; shift += 7 {
2971 if shift >= 64 {
2972 return ErrIntOverflowGenerated
2973 }
2974 if iNdEx >= l {
2975 return io.ErrUnexpectedEOF
2976 }
2977 b := dAtA[iNdEx]
2978 iNdEx++
2979 msglen |= int(b&0x7F) << shift
2980 if b < 0x80 {
2981 break
2982 }
2983 }
2984 if msglen < 0 {
2985 return ErrInvalidLengthGenerated
2986 }
2987 postIndex := iNdEx + msglen
2988 if postIndex < 0 {
2989 return ErrInvalidLengthGenerated
2990 }
2991 if postIndex > l {
2992 return io.ErrUnexpectedEOF
2993 }
2994 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2995 return err
2996 }
2997 iNdEx = postIndex
2998 default:
2999 iNdEx = preIndex
3000 skippy, err := skipGenerated(dAtA[iNdEx:])
3001 if err != nil {
3002 return err
3003 }
3004 if (skippy < 0) || (iNdEx+skippy) < 0 {
3005 return ErrInvalidLengthGenerated
3006 }
3007 if (iNdEx + skippy) > l {
3008 return io.ErrUnexpectedEOF
3009 }
3010 iNdEx += skippy
3011 }
3012 }
3013
3014 if iNdEx > l {
3015 return io.ErrUnexpectedEOF
3016 }
3017 return nil
3018 }
3019 func (m *CSINodeDriver) Unmarshal(dAtA []byte) error {
3020 l := len(dAtA)
3021 iNdEx := 0
3022 for iNdEx < l {
3023 preIndex := iNdEx
3024 var wire uint64
3025 for shift := uint(0); ; shift += 7 {
3026 if shift >= 64 {
3027 return ErrIntOverflowGenerated
3028 }
3029 if iNdEx >= l {
3030 return io.ErrUnexpectedEOF
3031 }
3032 b := dAtA[iNdEx]
3033 iNdEx++
3034 wire |= uint64(b&0x7F) << shift
3035 if b < 0x80 {
3036 break
3037 }
3038 }
3039 fieldNum := int32(wire >> 3)
3040 wireType := int(wire & 0x7)
3041 if wireType == 4 {
3042 return fmt.Errorf("proto: CSINodeDriver: wiretype end group for non-group")
3043 }
3044 if fieldNum <= 0 {
3045 return fmt.Errorf("proto: CSINodeDriver: illegal tag %d (wire type %d)", fieldNum, wire)
3046 }
3047 switch fieldNum {
3048 case 1:
3049 if wireType != 2 {
3050 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
3051 }
3052 var stringLen uint64
3053 for shift := uint(0); ; shift += 7 {
3054 if shift >= 64 {
3055 return ErrIntOverflowGenerated
3056 }
3057 if iNdEx >= l {
3058 return io.ErrUnexpectedEOF
3059 }
3060 b := dAtA[iNdEx]
3061 iNdEx++
3062 stringLen |= uint64(b&0x7F) << shift
3063 if b < 0x80 {
3064 break
3065 }
3066 }
3067 intStringLen := int(stringLen)
3068 if intStringLen < 0 {
3069 return ErrInvalidLengthGenerated
3070 }
3071 postIndex := iNdEx + intStringLen
3072 if postIndex < 0 {
3073 return ErrInvalidLengthGenerated
3074 }
3075 if postIndex > l {
3076 return io.ErrUnexpectedEOF
3077 }
3078 m.Name = string(dAtA[iNdEx:postIndex])
3079 iNdEx = postIndex
3080 case 2:
3081 if wireType != 2 {
3082 return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
3083 }
3084 var stringLen uint64
3085 for shift := uint(0); ; shift += 7 {
3086 if shift >= 64 {
3087 return ErrIntOverflowGenerated
3088 }
3089 if iNdEx >= l {
3090 return io.ErrUnexpectedEOF
3091 }
3092 b := dAtA[iNdEx]
3093 iNdEx++
3094 stringLen |= uint64(b&0x7F) << shift
3095 if b < 0x80 {
3096 break
3097 }
3098 }
3099 intStringLen := int(stringLen)
3100 if intStringLen < 0 {
3101 return ErrInvalidLengthGenerated
3102 }
3103 postIndex := iNdEx + intStringLen
3104 if postIndex < 0 {
3105 return ErrInvalidLengthGenerated
3106 }
3107 if postIndex > l {
3108 return io.ErrUnexpectedEOF
3109 }
3110 m.NodeID = string(dAtA[iNdEx:postIndex])
3111 iNdEx = postIndex
3112 case 3:
3113 if wireType != 2 {
3114 return fmt.Errorf("proto: wrong wireType = %d for field TopologyKeys", wireType)
3115 }
3116 var stringLen uint64
3117 for shift := uint(0); ; shift += 7 {
3118 if shift >= 64 {
3119 return ErrIntOverflowGenerated
3120 }
3121 if iNdEx >= l {
3122 return io.ErrUnexpectedEOF
3123 }
3124 b := dAtA[iNdEx]
3125 iNdEx++
3126 stringLen |= uint64(b&0x7F) << shift
3127 if b < 0x80 {
3128 break
3129 }
3130 }
3131 intStringLen := int(stringLen)
3132 if intStringLen < 0 {
3133 return ErrInvalidLengthGenerated
3134 }
3135 postIndex := iNdEx + intStringLen
3136 if postIndex < 0 {
3137 return ErrInvalidLengthGenerated
3138 }
3139 if postIndex > l {
3140 return io.ErrUnexpectedEOF
3141 }
3142 m.TopologyKeys = append(m.TopologyKeys, string(dAtA[iNdEx:postIndex]))
3143 iNdEx = postIndex
3144 case 4:
3145 if wireType != 2 {
3146 return fmt.Errorf("proto: wrong wireType = %d for field Allocatable", wireType)
3147 }
3148 var msglen int
3149 for shift := uint(0); ; shift += 7 {
3150 if shift >= 64 {
3151 return ErrIntOverflowGenerated
3152 }
3153 if iNdEx >= l {
3154 return io.ErrUnexpectedEOF
3155 }
3156 b := dAtA[iNdEx]
3157 iNdEx++
3158 msglen |= int(b&0x7F) << shift
3159 if b < 0x80 {
3160 break
3161 }
3162 }
3163 if msglen < 0 {
3164 return ErrInvalidLengthGenerated
3165 }
3166 postIndex := iNdEx + msglen
3167 if postIndex < 0 {
3168 return ErrInvalidLengthGenerated
3169 }
3170 if postIndex > l {
3171 return io.ErrUnexpectedEOF
3172 }
3173 if m.Allocatable == nil {
3174 m.Allocatable = &VolumeNodeResources{}
3175 }
3176 if err := m.Allocatable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3177 return err
3178 }
3179 iNdEx = postIndex
3180 default:
3181 iNdEx = preIndex
3182 skippy, err := skipGenerated(dAtA[iNdEx:])
3183 if err != nil {
3184 return err
3185 }
3186 if (skippy < 0) || (iNdEx+skippy) < 0 {
3187 return ErrInvalidLengthGenerated
3188 }
3189 if (iNdEx + skippy) > l {
3190 return io.ErrUnexpectedEOF
3191 }
3192 iNdEx += skippy
3193 }
3194 }
3195
3196 if iNdEx > l {
3197 return io.ErrUnexpectedEOF
3198 }
3199 return nil
3200 }
3201 func (m *CSINodeList) Unmarshal(dAtA []byte) error {
3202 l := len(dAtA)
3203 iNdEx := 0
3204 for iNdEx < l {
3205 preIndex := iNdEx
3206 var wire uint64
3207 for shift := uint(0); ; shift += 7 {
3208 if shift >= 64 {
3209 return ErrIntOverflowGenerated
3210 }
3211 if iNdEx >= l {
3212 return io.ErrUnexpectedEOF
3213 }
3214 b := dAtA[iNdEx]
3215 iNdEx++
3216 wire |= uint64(b&0x7F) << shift
3217 if b < 0x80 {
3218 break
3219 }
3220 }
3221 fieldNum := int32(wire >> 3)
3222 wireType := int(wire & 0x7)
3223 if wireType == 4 {
3224 return fmt.Errorf("proto: CSINodeList: wiretype end group for non-group")
3225 }
3226 if fieldNum <= 0 {
3227 return fmt.Errorf("proto: CSINodeList: illegal tag %d (wire type %d)", fieldNum, wire)
3228 }
3229 switch fieldNum {
3230 case 1:
3231 if wireType != 2 {
3232 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3233 }
3234 var msglen int
3235 for shift := uint(0); ; shift += 7 {
3236 if shift >= 64 {
3237 return ErrIntOverflowGenerated
3238 }
3239 if iNdEx >= l {
3240 return io.ErrUnexpectedEOF
3241 }
3242 b := dAtA[iNdEx]
3243 iNdEx++
3244 msglen |= int(b&0x7F) << shift
3245 if b < 0x80 {
3246 break
3247 }
3248 }
3249 if msglen < 0 {
3250 return ErrInvalidLengthGenerated
3251 }
3252 postIndex := iNdEx + msglen
3253 if postIndex < 0 {
3254 return ErrInvalidLengthGenerated
3255 }
3256 if postIndex > l {
3257 return io.ErrUnexpectedEOF
3258 }
3259 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3260 return err
3261 }
3262 iNdEx = postIndex
3263 case 2:
3264 if wireType != 2 {
3265 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3266 }
3267 var msglen int
3268 for shift := uint(0); ; shift += 7 {
3269 if shift >= 64 {
3270 return ErrIntOverflowGenerated
3271 }
3272 if iNdEx >= l {
3273 return io.ErrUnexpectedEOF
3274 }
3275 b := dAtA[iNdEx]
3276 iNdEx++
3277 msglen |= int(b&0x7F) << shift
3278 if b < 0x80 {
3279 break
3280 }
3281 }
3282 if msglen < 0 {
3283 return ErrInvalidLengthGenerated
3284 }
3285 postIndex := iNdEx + msglen
3286 if postIndex < 0 {
3287 return ErrInvalidLengthGenerated
3288 }
3289 if postIndex > l {
3290 return io.ErrUnexpectedEOF
3291 }
3292 m.Items = append(m.Items, CSINode{})
3293 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3294 return err
3295 }
3296 iNdEx = postIndex
3297 default:
3298 iNdEx = preIndex
3299 skippy, err := skipGenerated(dAtA[iNdEx:])
3300 if err != nil {
3301 return err
3302 }
3303 if (skippy < 0) || (iNdEx+skippy) < 0 {
3304 return ErrInvalidLengthGenerated
3305 }
3306 if (iNdEx + skippy) > l {
3307 return io.ErrUnexpectedEOF
3308 }
3309 iNdEx += skippy
3310 }
3311 }
3312
3313 if iNdEx > l {
3314 return io.ErrUnexpectedEOF
3315 }
3316 return nil
3317 }
3318 func (m *CSINodeSpec) Unmarshal(dAtA []byte) error {
3319 l := len(dAtA)
3320 iNdEx := 0
3321 for iNdEx < l {
3322 preIndex := iNdEx
3323 var wire uint64
3324 for shift := uint(0); ; shift += 7 {
3325 if shift >= 64 {
3326 return ErrIntOverflowGenerated
3327 }
3328 if iNdEx >= l {
3329 return io.ErrUnexpectedEOF
3330 }
3331 b := dAtA[iNdEx]
3332 iNdEx++
3333 wire |= uint64(b&0x7F) << shift
3334 if b < 0x80 {
3335 break
3336 }
3337 }
3338 fieldNum := int32(wire >> 3)
3339 wireType := int(wire & 0x7)
3340 if wireType == 4 {
3341 return fmt.Errorf("proto: CSINodeSpec: wiretype end group for non-group")
3342 }
3343 if fieldNum <= 0 {
3344 return fmt.Errorf("proto: CSINodeSpec: illegal tag %d (wire type %d)", fieldNum, wire)
3345 }
3346 switch fieldNum {
3347 case 1:
3348 if wireType != 2 {
3349 return fmt.Errorf("proto: wrong wireType = %d for field Drivers", wireType)
3350 }
3351 var msglen int
3352 for shift := uint(0); ; shift += 7 {
3353 if shift >= 64 {
3354 return ErrIntOverflowGenerated
3355 }
3356 if iNdEx >= l {
3357 return io.ErrUnexpectedEOF
3358 }
3359 b := dAtA[iNdEx]
3360 iNdEx++
3361 msglen |= int(b&0x7F) << shift
3362 if b < 0x80 {
3363 break
3364 }
3365 }
3366 if msglen < 0 {
3367 return ErrInvalidLengthGenerated
3368 }
3369 postIndex := iNdEx + msglen
3370 if postIndex < 0 {
3371 return ErrInvalidLengthGenerated
3372 }
3373 if postIndex > l {
3374 return io.ErrUnexpectedEOF
3375 }
3376 m.Drivers = append(m.Drivers, CSINodeDriver{})
3377 if err := m.Drivers[len(m.Drivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3378 return err
3379 }
3380 iNdEx = postIndex
3381 default:
3382 iNdEx = preIndex
3383 skippy, err := skipGenerated(dAtA[iNdEx:])
3384 if err != nil {
3385 return err
3386 }
3387 if (skippy < 0) || (iNdEx+skippy) < 0 {
3388 return ErrInvalidLengthGenerated
3389 }
3390 if (iNdEx + skippy) > l {
3391 return io.ErrUnexpectedEOF
3392 }
3393 iNdEx += skippy
3394 }
3395 }
3396
3397 if iNdEx > l {
3398 return io.ErrUnexpectedEOF
3399 }
3400 return nil
3401 }
3402 func (m *CSIStorageCapacity) Unmarshal(dAtA []byte) error {
3403 l := len(dAtA)
3404 iNdEx := 0
3405 for iNdEx < l {
3406 preIndex := iNdEx
3407 var wire uint64
3408 for shift := uint(0); ; shift += 7 {
3409 if shift >= 64 {
3410 return ErrIntOverflowGenerated
3411 }
3412 if iNdEx >= l {
3413 return io.ErrUnexpectedEOF
3414 }
3415 b := dAtA[iNdEx]
3416 iNdEx++
3417 wire |= uint64(b&0x7F) << shift
3418 if b < 0x80 {
3419 break
3420 }
3421 }
3422 fieldNum := int32(wire >> 3)
3423 wireType := int(wire & 0x7)
3424 if wireType == 4 {
3425 return fmt.Errorf("proto: CSIStorageCapacity: wiretype end group for non-group")
3426 }
3427 if fieldNum <= 0 {
3428 return fmt.Errorf("proto: CSIStorageCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
3429 }
3430 switch fieldNum {
3431 case 1:
3432 if wireType != 2 {
3433 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3434 }
3435 var msglen int
3436 for shift := uint(0); ; shift += 7 {
3437 if shift >= 64 {
3438 return ErrIntOverflowGenerated
3439 }
3440 if iNdEx >= l {
3441 return io.ErrUnexpectedEOF
3442 }
3443 b := dAtA[iNdEx]
3444 iNdEx++
3445 msglen |= int(b&0x7F) << shift
3446 if b < 0x80 {
3447 break
3448 }
3449 }
3450 if msglen < 0 {
3451 return ErrInvalidLengthGenerated
3452 }
3453 postIndex := iNdEx + msglen
3454 if postIndex < 0 {
3455 return ErrInvalidLengthGenerated
3456 }
3457 if postIndex > l {
3458 return io.ErrUnexpectedEOF
3459 }
3460 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3461 return err
3462 }
3463 iNdEx = postIndex
3464 case 2:
3465 if wireType != 2 {
3466 return fmt.Errorf("proto: wrong wireType = %d for field NodeTopology", wireType)
3467 }
3468 var msglen int
3469 for shift := uint(0); ; shift += 7 {
3470 if shift >= 64 {
3471 return ErrIntOverflowGenerated
3472 }
3473 if iNdEx >= l {
3474 return io.ErrUnexpectedEOF
3475 }
3476 b := dAtA[iNdEx]
3477 iNdEx++
3478 msglen |= int(b&0x7F) << shift
3479 if b < 0x80 {
3480 break
3481 }
3482 }
3483 if msglen < 0 {
3484 return ErrInvalidLengthGenerated
3485 }
3486 postIndex := iNdEx + msglen
3487 if postIndex < 0 {
3488 return ErrInvalidLengthGenerated
3489 }
3490 if postIndex > l {
3491 return io.ErrUnexpectedEOF
3492 }
3493 if m.NodeTopology == nil {
3494 m.NodeTopology = &v1.LabelSelector{}
3495 }
3496 if err := m.NodeTopology.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3497 return err
3498 }
3499 iNdEx = postIndex
3500 case 3:
3501 if wireType != 2 {
3502 return fmt.Errorf("proto: wrong wireType = %d for field StorageClassName", wireType)
3503 }
3504 var stringLen uint64
3505 for shift := uint(0); ; shift += 7 {
3506 if shift >= 64 {
3507 return ErrIntOverflowGenerated
3508 }
3509 if iNdEx >= l {
3510 return io.ErrUnexpectedEOF
3511 }
3512 b := dAtA[iNdEx]
3513 iNdEx++
3514 stringLen |= uint64(b&0x7F) << shift
3515 if b < 0x80 {
3516 break
3517 }
3518 }
3519 intStringLen := int(stringLen)
3520 if intStringLen < 0 {
3521 return ErrInvalidLengthGenerated
3522 }
3523 postIndex := iNdEx + intStringLen
3524 if postIndex < 0 {
3525 return ErrInvalidLengthGenerated
3526 }
3527 if postIndex > l {
3528 return io.ErrUnexpectedEOF
3529 }
3530 m.StorageClassName = string(dAtA[iNdEx:postIndex])
3531 iNdEx = postIndex
3532 case 4:
3533 if wireType != 2 {
3534 return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
3535 }
3536 var msglen int
3537 for shift := uint(0); ; shift += 7 {
3538 if shift >= 64 {
3539 return ErrIntOverflowGenerated
3540 }
3541 if iNdEx >= l {
3542 return io.ErrUnexpectedEOF
3543 }
3544 b := dAtA[iNdEx]
3545 iNdEx++
3546 msglen |= int(b&0x7F) << shift
3547 if b < 0x80 {
3548 break
3549 }
3550 }
3551 if msglen < 0 {
3552 return ErrInvalidLengthGenerated
3553 }
3554 postIndex := iNdEx + msglen
3555 if postIndex < 0 {
3556 return ErrInvalidLengthGenerated
3557 }
3558 if postIndex > l {
3559 return io.ErrUnexpectedEOF
3560 }
3561 if m.Capacity == nil {
3562 m.Capacity = &resource.Quantity{}
3563 }
3564 if err := m.Capacity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3565 return err
3566 }
3567 iNdEx = postIndex
3568 case 5:
3569 if wireType != 2 {
3570 return fmt.Errorf("proto: wrong wireType = %d for field MaximumVolumeSize", wireType)
3571 }
3572 var msglen int
3573 for shift := uint(0); ; shift += 7 {
3574 if shift >= 64 {
3575 return ErrIntOverflowGenerated
3576 }
3577 if iNdEx >= l {
3578 return io.ErrUnexpectedEOF
3579 }
3580 b := dAtA[iNdEx]
3581 iNdEx++
3582 msglen |= int(b&0x7F) << shift
3583 if b < 0x80 {
3584 break
3585 }
3586 }
3587 if msglen < 0 {
3588 return ErrInvalidLengthGenerated
3589 }
3590 postIndex := iNdEx + msglen
3591 if postIndex < 0 {
3592 return ErrInvalidLengthGenerated
3593 }
3594 if postIndex > l {
3595 return io.ErrUnexpectedEOF
3596 }
3597 if m.MaximumVolumeSize == nil {
3598 m.MaximumVolumeSize = &resource.Quantity{}
3599 }
3600 if err := m.MaximumVolumeSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3601 return err
3602 }
3603 iNdEx = postIndex
3604 default:
3605 iNdEx = preIndex
3606 skippy, err := skipGenerated(dAtA[iNdEx:])
3607 if err != nil {
3608 return err
3609 }
3610 if (skippy < 0) || (iNdEx+skippy) < 0 {
3611 return ErrInvalidLengthGenerated
3612 }
3613 if (iNdEx + skippy) > l {
3614 return io.ErrUnexpectedEOF
3615 }
3616 iNdEx += skippy
3617 }
3618 }
3619
3620 if iNdEx > l {
3621 return io.ErrUnexpectedEOF
3622 }
3623 return nil
3624 }
3625 func (m *CSIStorageCapacityList) Unmarshal(dAtA []byte) error {
3626 l := len(dAtA)
3627 iNdEx := 0
3628 for iNdEx < l {
3629 preIndex := iNdEx
3630 var wire uint64
3631 for shift := uint(0); ; shift += 7 {
3632 if shift >= 64 {
3633 return ErrIntOverflowGenerated
3634 }
3635 if iNdEx >= l {
3636 return io.ErrUnexpectedEOF
3637 }
3638 b := dAtA[iNdEx]
3639 iNdEx++
3640 wire |= uint64(b&0x7F) << shift
3641 if b < 0x80 {
3642 break
3643 }
3644 }
3645 fieldNum := int32(wire >> 3)
3646 wireType := int(wire & 0x7)
3647 if wireType == 4 {
3648 return fmt.Errorf("proto: CSIStorageCapacityList: wiretype end group for non-group")
3649 }
3650 if fieldNum <= 0 {
3651 return fmt.Errorf("proto: CSIStorageCapacityList: illegal tag %d (wire type %d)", fieldNum, wire)
3652 }
3653 switch fieldNum {
3654 case 1:
3655 if wireType != 2 {
3656 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
3657 }
3658 var msglen int
3659 for shift := uint(0); ; shift += 7 {
3660 if shift >= 64 {
3661 return ErrIntOverflowGenerated
3662 }
3663 if iNdEx >= l {
3664 return io.ErrUnexpectedEOF
3665 }
3666 b := dAtA[iNdEx]
3667 iNdEx++
3668 msglen |= int(b&0x7F) << shift
3669 if b < 0x80 {
3670 break
3671 }
3672 }
3673 if msglen < 0 {
3674 return ErrInvalidLengthGenerated
3675 }
3676 postIndex := iNdEx + msglen
3677 if postIndex < 0 {
3678 return ErrInvalidLengthGenerated
3679 }
3680 if postIndex > l {
3681 return io.ErrUnexpectedEOF
3682 }
3683 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3684 return err
3685 }
3686 iNdEx = postIndex
3687 case 2:
3688 if wireType != 2 {
3689 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
3690 }
3691 var msglen int
3692 for shift := uint(0); ; shift += 7 {
3693 if shift >= 64 {
3694 return ErrIntOverflowGenerated
3695 }
3696 if iNdEx >= l {
3697 return io.ErrUnexpectedEOF
3698 }
3699 b := dAtA[iNdEx]
3700 iNdEx++
3701 msglen |= int(b&0x7F) << shift
3702 if b < 0x80 {
3703 break
3704 }
3705 }
3706 if msglen < 0 {
3707 return ErrInvalidLengthGenerated
3708 }
3709 postIndex := iNdEx + msglen
3710 if postIndex < 0 {
3711 return ErrInvalidLengthGenerated
3712 }
3713 if postIndex > l {
3714 return io.ErrUnexpectedEOF
3715 }
3716 m.Items = append(m.Items, CSIStorageCapacity{})
3717 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3718 return err
3719 }
3720 iNdEx = postIndex
3721 default:
3722 iNdEx = preIndex
3723 skippy, err := skipGenerated(dAtA[iNdEx:])
3724 if err != nil {
3725 return err
3726 }
3727 if (skippy < 0) || (iNdEx+skippy) < 0 {
3728 return ErrInvalidLengthGenerated
3729 }
3730 if (iNdEx + skippy) > l {
3731 return io.ErrUnexpectedEOF
3732 }
3733 iNdEx += skippy
3734 }
3735 }
3736
3737 if iNdEx > l {
3738 return io.ErrUnexpectedEOF
3739 }
3740 return nil
3741 }
3742 func (m *StorageClass) Unmarshal(dAtA []byte) error {
3743 l := len(dAtA)
3744 iNdEx := 0
3745 for iNdEx < l {
3746 preIndex := iNdEx
3747 var wire uint64
3748 for shift := uint(0); ; shift += 7 {
3749 if shift >= 64 {
3750 return ErrIntOverflowGenerated
3751 }
3752 if iNdEx >= l {
3753 return io.ErrUnexpectedEOF
3754 }
3755 b := dAtA[iNdEx]
3756 iNdEx++
3757 wire |= uint64(b&0x7F) << shift
3758 if b < 0x80 {
3759 break
3760 }
3761 }
3762 fieldNum := int32(wire >> 3)
3763 wireType := int(wire & 0x7)
3764 if wireType == 4 {
3765 return fmt.Errorf("proto: StorageClass: wiretype end group for non-group")
3766 }
3767 if fieldNum <= 0 {
3768 return fmt.Errorf("proto: StorageClass: illegal tag %d (wire type %d)", fieldNum, wire)
3769 }
3770 switch fieldNum {
3771 case 1:
3772 if wireType != 2 {
3773 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
3774 }
3775 var msglen int
3776 for shift := uint(0); ; shift += 7 {
3777 if shift >= 64 {
3778 return ErrIntOverflowGenerated
3779 }
3780 if iNdEx >= l {
3781 return io.ErrUnexpectedEOF
3782 }
3783 b := dAtA[iNdEx]
3784 iNdEx++
3785 msglen |= int(b&0x7F) << shift
3786 if b < 0x80 {
3787 break
3788 }
3789 }
3790 if msglen < 0 {
3791 return ErrInvalidLengthGenerated
3792 }
3793 postIndex := iNdEx + msglen
3794 if postIndex < 0 {
3795 return ErrInvalidLengthGenerated
3796 }
3797 if postIndex > l {
3798 return io.ErrUnexpectedEOF
3799 }
3800 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3801 return err
3802 }
3803 iNdEx = postIndex
3804 case 2:
3805 if wireType != 2 {
3806 return fmt.Errorf("proto: wrong wireType = %d for field Provisioner", wireType)
3807 }
3808 var stringLen uint64
3809 for shift := uint(0); ; shift += 7 {
3810 if shift >= 64 {
3811 return ErrIntOverflowGenerated
3812 }
3813 if iNdEx >= l {
3814 return io.ErrUnexpectedEOF
3815 }
3816 b := dAtA[iNdEx]
3817 iNdEx++
3818 stringLen |= uint64(b&0x7F) << shift
3819 if b < 0x80 {
3820 break
3821 }
3822 }
3823 intStringLen := int(stringLen)
3824 if intStringLen < 0 {
3825 return ErrInvalidLengthGenerated
3826 }
3827 postIndex := iNdEx + intStringLen
3828 if postIndex < 0 {
3829 return ErrInvalidLengthGenerated
3830 }
3831 if postIndex > l {
3832 return io.ErrUnexpectedEOF
3833 }
3834 m.Provisioner = string(dAtA[iNdEx:postIndex])
3835 iNdEx = postIndex
3836 case 3:
3837 if wireType != 2 {
3838 return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
3839 }
3840 var msglen int
3841 for shift := uint(0); ; shift += 7 {
3842 if shift >= 64 {
3843 return ErrIntOverflowGenerated
3844 }
3845 if iNdEx >= l {
3846 return io.ErrUnexpectedEOF
3847 }
3848 b := dAtA[iNdEx]
3849 iNdEx++
3850 msglen |= int(b&0x7F) << shift
3851 if b < 0x80 {
3852 break
3853 }
3854 }
3855 if msglen < 0 {
3856 return ErrInvalidLengthGenerated
3857 }
3858 postIndex := iNdEx + msglen
3859 if postIndex < 0 {
3860 return ErrInvalidLengthGenerated
3861 }
3862 if postIndex > l {
3863 return io.ErrUnexpectedEOF
3864 }
3865 if m.Parameters == nil {
3866 m.Parameters = make(map[string]string)
3867 }
3868 var mapkey string
3869 var mapvalue string
3870 for iNdEx < postIndex {
3871 entryPreIndex := iNdEx
3872 var wire uint64
3873 for shift := uint(0); ; shift += 7 {
3874 if shift >= 64 {
3875 return ErrIntOverflowGenerated
3876 }
3877 if iNdEx >= l {
3878 return io.ErrUnexpectedEOF
3879 }
3880 b := dAtA[iNdEx]
3881 iNdEx++
3882 wire |= uint64(b&0x7F) << shift
3883 if b < 0x80 {
3884 break
3885 }
3886 }
3887 fieldNum := int32(wire >> 3)
3888 if fieldNum == 1 {
3889 var stringLenmapkey uint64
3890 for shift := uint(0); ; shift += 7 {
3891 if shift >= 64 {
3892 return ErrIntOverflowGenerated
3893 }
3894 if iNdEx >= l {
3895 return io.ErrUnexpectedEOF
3896 }
3897 b := dAtA[iNdEx]
3898 iNdEx++
3899 stringLenmapkey |= uint64(b&0x7F) << shift
3900 if b < 0x80 {
3901 break
3902 }
3903 }
3904 intStringLenmapkey := int(stringLenmapkey)
3905 if intStringLenmapkey < 0 {
3906 return ErrInvalidLengthGenerated
3907 }
3908 postStringIndexmapkey := iNdEx + intStringLenmapkey
3909 if postStringIndexmapkey < 0 {
3910 return ErrInvalidLengthGenerated
3911 }
3912 if postStringIndexmapkey > l {
3913 return io.ErrUnexpectedEOF
3914 }
3915 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
3916 iNdEx = postStringIndexmapkey
3917 } else if fieldNum == 2 {
3918 var stringLenmapvalue uint64
3919 for shift := uint(0); ; shift += 7 {
3920 if shift >= 64 {
3921 return ErrIntOverflowGenerated
3922 }
3923 if iNdEx >= l {
3924 return io.ErrUnexpectedEOF
3925 }
3926 b := dAtA[iNdEx]
3927 iNdEx++
3928 stringLenmapvalue |= uint64(b&0x7F) << shift
3929 if b < 0x80 {
3930 break
3931 }
3932 }
3933 intStringLenmapvalue := int(stringLenmapvalue)
3934 if intStringLenmapvalue < 0 {
3935 return ErrInvalidLengthGenerated
3936 }
3937 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
3938 if postStringIndexmapvalue < 0 {
3939 return ErrInvalidLengthGenerated
3940 }
3941 if postStringIndexmapvalue > l {
3942 return io.ErrUnexpectedEOF
3943 }
3944 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
3945 iNdEx = postStringIndexmapvalue
3946 } else {
3947 iNdEx = entryPreIndex
3948 skippy, err := skipGenerated(dAtA[iNdEx:])
3949 if err != nil {
3950 return err
3951 }
3952 if (skippy < 0) || (iNdEx+skippy) < 0 {
3953 return ErrInvalidLengthGenerated
3954 }
3955 if (iNdEx + skippy) > postIndex {
3956 return io.ErrUnexpectedEOF
3957 }
3958 iNdEx += skippy
3959 }
3960 }
3961 m.Parameters[mapkey] = mapvalue
3962 iNdEx = postIndex
3963 case 4:
3964 if wireType != 2 {
3965 return fmt.Errorf("proto: wrong wireType = %d for field ReclaimPolicy", wireType)
3966 }
3967 var stringLen uint64
3968 for shift := uint(0); ; shift += 7 {
3969 if shift >= 64 {
3970 return ErrIntOverflowGenerated
3971 }
3972 if iNdEx >= l {
3973 return io.ErrUnexpectedEOF
3974 }
3975 b := dAtA[iNdEx]
3976 iNdEx++
3977 stringLen |= uint64(b&0x7F) << shift
3978 if b < 0x80 {
3979 break
3980 }
3981 }
3982 intStringLen := int(stringLen)
3983 if intStringLen < 0 {
3984 return ErrInvalidLengthGenerated
3985 }
3986 postIndex := iNdEx + intStringLen
3987 if postIndex < 0 {
3988 return ErrInvalidLengthGenerated
3989 }
3990 if postIndex > l {
3991 return io.ErrUnexpectedEOF
3992 }
3993 s := k8s_io_api_core_v1.PersistentVolumeReclaimPolicy(dAtA[iNdEx:postIndex])
3994 m.ReclaimPolicy = &s
3995 iNdEx = postIndex
3996 case 5:
3997 if wireType != 2 {
3998 return fmt.Errorf("proto: wrong wireType = %d for field MountOptions", wireType)
3999 }
4000 var stringLen uint64
4001 for shift := uint(0); ; shift += 7 {
4002 if shift >= 64 {
4003 return ErrIntOverflowGenerated
4004 }
4005 if iNdEx >= l {
4006 return io.ErrUnexpectedEOF
4007 }
4008 b := dAtA[iNdEx]
4009 iNdEx++
4010 stringLen |= uint64(b&0x7F) << shift
4011 if b < 0x80 {
4012 break
4013 }
4014 }
4015 intStringLen := int(stringLen)
4016 if intStringLen < 0 {
4017 return ErrInvalidLengthGenerated
4018 }
4019 postIndex := iNdEx + intStringLen
4020 if postIndex < 0 {
4021 return ErrInvalidLengthGenerated
4022 }
4023 if postIndex > l {
4024 return io.ErrUnexpectedEOF
4025 }
4026 m.MountOptions = append(m.MountOptions, string(dAtA[iNdEx:postIndex]))
4027 iNdEx = postIndex
4028 case 6:
4029 if wireType != 0 {
4030 return fmt.Errorf("proto: wrong wireType = %d for field AllowVolumeExpansion", wireType)
4031 }
4032 var v int
4033 for shift := uint(0); ; shift += 7 {
4034 if shift >= 64 {
4035 return ErrIntOverflowGenerated
4036 }
4037 if iNdEx >= l {
4038 return io.ErrUnexpectedEOF
4039 }
4040 b := dAtA[iNdEx]
4041 iNdEx++
4042 v |= int(b&0x7F) << shift
4043 if b < 0x80 {
4044 break
4045 }
4046 }
4047 b := bool(v != 0)
4048 m.AllowVolumeExpansion = &b
4049 case 7:
4050 if wireType != 2 {
4051 return fmt.Errorf("proto: wrong wireType = %d for field VolumeBindingMode", wireType)
4052 }
4053 var stringLen uint64
4054 for shift := uint(0); ; shift += 7 {
4055 if shift >= 64 {
4056 return ErrIntOverflowGenerated
4057 }
4058 if iNdEx >= l {
4059 return io.ErrUnexpectedEOF
4060 }
4061 b := dAtA[iNdEx]
4062 iNdEx++
4063 stringLen |= uint64(b&0x7F) << shift
4064 if b < 0x80 {
4065 break
4066 }
4067 }
4068 intStringLen := int(stringLen)
4069 if intStringLen < 0 {
4070 return ErrInvalidLengthGenerated
4071 }
4072 postIndex := iNdEx + intStringLen
4073 if postIndex < 0 {
4074 return ErrInvalidLengthGenerated
4075 }
4076 if postIndex > l {
4077 return io.ErrUnexpectedEOF
4078 }
4079 s := VolumeBindingMode(dAtA[iNdEx:postIndex])
4080 m.VolumeBindingMode = &s
4081 iNdEx = postIndex
4082 case 8:
4083 if wireType != 2 {
4084 return fmt.Errorf("proto: wrong wireType = %d for field AllowedTopologies", wireType)
4085 }
4086 var msglen int
4087 for shift := uint(0); ; shift += 7 {
4088 if shift >= 64 {
4089 return ErrIntOverflowGenerated
4090 }
4091 if iNdEx >= l {
4092 return io.ErrUnexpectedEOF
4093 }
4094 b := dAtA[iNdEx]
4095 iNdEx++
4096 msglen |= int(b&0x7F) << shift
4097 if b < 0x80 {
4098 break
4099 }
4100 }
4101 if msglen < 0 {
4102 return ErrInvalidLengthGenerated
4103 }
4104 postIndex := iNdEx + msglen
4105 if postIndex < 0 {
4106 return ErrInvalidLengthGenerated
4107 }
4108 if postIndex > l {
4109 return io.ErrUnexpectedEOF
4110 }
4111 m.AllowedTopologies = append(m.AllowedTopologies, v11.TopologySelectorTerm{})
4112 if err := m.AllowedTopologies[len(m.AllowedTopologies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4113 return err
4114 }
4115 iNdEx = postIndex
4116 default:
4117 iNdEx = preIndex
4118 skippy, err := skipGenerated(dAtA[iNdEx:])
4119 if err != nil {
4120 return err
4121 }
4122 if (skippy < 0) || (iNdEx+skippy) < 0 {
4123 return ErrInvalidLengthGenerated
4124 }
4125 if (iNdEx + skippy) > l {
4126 return io.ErrUnexpectedEOF
4127 }
4128 iNdEx += skippy
4129 }
4130 }
4131
4132 if iNdEx > l {
4133 return io.ErrUnexpectedEOF
4134 }
4135 return nil
4136 }
4137 func (m *StorageClassList) Unmarshal(dAtA []byte) error {
4138 l := len(dAtA)
4139 iNdEx := 0
4140 for iNdEx < l {
4141 preIndex := iNdEx
4142 var wire uint64
4143 for shift := uint(0); ; shift += 7 {
4144 if shift >= 64 {
4145 return ErrIntOverflowGenerated
4146 }
4147 if iNdEx >= l {
4148 return io.ErrUnexpectedEOF
4149 }
4150 b := dAtA[iNdEx]
4151 iNdEx++
4152 wire |= uint64(b&0x7F) << shift
4153 if b < 0x80 {
4154 break
4155 }
4156 }
4157 fieldNum := int32(wire >> 3)
4158 wireType := int(wire & 0x7)
4159 if wireType == 4 {
4160 return fmt.Errorf("proto: StorageClassList: wiretype end group for non-group")
4161 }
4162 if fieldNum <= 0 {
4163 return fmt.Errorf("proto: StorageClassList: illegal tag %d (wire type %d)", fieldNum, wire)
4164 }
4165 switch fieldNum {
4166 case 1:
4167 if wireType != 2 {
4168 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4169 }
4170 var msglen int
4171 for shift := uint(0); ; shift += 7 {
4172 if shift >= 64 {
4173 return ErrIntOverflowGenerated
4174 }
4175 if iNdEx >= l {
4176 return io.ErrUnexpectedEOF
4177 }
4178 b := dAtA[iNdEx]
4179 iNdEx++
4180 msglen |= int(b&0x7F) << shift
4181 if b < 0x80 {
4182 break
4183 }
4184 }
4185 if msglen < 0 {
4186 return ErrInvalidLengthGenerated
4187 }
4188 postIndex := iNdEx + msglen
4189 if postIndex < 0 {
4190 return ErrInvalidLengthGenerated
4191 }
4192 if postIndex > l {
4193 return io.ErrUnexpectedEOF
4194 }
4195 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4196 return err
4197 }
4198 iNdEx = postIndex
4199 case 2:
4200 if wireType != 2 {
4201 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4202 }
4203 var msglen int
4204 for shift := uint(0); ; shift += 7 {
4205 if shift >= 64 {
4206 return ErrIntOverflowGenerated
4207 }
4208 if iNdEx >= l {
4209 return io.ErrUnexpectedEOF
4210 }
4211 b := dAtA[iNdEx]
4212 iNdEx++
4213 msglen |= int(b&0x7F) << shift
4214 if b < 0x80 {
4215 break
4216 }
4217 }
4218 if msglen < 0 {
4219 return ErrInvalidLengthGenerated
4220 }
4221 postIndex := iNdEx + msglen
4222 if postIndex < 0 {
4223 return ErrInvalidLengthGenerated
4224 }
4225 if postIndex > l {
4226 return io.ErrUnexpectedEOF
4227 }
4228 m.Items = append(m.Items, StorageClass{})
4229 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4230 return err
4231 }
4232 iNdEx = postIndex
4233 default:
4234 iNdEx = preIndex
4235 skippy, err := skipGenerated(dAtA[iNdEx:])
4236 if err != nil {
4237 return err
4238 }
4239 if (skippy < 0) || (iNdEx+skippy) < 0 {
4240 return ErrInvalidLengthGenerated
4241 }
4242 if (iNdEx + skippy) > l {
4243 return io.ErrUnexpectedEOF
4244 }
4245 iNdEx += skippy
4246 }
4247 }
4248
4249 if iNdEx > l {
4250 return io.ErrUnexpectedEOF
4251 }
4252 return nil
4253 }
4254 func (m *TokenRequest) Unmarshal(dAtA []byte) error {
4255 l := len(dAtA)
4256 iNdEx := 0
4257 for iNdEx < l {
4258 preIndex := iNdEx
4259 var wire uint64
4260 for shift := uint(0); ; shift += 7 {
4261 if shift >= 64 {
4262 return ErrIntOverflowGenerated
4263 }
4264 if iNdEx >= l {
4265 return io.ErrUnexpectedEOF
4266 }
4267 b := dAtA[iNdEx]
4268 iNdEx++
4269 wire |= uint64(b&0x7F) << shift
4270 if b < 0x80 {
4271 break
4272 }
4273 }
4274 fieldNum := int32(wire >> 3)
4275 wireType := int(wire & 0x7)
4276 if wireType == 4 {
4277 return fmt.Errorf("proto: TokenRequest: wiretype end group for non-group")
4278 }
4279 if fieldNum <= 0 {
4280 return fmt.Errorf("proto: TokenRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4281 }
4282 switch fieldNum {
4283 case 1:
4284 if wireType != 2 {
4285 return fmt.Errorf("proto: wrong wireType = %d for field Audience", wireType)
4286 }
4287 var stringLen uint64
4288 for shift := uint(0); ; shift += 7 {
4289 if shift >= 64 {
4290 return ErrIntOverflowGenerated
4291 }
4292 if iNdEx >= l {
4293 return io.ErrUnexpectedEOF
4294 }
4295 b := dAtA[iNdEx]
4296 iNdEx++
4297 stringLen |= uint64(b&0x7F) << shift
4298 if b < 0x80 {
4299 break
4300 }
4301 }
4302 intStringLen := int(stringLen)
4303 if intStringLen < 0 {
4304 return ErrInvalidLengthGenerated
4305 }
4306 postIndex := iNdEx + intStringLen
4307 if postIndex < 0 {
4308 return ErrInvalidLengthGenerated
4309 }
4310 if postIndex > l {
4311 return io.ErrUnexpectedEOF
4312 }
4313 m.Audience = string(dAtA[iNdEx:postIndex])
4314 iNdEx = postIndex
4315 case 2:
4316 if wireType != 0 {
4317 return fmt.Errorf("proto: wrong wireType = %d for field ExpirationSeconds", wireType)
4318 }
4319 var v int64
4320 for shift := uint(0); ; shift += 7 {
4321 if shift >= 64 {
4322 return ErrIntOverflowGenerated
4323 }
4324 if iNdEx >= l {
4325 return io.ErrUnexpectedEOF
4326 }
4327 b := dAtA[iNdEx]
4328 iNdEx++
4329 v |= int64(b&0x7F) << shift
4330 if b < 0x80 {
4331 break
4332 }
4333 }
4334 m.ExpirationSeconds = &v
4335 default:
4336 iNdEx = preIndex
4337 skippy, err := skipGenerated(dAtA[iNdEx:])
4338 if err != nil {
4339 return err
4340 }
4341 if (skippy < 0) || (iNdEx+skippy) < 0 {
4342 return ErrInvalidLengthGenerated
4343 }
4344 if (iNdEx + skippy) > l {
4345 return io.ErrUnexpectedEOF
4346 }
4347 iNdEx += skippy
4348 }
4349 }
4350
4351 if iNdEx > l {
4352 return io.ErrUnexpectedEOF
4353 }
4354 return nil
4355 }
4356 func (m *VolumeAttachment) Unmarshal(dAtA []byte) error {
4357 l := len(dAtA)
4358 iNdEx := 0
4359 for iNdEx < l {
4360 preIndex := iNdEx
4361 var wire uint64
4362 for shift := uint(0); ; shift += 7 {
4363 if shift >= 64 {
4364 return ErrIntOverflowGenerated
4365 }
4366 if iNdEx >= l {
4367 return io.ErrUnexpectedEOF
4368 }
4369 b := dAtA[iNdEx]
4370 iNdEx++
4371 wire |= uint64(b&0x7F) << shift
4372 if b < 0x80 {
4373 break
4374 }
4375 }
4376 fieldNum := int32(wire >> 3)
4377 wireType := int(wire & 0x7)
4378 if wireType == 4 {
4379 return fmt.Errorf("proto: VolumeAttachment: wiretype end group for non-group")
4380 }
4381 if fieldNum <= 0 {
4382 return fmt.Errorf("proto: VolumeAttachment: illegal tag %d (wire type %d)", fieldNum, wire)
4383 }
4384 switch fieldNum {
4385 case 1:
4386 if wireType != 2 {
4387 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4388 }
4389 var msglen int
4390 for shift := uint(0); ; shift += 7 {
4391 if shift >= 64 {
4392 return ErrIntOverflowGenerated
4393 }
4394 if iNdEx >= l {
4395 return io.ErrUnexpectedEOF
4396 }
4397 b := dAtA[iNdEx]
4398 iNdEx++
4399 msglen |= int(b&0x7F) << shift
4400 if b < 0x80 {
4401 break
4402 }
4403 }
4404 if msglen < 0 {
4405 return ErrInvalidLengthGenerated
4406 }
4407 postIndex := iNdEx + msglen
4408 if postIndex < 0 {
4409 return ErrInvalidLengthGenerated
4410 }
4411 if postIndex > l {
4412 return io.ErrUnexpectedEOF
4413 }
4414 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4415 return err
4416 }
4417 iNdEx = postIndex
4418 case 2:
4419 if wireType != 2 {
4420 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4421 }
4422 var msglen int
4423 for shift := uint(0); ; shift += 7 {
4424 if shift >= 64 {
4425 return ErrIntOverflowGenerated
4426 }
4427 if iNdEx >= l {
4428 return io.ErrUnexpectedEOF
4429 }
4430 b := dAtA[iNdEx]
4431 iNdEx++
4432 msglen |= int(b&0x7F) << shift
4433 if b < 0x80 {
4434 break
4435 }
4436 }
4437 if msglen < 0 {
4438 return ErrInvalidLengthGenerated
4439 }
4440 postIndex := iNdEx + msglen
4441 if postIndex < 0 {
4442 return ErrInvalidLengthGenerated
4443 }
4444 if postIndex > l {
4445 return io.ErrUnexpectedEOF
4446 }
4447 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4448 return err
4449 }
4450 iNdEx = postIndex
4451 case 3:
4452 if wireType != 2 {
4453 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4454 }
4455 var msglen int
4456 for shift := uint(0); ; shift += 7 {
4457 if shift >= 64 {
4458 return ErrIntOverflowGenerated
4459 }
4460 if iNdEx >= l {
4461 return io.ErrUnexpectedEOF
4462 }
4463 b := dAtA[iNdEx]
4464 iNdEx++
4465 msglen |= int(b&0x7F) << shift
4466 if b < 0x80 {
4467 break
4468 }
4469 }
4470 if msglen < 0 {
4471 return ErrInvalidLengthGenerated
4472 }
4473 postIndex := iNdEx + msglen
4474 if postIndex < 0 {
4475 return ErrInvalidLengthGenerated
4476 }
4477 if postIndex > l {
4478 return io.ErrUnexpectedEOF
4479 }
4480 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4481 return err
4482 }
4483 iNdEx = postIndex
4484 default:
4485 iNdEx = preIndex
4486 skippy, err := skipGenerated(dAtA[iNdEx:])
4487 if err != nil {
4488 return err
4489 }
4490 if (skippy < 0) || (iNdEx+skippy) < 0 {
4491 return ErrInvalidLengthGenerated
4492 }
4493 if (iNdEx + skippy) > l {
4494 return io.ErrUnexpectedEOF
4495 }
4496 iNdEx += skippy
4497 }
4498 }
4499
4500 if iNdEx > l {
4501 return io.ErrUnexpectedEOF
4502 }
4503 return nil
4504 }
4505 func (m *VolumeAttachmentList) Unmarshal(dAtA []byte) error {
4506 l := len(dAtA)
4507 iNdEx := 0
4508 for iNdEx < l {
4509 preIndex := iNdEx
4510 var wire uint64
4511 for shift := uint(0); ; shift += 7 {
4512 if shift >= 64 {
4513 return ErrIntOverflowGenerated
4514 }
4515 if iNdEx >= l {
4516 return io.ErrUnexpectedEOF
4517 }
4518 b := dAtA[iNdEx]
4519 iNdEx++
4520 wire |= uint64(b&0x7F) << shift
4521 if b < 0x80 {
4522 break
4523 }
4524 }
4525 fieldNum := int32(wire >> 3)
4526 wireType := int(wire & 0x7)
4527 if wireType == 4 {
4528 return fmt.Errorf("proto: VolumeAttachmentList: wiretype end group for non-group")
4529 }
4530 if fieldNum <= 0 {
4531 return fmt.Errorf("proto: VolumeAttachmentList: illegal tag %d (wire type %d)", fieldNum, wire)
4532 }
4533 switch fieldNum {
4534 case 1:
4535 if wireType != 2 {
4536 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
4537 }
4538 var msglen int
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 msglen |= int(b&0x7F) << shift
4549 if b < 0x80 {
4550 break
4551 }
4552 }
4553 if msglen < 0 {
4554 return ErrInvalidLengthGenerated
4555 }
4556 postIndex := iNdEx + msglen
4557 if postIndex < 0 {
4558 return ErrInvalidLengthGenerated
4559 }
4560 if postIndex > l {
4561 return io.ErrUnexpectedEOF
4562 }
4563 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4564 return err
4565 }
4566 iNdEx = postIndex
4567 case 2:
4568 if wireType != 2 {
4569 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
4570 }
4571 var msglen int
4572 for shift := uint(0); ; shift += 7 {
4573 if shift >= 64 {
4574 return ErrIntOverflowGenerated
4575 }
4576 if iNdEx >= l {
4577 return io.ErrUnexpectedEOF
4578 }
4579 b := dAtA[iNdEx]
4580 iNdEx++
4581 msglen |= int(b&0x7F) << shift
4582 if b < 0x80 {
4583 break
4584 }
4585 }
4586 if msglen < 0 {
4587 return ErrInvalidLengthGenerated
4588 }
4589 postIndex := iNdEx + msglen
4590 if postIndex < 0 {
4591 return ErrInvalidLengthGenerated
4592 }
4593 if postIndex > l {
4594 return io.ErrUnexpectedEOF
4595 }
4596 m.Items = append(m.Items, VolumeAttachment{})
4597 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4598 return err
4599 }
4600 iNdEx = postIndex
4601 default:
4602 iNdEx = preIndex
4603 skippy, err := skipGenerated(dAtA[iNdEx:])
4604 if err != nil {
4605 return err
4606 }
4607 if (skippy < 0) || (iNdEx+skippy) < 0 {
4608 return ErrInvalidLengthGenerated
4609 }
4610 if (iNdEx + skippy) > l {
4611 return io.ErrUnexpectedEOF
4612 }
4613 iNdEx += skippy
4614 }
4615 }
4616
4617 if iNdEx > l {
4618 return io.ErrUnexpectedEOF
4619 }
4620 return nil
4621 }
4622 func (m *VolumeAttachmentSource) Unmarshal(dAtA []byte) error {
4623 l := len(dAtA)
4624 iNdEx := 0
4625 for iNdEx < l {
4626 preIndex := iNdEx
4627 var wire uint64
4628 for shift := uint(0); ; shift += 7 {
4629 if shift >= 64 {
4630 return ErrIntOverflowGenerated
4631 }
4632 if iNdEx >= l {
4633 return io.ErrUnexpectedEOF
4634 }
4635 b := dAtA[iNdEx]
4636 iNdEx++
4637 wire |= uint64(b&0x7F) << shift
4638 if b < 0x80 {
4639 break
4640 }
4641 }
4642 fieldNum := int32(wire >> 3)
4643 wireType := int(wire & 0x7)
4644 if wireType == 4 {
4645 return fmt.Errorf("proto: VolumeAttachmentSource: wiretype end group for non-group")
4646 }
4647 if fieldNum <= 0 {
4648 return fmt.Errorf("proto: VolumeAttachmentSource: illegal tag %d (wire type %d)", fieldNum, wire)
4649 }
4650 switch fieldNum {
4651 case 1:
4652 if wireType != 2 {
4653 return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeName", wireType)
4654 }
4655 var stringLen uint64
4656 for shift := uint(0); ; shift += 7 {
4657 if shift >= 64 {
4658 return ErrIntOverflowGenerated
4659 }
4660 if iNdEx >= l {
4661 return io.ErrUnexpectedEOF
4662 }
4663 b := dAtA[iNdEx]
4664 iNdEx++
4665 stringLen |= uint64(b&0x7F) << shift
4666 if b < 0x80 {
4667 break
4668 }
4669 }
4670 intStringLen := int(stringLen)
4671 if intStringLen < 0 {
4672 return ErrInvalidLengthGenerated
4673 }
4674 postIndex := iNdEx + intStringLen
4675 if postIndex < 0 {
4676 return ErrInvalidLengthGenerated
4677 }
4678 if postIndex > l {
4679 return io.ErrUnexpectedEOF
4680 }
4681 s := string(dAtA[iNdEx:postIndex])
4682 m.PersistentVolumeName = &s
4683 iNdEx = postIndex
4684 case 2:
4685 if wireType != 2 {
4686 return fmt.Errorf("proto: wrong wireType = %d for field InlineVolumeSpec", wireType)
4687 }
4688 var msglen int
4689 for shift := uint(0); ; shift += 7 {
4690 if shift >= 64 {
4691 return ErrIntOverflowGenerated
4692 }
4693 if iNdEx >= l {
4694 return io.ErrUnexpectedEOF
4695 }
4696 b := dAtA[iNdEx]
4697 iNdEx++
4698 msglen |= int(b&0x7F) << shift
4699 if b < 0x80 {
4700 break
4701 }
4702 }
4703 if msglen < 0 {
4704 return ErrInvalidLengthGenerated
4705 }
4706 postIndex := iNdEx + msglen
4707 if postIndex < 0 {
4708 return ErrInvalidLengthGenerated
4709 }
4710 if postIndex > l {
4711 return io.ErrUnexpectedEOF
4712 }
4713 if m.InlineVolumeSpec == nil {
4714 m.InlineVolumeSpec = &v11.PersistentVolumeSpec{}
4715 }
4716 if err := m.InlineVolumeSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4717 return err
4718 }
4719 iNdEx = postIndex
4720 default:
4721 iNdEx = preIndex
4722 skippy, err := skipGenerated(dAtA[iNdEx:])
4723 if err != nil {
4724 return err
4725 }
4726 if (skippy < 0) || (iNdEx+skippy) < 0 {
4727 return ErrInvalidLengthGenerated
4728 }
4729 if (iNdEx + skippy) > l {
4730 return io.ErrUnexpectedEOF
4731 }
4732 iNdEx += skippy
4733 }
4734 }
4735
4736 if iNdEx > l {
4737 return io.ErrUnexpectedEOF
4738 }
4739 return nil
4740 }
4741 func (m *VolumeAttachmentSpec) Unmarshal(dAtA []byte) error {
4742 l := len(dAtA)
4743 iNdEx := 0
4744 for iNdEx < l {
4745 preIndex := iNdEx
4746 var wire uint64
4747 for shift := uint(0); ; shift += 7 {
4748 if shift >= 64 {
4749 return ErrIntOverflowGenerated
4750 }
4751 if iNdEx >= l {
4752 return io.ErrUnexpectedEOF
4753 }
4754 b := dAtA[iNdEx]
4755 iNdEx++
4756 wire |= uint64(b&0x7F) << shift
4757 if b < 0x80 {
4758 break
4759 }
4760 }
4761 fieldNum := int32(wire >> 3)
4762 wireType := int(wire & 0x7)
4763 if wireType == 4 {
4764 return fmt.Errorf("proto: VolumeAttachmentSpec: wiretype end group for non-group")
4765 }
4766 if fieldNum <= 0 {
4767 return fmt.Errorf("proto: VolumeAttachmentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4768 }
4769 switch fieldNum {
4770 case 1:
4771 if wireType != 2 {
4772 return fmt.Errorf("proto: wrong wireType = %d for field Attacher", wireType)
4773 }
4774 var stringLen uint64
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 stringLen |= uint64(b&0x7F) << shift
4785 if b < 0x80 {
4786 break
4787 }
4788 }
4789 intStringLen := int(stringLen)
4790 if intStringLen < 0 {
4791 return ErrInvalidLengthGenerated
4792 }
4793 postIndex := iNdEx + intStringLen
4794 if postIndex < 0 {
4795 return ErrInvalidLengthGenerated
4796 }
4797 if postIndex > l {
4798 return io.ErrUnexpectedEOF
4799 }
4800 m.Attacher = string(dAtA[iNdEx:postIndex])
4801 iNdEx = postIndex
4802 case 2:
4803 if wireType != 2 {
4804 return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
4805 }
4806 var msglen int
4807 for shift := uint(0); ; shift += 7 {
4808 if shift >= 64 {
4809 return ErrIntOverflowGenerated
4810 }
4811 if iNdEx >= l {
4812 return io.ErrUnexpectedEOF
4813 }
4814 b := dAtA[iNdEx]
4815 iNdEx++
4816 msglen |= int(b&0x7F) << shift
4817 if b < 0x80 {
4818 break
4819 }
4820 }
4821 if msglen < 0 {
4822 return ErrInvalidLengthGenerated
4823 }
4824 postIndex := iNdEx + msglen
4825 if postIndex < 0 {
4826 return ErrInvalidLengthGenerated
4827 }
4828 if postIndex > l {
4829 return io.ErrUnexpectedEOF
4830 }
4831 if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4832 return err
4833 }
4834 iNdEx = postIndex
4835 case 3:
4836 if wireType != 2 {
4837 return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
4838 }
4839 var stringLen uint64
4840 for shift := uint(0); ; shift += 7 {
4841 if shift >= 64 {
4842 return ErrIntOverflowGenerated
4843 }
4844 if iNdEx >= l {
4845 return io.ErrUnexpectedEOF
4846 }
4847 b := dAtA[iNdEx]
4848 iNdEx++
4849 stringLen |= uint64(b&0x7F) << shift
4850 if b < 0x80 {
4851 break
4852 }
4853 }
4854 intStringLen := int(stringLen)
4855 if intStringLen < 0 {
4856 return ErrInvalidLengthGenerated
4857 }
4858 postIndex := iNdEx + intStringLen
4859 if postIndex < 0 {
4860 return ErrInvalidLengthGenerated
4861 }
4862 if postIndex > l {
4863 return io.ErrUnexpectedEOF
4864 }
4865 m.NodeName = string(dAtA[iNdEx:postIndex])
4866 iNdEx = postIndex
4867 default:
4868 iNdEx = preIndex
4869 skippy, err := skipGenerated(dAtA[iNdEx:])
4870 if err != nil {
4871 return err
4872 }
4873 if (skippy < 0) || (iNdEx+skippy) < 0 {
4874 return ErrInvalidLengthGenerated
4875 }
4876 if (iNdEx + skippy) > l {
4877 return io.ErrUnexpectedEOF
4878 }
4879 iNdEx += skippy
4880 }
4881 }
4882
4883 if iNdEx > l {
4884 return io.ErrUnexpectedEOF
4885 }
4886 return nil
4887 }
4888 func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
4889 l := len(dAtA)
4890 iNdEx := 0
4891 for iNdEx < l {
4892 preIndex := iNdEx
4893 var wire uint64
4894 for shift := uint(0); ; shift += 7 {
4895 if shift >= 64 {
4896 return ErrIntOverflowGenerated
4897 }
4898 if iNdEx >= l {
4899 return io.ErrUnexpectedEOF
4900 }
4901 b := dAtA[iNdEx]
4902 iNdEx++
4903 wire |= uint64(b&0x7F) << shift
4904 if b < 0x80 {
4905 break
4906 }
4907 }
4908 fieldNum := int32(wire >> 3)
4909 wireType := int(wire & 0x7)
4910 if wireType == 4 {
4911 return fmt.Errorf("proto: VolumeAttachmentStatus: wiretype end group for non-group")
4912 }
4913 if fieldNum <= 0 {
4914 return fmt.Errorf("proto: VolumeAttachmentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4915 }
4916 switch fieldNum {
4917 case 1:
4918 if wireType != 0 {
4919 return fmt.Errorf("proto: wrong wireType = %d for field Attached", wireType)
4920 }
4921 var v int
4922 for shift := uint(0); ; shift += 7 {
4923 if shift >= 64 {
4924 return ErrIntOverflowGenerated
4925 }
4926 if iNdEx >= l {
4927 return io.ErrUnexpectedEOF
4928 }
4929 b := dAtA[iNdEx]
4930 iNdEx++
4931 v |= int(b&0x7F) << shift
4932 if b < 0x80 {
4933 break
4934 }
4935 }
4936 m.Attached = bool(v != 0)
4937 case 2:
4938 if wireType != 2 {
4939 return fmt.Errorf("proto: wrong wireType = %d for field AttachmentMetadata", wireType)
4940 }
4941 var msglen int
4942 for shift := uint(0); ; shift += 7 {
4943 if shift >= 64 {
4944 return ErrIntOverflowGenerated
4945 }
4946 if iNdEx >= l {
4947 return io.ErrUnexpectedEOF
4948 }
4949 b := dAtA[iNdEx]
4950 iNdEx++
4951 msglen |= int(b&0x7F) << shift
4952 if b < 0x80 {
4953 break
4954 }
4955 }
4956 if msglen < 0 {
4957 return ErrInvalidLengthGenerated
4958 }
4959 postIndex := iNdEx + msglen
4960 if postIndex < 0 {
4961 return ErrInvalidLengthGenerated
4962 }
4963 if postIndex > l {
4964 return io.ErrUnexpectedEOF
4965 }
4966 if m.AttachmentMetadata == nil {
4967 m.AttachmentMetadata = make(map[string]string)
4968 }
4969 var mapkey string
4970 var mapvalue string
4971 for iNdEx < postIndex {
4972 entryPreIndex := iNdEx
4973 var wire uint64
4974 for shift := uint(0); ; shift += 7 {
4975 if shift >= 64 {
4976 return ErrIntOverflowGenerated
4977 }
4978 if iNdEx >= l {
4979 return io.ErrUnexpectedEOF
4980 }
4981 b := dAtA[iNdEx]
4982 iNdEx++
4983 wire |= uint64(b&0x7F) << shift
4984 if b < 0x80 {
4985 break
4986 }
4987 }
4988 fieldNum := int32(wire >> 3)
4989 if fieldNum == 1 {
4990 var stringLenmapkey uint64
4991 for shift := uint(0); ; shift += 7 {
4992 if shift >= 64 {
4993 return ErrIntOverflowGenerated
4994 }
4995 if iNdEx >= l {
4996 return io.ErrUnexpectedEOF
4997 }
4998 b := dAtA[iNdEx]
4999 iNdEx++
5000 stringLenmapkey |= uint64(b&0x7F) << shift
5001 if b < 0x80 {
5002 break
5003 }
5004 }
5005 intStringLenmapkey := int(stringLenmapkey)
5006 if intStringLenmapkey < 0 {
5007 return ErrInvalidLengthGenerated
5008 }
5009 postStringIndexmapkey := iNdEx + intStringLenmapkey
5010 if postStringIndexmapkey < 0 {
5011 return ErrInvalidLengthGenerated
5012 }
5013 if postStringIndexmapkey > l {
5014 return io.ErrUnexpectedEOF
5015 }
5016 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
5017 iNdEx = postStringIndexmapkey
5018 } else if fieldNum == 2 {
5019 var stringLenmapvalue uint64
5020 for shift := uint(0); ; shift += 7 {
5021 if shift >= 64 {
5022 return ErrIntOverflowGenerated
5023 }
5024 if iNdEx >= l {
5025 return io.ErrUnexpectedEOF
5026 }
5027 b := dAtA[iNdEx]
5028 iNdEx++
5029 stringLenmapvalue |= uint64(b&0x7F) << shift
5030 if b < 0x80 {
5031 break
5032 }
5033 }
5034 intStringLenmapvalue := int(stringLenmapvalue)
5035 if intStringLenmapvalue < 0 {
5036 return ErrInvalidLengthGenerated
5037 }
5038 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
5039 if postStringIndexmapvalue < 0 {
5040 return ErrInvalidLengthGenerated
5041 }
5042 if postStringIndexmapvalue > l {
5043 return io.ErrUnexpectedEOF
5044 }
5045 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
5046 iNdEx = postStringIndexmapvalue
5047 } else {
5048 iNdEx = entryPreIndex
5049 skippy, err := skipGenerated(dAtA[iNdEx:])
5050 if err != nil {
5051 return err
5052 }
5053 if (skippy < 0) || (iNdEx+skippy) < 0 {
5054 return ErrInvalidLengthGenerated
5055 }
5056 if (iNdEx + skippy) > postIndex {
5057 return io.ErrUnexpectedEOF
5058 }
5059 iNdEx += skippy
5060 }
5061 }
5062 m.AttachmentMetadata[mapkey] = mapvalue
5063 iNdEx = postIndex
5064 case 3:
5065 if wireType != 2 {
5066 return fmt.Errorf("proto: wrong wireType = %d for field AttachError", wireType)
5067 }
5068 var msglen int
5069 for shift := uint(0); ; shift += 7 {
5070 if shift >= 64 {
5071 return ErrIntOverflowGenerated
5072 }
5073 if iNdEx >= l {
5074 return io.ErrUnexpectedEOF
5075 }
5076 b := dAtA[iNdEx]
5077 iNdEx++
5078 msglen |= int(b&0x7F) << shift
5079 if b < 0x80 {
5080 break
5081 }
5082 }
5083 if msglen < 0 {
5084 return ErrInvalidLengthGenerated
5085 }
5086 postIndex := iNdEx + msglen
5087 if postIndex < 0 {
5088 return ErrInvalidLengthGenerated
5089 }
5090 if postIndex > l {
5091 return io.ErrUnexpectedEOF
5092 }
5093 if m.AttachError == nil {
5094 m.AttachError = &VolumeError{}
5095 }
5096 if err := m.AttachError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5097 return err
5098 }
5099 iNdEx = postIndex
5100 case 4:
5101 if wireType != 2 {
5102 return fmt.Errorf("proto: wrong wireType = %d for field DetachError", wireType)
5103 }
5104 var msglen int
5105 for shift := uint(0); ; shift += 7 {
5106 if shift >= 64 {
5107 return ErrIntOverflowGenerated
5108 }
5109 if iNdEx >= l {
5110 return io.ErrUnexpectedEOF
5111 }
5112 b := dAtA[iNdEx]
5113 iNdEx++
5114 msglen |= int(b&0x7F) << shift
5115 if b < 0x80 {
5116 break
5117 }
5118 }
5119 if msglen < 0 {
5120 return ErrInvalidLengthGenerated
5121 }
5122 postIndex := iNdEx + msglen
5123 if postIndex < 0 {
5124 return ErrInvalidLengthGenerated
5125 }
5126 if postIndex > l {
5127 return io.ErrUnexpectedEOF
5128 }
5129 if m.DetachError == nil {
5130 m.DetachError = &VolumeError{}
5131 }
5132 if err := m.DetachError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5133 return err
5134 }
5135 iNdEx = postIndex
5136 default:
5137 iNdEx = preIndex
5138 skippy, err := skipGenerated(dAtA[iNdEx:])
5139 if err != nil {
5140 return err
5141 }
5142 if (skippy < 0) || (iNdEx+skippy) < 0 {
5143 return ErrInvalidLengthGenerated
5144 }
5145 if (iNdEx + skippy) > l {
5146 return io.ErrUnexpectedEOF
5147 }
5148 iNdEx += skippy
5149 }
5150 }
5151
5152 if iNdEx > l {
5153 return io.ErrUnexpectedEOF
5154 }
5155 return nil
5156 }
5157 func (m *VolumeError) Unmarshal(dAtA []byte) error {
5158 l := len(dAtA)
5159 iNdEx := 0
5160 for iNdEx < l {
5161 preIndex := iNdEx
5162 var wire uint64
5163 for shift := uint(0); ; shift += 7 {
5164 if shift >= 64 {
5165 return ErrIntOverflowGenerated
5166 }
5167 if iNdEx >= l {
5168 return io.ErrUnexpectedEOF
5169 }
5170 b := dAtA[iNdEx]
5171 iNdEx++
5172 wire |= uint64(b&0x7F) << shift
5173 if b < 0x80 {
5174 break
5175 }
5176 }
5177 fieldNum := int32(wire >> 3)
5178 wireType := int(wire & 0x7)
5179 if wireType == 4 {
5180 return fmt.Errorf("proto: VolumeError: wiretype end group for non-group")
5181 }
5182 if fieldNum <= 0 {
5183 return fmt.Errorf("proto: VolumeError: illegal tag %d (wire type %d)", fieldNum, wire)
5184 }
5185 switch fieldNum {
5186 case 1:
5187 if wireType != 2 {
5188 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
5189 }
5190 var msglen int
5191 for shift := uint(0); ; shift += 7 {
5192 if shift >= 64 {
5193 return ErrIntOverflowGenerated
5194 }
5195 if iNdEx >= l {
5196 return io.ErrUnexpectedEOF
5197 }
5198 b := dAtA[iNdEx]
5199 iNdEx++
5200 msglen |= int(b&0x7F) << shift
5201 if b < 0x80 {
5202 break
5203 }
5204 }
5205 if msglen < 0 {
5206 return ErrInvalidLengthGenerated
5207 }
5208 postIndex := iNdEx + msglen
5209 if postIndex < 0 {
5210 return ErrInvalidLengthGenerated
5211 }
5212 if postIndex > l {
5213 return io.ErrUnexpectedEOF
5214 }
5215 if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
5216 return err
5217 }
5218 iNdEx = postIndex
5219 case 2:
5220 if wireType != 2 {
5221 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
5222 }
5223 var stringLen uint64
5224 for shift := uint(0); ; shift += 7 {
5225 if shift >= 64 {
5226 return ErrIntOverflowGenerated
5227 }
5228 if iNdEx >= l {
5229 return io.ErrUnexpectedEOF
5230 }
5231 b := dAtA[iNdEx]
5232 iNdEx++
5233 stringLen |= uint64(b&0x7F) << shift
5234 if b < 0x80 {
5235 break
5236 }
5237 }
5238 intStringLen := int(stringLen)
5239 if intStringLen < 0 {
5240 return ErrInvalidLengthGenerated
5241 }
5242 postIndex := iNdEx + intStringLen
5243 if postIndex < 0 {
5244 return ErrInvalidLengthGenerated
5245 }
5246 if postIndex > l {
5247 return io.ErrUnexpectedEOF
5248 }
5249 m.Message = string(dAtA[iNdEx:postIndex])
5250 iNdEx = postIndex
5251 default:
5252 iNdEx = preIndex
5253 skippy, err := skipGenerated(dAtA[iNdEx:])
5254 if err != nil {
5255 return err
5256 }
5257 if (skippy < 0) || (iNdEx+skippy) < 0 {
5258 return ErrInvalidLengthGenerated
5259 }
5260 if (iNdEx + skippy) > l {
5261 return io.ErrUnexpectedEOF
5262 }
5263 iNdEx += skippy
5264 }
5265 }
5266
5267 if iNdEx > l {
5268 return io.ErrUnexpectedEOF
5269 }
5270 return nil
5271 }
5272 func (m *VolumeNodeResources) Unmarshal(dAtA []byte) error {
5273 l := len(dAtA)
5274 iNdEx := 0
5275 for iNdEx < l {
5276 preIndex := iNdEx
5277 var wire uint64
5278 for shift := uint(0); ; shift += 7 {
5279 if shift >= 64 {
5280 return ErrIntOverflowGenerated
5281 }
5282 if iNdEx >= l {
5283 return io.ErrUnexpectedEOF
5284 }
5285 b := dAtA[iNdEx]
5286 iNdEx++
5287 wire |= uint64(b&0x7F) << shift
5288 if b < 0x80 {
5289 break
5290 }
5291 }
5292 fieldNum := int32(wire >> 3)
5293 wireType := int(wire & 0x7)
5294 if wireType == 4 {
5295 return fmt.Errorf("proto: VolumeNodeResources: wiretype end group for non-group")
5296 }
5297 if fieldNum <= 0 {
5298 return fmt.Errorf("proto: VolumeNodeResources: illegal tag %d (wire type %d)", fieldNum, wire)
5299 }
5300 switch fieldNum {
5301 case 1:
5302 if wireType != 0 {
5303 return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
5304 }
5305 var v int32
5306 for shift := uint(0); ; shift += 7 {
5307 if shift >= 64 {
5308 return ErrIntOverflowGenerated
5309 }
5310 if iNdEx >= l {
5311 return io.ErrUnexpectedEOF
5312 }
5313 b := dAtA[iNdEx]
5314 iNdEx++
5315 v |= int32(b&0x7F) << shift
5316 if b < 0x80 {
5317 break
5318 }
5319 }
5320 m.Count = &v
5321 default:
5322 iNdEx = preIndex
5323 skippy, err := skipGenerated(dAtA[iNdEx:])
5324 if err != nil {
5325 return err
5326 }
5327 if (skippy < 0) || (iNdEx+skippy) < 0 {
5328 return ErrInvalidLengthGenerated
5329 }
5330 if (iNdEx + skippy) > l {
5331 return io.ErrUnexpectedEOF
5332 }
5333 iNdEx += skippy
5334 }
5335 }
5336
5337 if iNdEx > l {
5338 return io.ErrUnexpectedEOF
5339 }
5340 return nil
5341 }
5342 func skipGenerated(dAtA []byte) (n int, err error) {
5343 l := len(dAtA)
5344 iNdEx := 0
5345 depth := 0
5346 for iNdEx < l {
5347 var wire uint64
5348 for shift := uint(0); ; shift += 7 {
5349 if shift >= 64 {
5350 return 0, ErrIntOverflowGenerated
5351 }
5352 if iNdEx >= l {
5353 return 0, io.ErrUnexpectedEOF
5354 }
5355 b := dAtA[iNdEx]
5356 iNdEx++
5357 wire |= (uint64(b) & 0x7F) << shift
5358 if b < 0x80 {
5359 break
5360 }
5361 }
5362 wireType := int(wire & 0x7)
5363 switch wireType {
5364 case 0:
5365 for shift := uint(0); ; shift += 7 {
5366 if shift >= 64 {
5367 return 0, ErrIntOverflowGenerated
5368 }
5369 if iNdEx >= l {
5370 return 0, io.ErrUnexpectedEOF
5371 }
5372 iNdEx++
5373 if dAtA[iNdEx-1] < 0x80 {
5374 break
5375 }
5376 }
5377 case 1:
5378 iNdEx += 8
5379 case 2:
5380 var length int
5381 for shift := uint(0); ; shift += 7 {
5382 if shift >= 64 {
5383 return 0, ErrIntOverflowGenerated
5384 }
5385 if iNdEx >= l {
5386 return 0, io.ErrUnexpectedEOF
5387 }
5388 b := dAtA[iNdEx]
5389 iNdEx++
5390 length |= (int(b) & 0x7F) << shift
5391 if b < 0x80 {
5392 break
5393 }
5394 }
5395 if length < 0 {
5396 return 0, ErrInvalidLengthGenerated
5397 }
5398 iNdEx += length
5399 case 3:
5400 depth++
5401 case 4:
5402 if depth == 0 {
5403 return 0, ErrUnexpectedEndOfGroupGenerated
5404 }
5405 depth--
5406 case 5:
5407 iNdEx += 4
5408 default:
5409 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
5410 }
5411 if iNdEx < 0 {
5412 return 0, ErrInvalidLengthGenerated
5413 }
5414 if depth == 0 {
5415 return iNdEx, nil
5416 }
5417 }
5418 return 0, io.ErrUnexpectedEOF
5419 }
5420
5421 var (
5422 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
5423 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
5424 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
5425 )
5426
View as plain text