blob: 3e995f039fc834ce1282d459d50fcca4b1ba00e0 [file] [log] [blame]
sslobodr60a6d0f2019-01-18 14:51:05 -05001/*
2Copyright The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8 http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17// Code generated by protoc-gen-gogo. DO NOT EDIT.
18// source: k8s.io/kubernetes/vendor/k8s.io/api/storage/v1beta1/generated.proto
19
20/*
21 Package v1beta1 is a generated protocol buffer package.
22
23 It is generated from these files:
24 k8s.io/kubernetes/vendor/k8s.io/api/storage/v1beta1/generated.proto
25
26 It has these top-level messages:
27 StorageClass
28 StorageClassList
29 VolumeAttachment
30 VolumeAttachmentList
31 VolumeAttachmentSource
32 VolumeAttachmentSpec
33 VolumeAttachmentStatus
34 VolumeError
35*/
36package v1beta1
37
38import proto "github.com/gogo/protobuf/proto"
39import fmt "fmt"
40import math "math"
41
42import k8s_io_api_core_v1 "k8s.io/api/core/v1"
43
44import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
45
46import strings "strings"
47import reflect "reflect"
48
49import io "io"
50
51// Reference imports to suppress errors if they are not otherwise used.
52var _ = proto.Marshal
53var _ = fmt.Errorf
54var _ = math.Inf
55
56// This is a compile-time assertion to ensure that this generated file
57// is compatible with the proto package it is being compiled against.
58// A compilation error at this line likely means your copy of the
59// proto package needs to be updated.
60const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
61
62func (m *StorageClass) Reset() { *m = StorageClass{} }
63func (*StorageClass) ProtoMessage() {}
64func (*StorageClass) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
65
66func (m *StorageClassList) Reset() { *m = StorageClassList{} }
67func (*StorageClassList) ProtoMessage() {}
68func (*StorageClassList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
69
70func (m *VolumeAttachment) Reset() { *m = VolumeAttachment{} }
71func (*VolumeAttachment) ProtoMessage() {}
72func (*VolumeAttachment) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
73
74func (m *VolumeAttachmentList) Reset() { *m = VolumeAttachmentList{} }
75func (*VolumeAttachmentList) ProtoMessage() {}
76func (*VolumeAttachmentList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
77
78func (m *VolumeAttachmentSource) Reset() { *m = VolumeAttachmentSource{} }
79func (*VolumeAttachmentSource) ProtoMessage() {}
80func (*VolumeAttachmentSource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
81
82func (m *VolumeAttachmentSpec) Reset() { *m = VolumeAttachmentSpec{} }
83func (*VolumeAttachmentSpec) ProtoMessage() {}
84func (*VolumeAttachmentSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
85
86func (m *VolumeAttachmentStatus) Reset() { *m = VolumeAttachmentStatus{} }
87func (*VolumeAttachmentStatus) ProtoMessage() {}
88func (*VolumeAttachmentStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
89
90func (m *VolumeError) Reset() { *m = VolumeError{} }
91func (*VolumeError) ProtoMessage() {}
92func (*VolumeError) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
93
94func init() {
95 proto.RegisterType((*StorageClass)(nil), "k8s.io.api.storage.v1beta1.StorageClass")
96 proto.RegisterType((*StorageClassList)(nil), "k8s.io.api.storage.v1beta1.StorageClassList")
97 proto.RegisterType((*VolumeAttachment)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachment")
98 proto.RegisterType((*VolumeAttachmentList)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentList")
99 proto.RegisterType((*VolumeAttachmentSource)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentSource")
100 proto.RegisterType((*VolumeAttachmentSpec)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentSpec")
101 proto.RegisterType((*VolumeAttachmentStatus)(nil), "k8s.io.api.storage.v1beta1.VolumeAttachmentStatus")
102 proto.RegisterType((*VolumeError)(nil), "k8s.io.api.storage.v1beta1.VolumeError")
103}
104func (m *StorageClass) Marshal() (dAtA []byte, err error) {
105 size := m.Size()
106 dAtA = make([]byte, size)
107 n, err := m.MarshalTo(dAtA)
108 if err != nil {
109 return nil, err
110 }
111 return dAtA[:n], nil
112}
113
114func (m *StorageClass) MarshalTo(dAtA []byte) (int, error) {
115 var i int
116 _ = i
117 var l int
118 _ = l
119 dAtA[i] = 0xa
120 i++
121 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
122 n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
123 if err != nil {
124 return 0, err
125 }
126 i += n1
127 dAtA[i] = 0x12
128 i++
129 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Provisioner)))
130 i += copy(dAtA[i:], m.Provisioner)
131 if len(m.Parameters) > 0 {
132 keysForParameters := make([]string, 0, len(m.Parameters))
133 for k := range m.Parameters {
134 keysForParameters = append(keysForParameters, string(k))
135 }
136 github_com_gogo_protobuf_sortkeys.Strings(keysForParameters)
137 for _, k := range keysForParameters {
138 dAtA[i] = 0x1a
139 i++
140 v := m.Parameters[string(k)]
141 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
142 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
143 dAtA[i] = 0xa
144 i++
145 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
146 i += copy(dAtA[i:], k)
147 dAtA[i] = 0x12
148 i++
149 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
150 i += copy(dAtA[i:], v)
151 }
152 }
153 if m.ReclaimPolicy != nil {
154 dAtA[i] = 0x22
155 i++
156 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.ReclaimPolicy)))
157 i += copy(dAtA[i:], *m.ReclaimPolicy)
158 }
159 if len(m.MountOptions) > 0 {
160 for _, s := range m.MountOptions {
161 dAtA[i] = 0x2a
162 i++
163 l = len(s)
164 for l >= 1<<7 {
165 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
166 l >>= 7
167 i++
168 }
169 dAtA[i] = uint8(l)
170 i++
171 i += copy(dAtA[i:], s)
172 }
173 }
174 if m.AllowVolumeExpansion != nil {
175 dAtA[i] = 0x30
176 i++
177 if *m.AllowVolumeExpansion {
178 dAtA[i] = 1
179 } else {
180 dAtA[i] = 0
181 }
182 i++
183 }
184 if m.VolumeBindingMode != nil {
185 dAtA[i] = 0x3a
186 i++
187 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.VolumeBindingMode)))
188 i += copy(dAtA[i:], *m.VolumeBindingMode)
189 }
190 if len(m.AllowedTopologies) > 0 {
191 for _, msg := range m.AllowedTopologies {
192 dAtA[i] = 0x42
193 i++
194 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
195 n, err := msg.MarshalTo(dAtA[i:])
196 if err != nil {
197 return 0, err
198 }
199 i += n
200 }
201 }
202 return i, nil
203}
204
205func (m *StorageClassList) Marshal() (dAtA []byte, err error) {
206 size := m.Size()
207 dAtA = make([]byte, size)
208 n, err := m.MarshalTo(dAtA)
209 if err != nil {
210 return nil, err
211 }
212 return dAtA[:n], nil
213}
214
215func (m *StorageClassList) MarshalTo(dAtA []byte) (int, error) {
216 var i int
217 _ = i
218 var l int
219 _ = l
220 dAtA[i] = 0xa
221 i++
222 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
223 n2, err := m.ListMeta.MarshalTo(dAtA[i:])
224 if err != nil {
225 return 0, err
226 }
227 i += n2
228 if len(m.Items) > 0 {
229 for _, msg := range m.Items {
230 dAtA[i] = 0x12
231 i++
232 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
233 n, err := msg.MarshalTo(dAtA[i:])
234 if err != nil {
235 return 0, err
236 }
237 i += n
238 }
239 }
240 return i, nil
241}
242
243func (m *VolumeAttachment) Marshal() (dAtA []byte, err error) {
244 size := m.Size()
245 dAtA = make([]byte, size)
246 n, err := m.MarshalTo(dAtA)
247 if err != nil {
248 return nil, err
249 }
250 return dAtA[:n], nil
251}
252
253func (m *VolumeAttachment) MarshalTo(dAtA []byte) (int, error) {
254 var i int
255 _ = i
256 var l int
257 _ = l
258 dAtA[i] = 0xa
259 i++
260 i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
261 n3, err := m.ObjectMeta.MarshalTo(dAtA[i:])
262 if err != nil {
263 return 0, err
264 }
265 i += n3
266 dAtA[i] = 0x12
267 i++
268 i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
269 n4, err := m.Spec.MarshalTo(dAtA[i:])
270 if err != nil {
271 return 0, err
272 }
273 i += n4
274 dAtA[i] = 0x1a
275 i++
276 i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
277 n5, err := m.Status.MarshalTo(dAtA[i:])
278 if err != nil {
279 return 0, err
280 }
281 i += n5
282 return i, nil
283}
284
285func (m *VolumeAttachmentList) Marshal() (dAtA []byte, err error) {
286 size := m.Size()
287 dAtA = make([]byte, size)
288 n, err := m.MarshalTo(dAtA)
289 if err != nil {
290 return nil, err
291 }
292 return dAtA[:n], nil
293}
294
295func (m *VolumeAttachmentList) MarshalTo(dAtA []byte) (int, error) {
296 var i int
297 _ = i
298 var l int
299 _ = l
300 dAtA[i] = 0xa
301 i++
302 i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
303 n6, err := m.ListMeta.MarshalTo(dAtA[i:])
304 if err != nil {
305 return 0, err
306 }
307 i += n6
308 if len(m.Items) > 0 {
309 for _, msg := range m.Items {
310 dAtA[i] = 0x12
311 i++
312 i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
313 n, err := msg.MarshalTo(dAtA[i:])
314 if err != nil {
315 return 0, err
316 }
317 i += n
318 }
319 }
320 return i, nil
321}
322
323func (m *VolumeAttachmentSource) Marshal() (dAtA []byte, err error) {
324 size := m.Size()
325 dAtA = make([]byte, size)
326 n, err := m.MarshalTo(dAtA)
327 if err != nil {
328 return nil, err
329 }
330 return dAtA[:n], nil
331}
332
333func (m *VolumeAttachmentSource) MarshalTo(dAtA []byte) (int, error) {
334 var i int
335 _ = i
336 var l int
337 _ = l
338 if m.PersistentVolumeName != nil {
339 dAtA[i] = 0xa
340 i++
341 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PersistentVolumeName)))
342 i += copy(dAtA[i:], *m.PersistentVolumeName)
343 }
344 return i, nil
345}
346
347func (m *VolumeAttachmentSpec) Marshal() (dAtA []byte, err error) {
348 size := m.Size()
349 dAtA = make([]byte, size)
350 n, err := m.MarshalTo(dAtA)
351 if err != nil {
352 return nil, err
353 }
354 return dAtA[:n], nil
355}
356
357func (m *VolumeAttachmentSpec) MarshalTo(dAtA []byte) (int, error) {
358 var i int
359 _ = i
360 var l int
361 _ = l
362 dAtA[i] = 0xa
363 i++
364 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Attacher)))
365 i += copy(dAtA[i:], m.Attacher)
366 dAtA[i] = 0x12
367 i++
368 i = encodeVarintGenerated(dAtA, i, uint64(m.Source.Size()))
369 n7, err := m.Source.MarshalTo(dAtA[i:])
370 if err != nil {
371 return 0, err
372 }
373 i += n7
374 dAtA[i] = 0x1a
375 i++
376 i = encodeVarintGenerated(dAtA, i, uint64(len(m.NodeName)))
377 i += copy(dAtA[i:], m.NodeName)
378 return i, nil
379}
380
381func (m *VolumeAttachmentStatus) Marshal() (dAtA []byte, err error) {
382 size := m.Size()
383 dAtA = make([]byte, size)
384 n, err := m.MarshalTo(dAtA)
385 if err != nil {
386 return nil, err
387 }
388 return dAtA[:n], nil
389}
390
391func (m *VolumeAttachmentStatus) MarshalTo(dAtA []byte) (int, error) {
392 var i int
393 _ = i
394 var l int
395 _ = l
396 dAtA[i] = 0x8
397 i++
398 if m.Attached {
399 dAtA[i] = 1
400 } else {
401 dAtA[i] = 0
402 }
403 i++
404 if len(m.AttachmentMetadata) > 0 {
405 keysForAttachmentMetadata := make([]string, 0, len(m.AttachmentMetadata))
406 for k := range m.AttachmentMetadata {
407 keysForAttachmentMetadata = append(keysForAttachmentMetadata, string(k))
408 }
409 github_com_gogo_protobuf_sortkeys.Strings(keysForAttachmentMetadata)
410 for _, k := range keysForAttachmentMetadata {
411 dAtA[i] = 0x12
412 i++
413 v := m.AttachmentMetadata[string(k)]
414 mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
415 i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
416 dAtA[i] = 0xa
417 i++
418 i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
419 i += copy(dAtA[i:], k)
420 dAtA[i] = 0x12
421 i++
422 i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
423 i += copy(dAtA[i:], v)
424 }
425 }
426 if m.AttachError != nil {
427 dAtA[i] = 0x1a
428 i++
429 i = encodeVarintGenerated(dAtA, i, uint64(m.AttachError.Size()))
430 n8, err := m.AttachError.MarshalTo(dAtA[i:])
431 if err != nil {
432 return 0, err
433 }
434 i += n8
435 }
436 if m.DetachError != nil {
437 dAtA[i] = 0x22
438 i++
439 i = encodeVarintGenerated(dAtA, i, uint64(m.DetachError.Size()))
440 n9, err := m.DetachError.MarshalTo(dAtA[i:])
441 if err != nil {
442 return 0, err
443 }
444 i += n9
445 }
446 return i, nil
447}
448
449func (m *VolumeError) Marshal() (dAtA []byte, err error) {
450 size := m.Size()
451 dAtA = make([]byte, size)
452 n, err := m.MarshalTo(dAtA)
453 if err != nil {
454 return nil, err
455 }
456 return dAtA[:n], nil
457}
458
459func (m *VolumeError) MarshalTo(dAtA []byte) (int, error) {
460 var i int
461 _ = i
462 var l int
463 _ = l
464 dAtA[i] = 0xa
465 i++
466 i = encodeVarintGenerated(dAtA, i, uint64(m.Time.Size()))
467 n10, err := m.Time.MarshalTo(dAtA[i:])
468 if err != nil {
469 return 0, err
470 }
471 i += n10
472 dAtA[i] = 0x12
473 i++
474 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
475 i += copy(dAtA[i:], m.Message)
476 return i, nil
477}
478
479func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
480 for v >= 1<<7 {
481 dAtA[offset] = uint8(v&0x7f | 0x80)
482 v >>= 7
483 offset++
484 }
485 dAtA[offset] = uint8(v)
486 return offset + 1
487}
488func (m *StorageClass) Size() (n int) {
489 var l int
490 _ = l
491 l = m.ObjectMeta.Size()
492 n += 1 + l + sovGenerated(uint64(l))
493 l = len(m.Provisioner)
494 n += 1 + l + sovGenerated(uint64(l))
495 if len(m.Parameters) > 0 {
496 for k, v := range m.Parameters {
497 _ = k
498 _ = v
499 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
500 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
501 }
502 }
503 if m.ReclaimPolicy != nil {
504 l = len(*m.ReclaimPolicy)
505 n += 1 + l + sovGenerated(uint64(l))
506 }
507 if len(m.MountOptions) > 0 {
508 for _, s := range m.MountOptions {
509 l = len(s)
510 n += 1 + l + sovGenerated(uint64(l))
511 }
512 }
513 if m.AllowVolumeExpansion != nil {
514 n += 2
515 }
516 if m.VolumeBindingMode != nil {
517 l = len(*m.VolumeBindingMode)
518 n += 1 + l + sovGenerated(uint64(l))
519 }
520 if len(m.AllowedTopologies) > 0 {
521 for _, e := range m.AllowedTopologies {
522 l = e.Size()
523 n += 1 + l + sovGenerated(uint64(l))
524 }
525 }
526 return n
527}
528
529func (m *StorageClassList) Size() (n int) {
530 var l int
531 _ = l
532 l = m.ListMeta.Size()
533 n += 1 + l + sovGenerated(uint64(l))
534 if len(m.Items) > 0 {
535 for _, e := range m.Items {
536 l = e.Size()
537 n += 1 + l + sovGenerated(uint64(l))
538 }
539 }
540 return n
541}
542
543func (m *VolumeAttachment) Size() (n int) {
544 var l int
545 _ = l
546 l = m.ObjectMeta.Size()
547 n += 1 + l + sovGenerated(uint64(l))
548 l = m.Spec.Size()
549 n += 1 + l + sovGenerated(uint64(l))
550 l = m.Status.Size()
551 n += 1 + l + sovGenerated(uint64(l))
552 return n
553}
554
555func (m *VolumeAttachmentList) Size() (n int) {
556 var l int
557 _ = l
558 l = m.ListMeta.Size()
559 n += 1 + l + sovGenerated(uint64(l))
560 if len(m.Items) > 0 {
561 for _, e := range m.Items {
562 l = e.Size()
563 n += 1 + l + sovGenerated(uint64(l))
564 }
565 }
566 return n
567}
568
569func (m *VolumeAttachmentSource) Size() (n int) {
570 var l int
571 _ = l
572 if m.PersistentVolumeName != nil {
573 l = len(*m.PersistentVolumeName)
574 n += 1 + l + sovGenerated(uint64(l))
575 }
576 return n
577}
578
579func (m *VolumeAttachmentSpec) Size() (n int) {
580 var l int
581 _ = l
582 l = len(m.Attacher)
583 n += 1 + l + sovGenerated(uint64(l))
584 l = m.Source.Size()
585 n += 1 + l + sovGenerated(uint64(l))
586 l = len(m.NodeName)
587 n += 1 + l + sovGenerated(uint64(l))
588 return n
589}
590
591func (m *VolumeAttachmentStatus) Size() (n int) {
592 var l int
593 _ = l
594 n += 2
595 if len(m.AttachmentMetadata) > 0 {
596 for k, v := range m.AttachmentMetadata {
597 _ = k
598 _ = v
599 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
600 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
601 }
602 }
603 if m.AttachError != nil {
604 l = m.AttachError.Size()
605 n += 1 + l + sovGenerated(uint64(l))
606 }
607 if m.DetachError != nil {
608 l = m.DetachError.Size()
609 n += 1 + l + sovGenerated(uint64(l))
610 }
611 return n
612}
613
614func (m *VolumeError) Size() (n int) {
615 var l int
616 _ = l
617 l = m.Time.Size()
618 n += 1 + l + sovGenerated(uint64(l))
619 l = len(m.Message)
620 n += 1 + l + sovGenerated(uint64(l))
621 return n
622}
623
624func sovGenerated(x uint64) (n int) {
625 for {
626 n++
627 x >>= 7
628 if x == 0 {
629 break
630 }
631 }
632 return n
633}
634func sozGenerated(x uint64) (n int) {
635 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
636}
637func (this *StorageClass) String() string {
638 if this == nil {
639 return "nil"
640 }
641 keysForParameters := make([]string, 0, len(this.Parameters))
642 for k := range this.Parameters {
643 keysForParameters = append(keysForParameters, k)
644 }
645 github_com_gogo_protobuf_sortkeys.Strings(keysForParameters)
646 mapStringForParameters := "map[string]string{"
647 for _, k := range keysForParameters {
648 mapStringForParameters += fmt.Sprintf("%v: %v,", k, this.Parameters[k])
649 }
650 mapStringForParameters += "}"
651 s := strings.Join([]string{`&StorageClass{`,
652 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
653 `Provisioner:` + fmt.Sprintf("%v", this.Provisioner) + `,`,
654 `Parameters:` + mapStringForParameters + `,`,
655 `ReclaimPolicy:` + valueToStringGenerated(this.ReclaimPolicy) + `,`,
656 `MountOptions:` + fmt.Sprintf("%v", this.MountOptions) + `,`,
657 `AllowVolumeExpansion:` + valueToStringGenerated(this.AllowVolumeExpansion) + `,`,
658 `VolumeBindingMode:` + valueToStringGenerated(this.VolumeBindingMode) + `,`,
659 `AllowedTopologies:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AllowedTopologies), "TopologySelectorTerm", "k8s_io_api_core_v1.TopologySelectorTerm", 1), `&`, ``, 1) + `,`,
660 `}`,
661 }, "")
662 return s
663}
664func (this *StorageClassList) String() string {
665 if this == nil {
666 return "nil"
667 }
668 s := strings.Join([]string{`&StorageClassList{`,
669 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
670 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "StorageClass", "StorageClass", 1), `&`, ``, 1) + `,`,
671 `}`,
672 }, "")
673 return s
674}
675func (this *VolumeAttachment) String() string {
676 if this == nil {
677 return "nil"
678 }
679 s := strings.Join([]string{`&VolumeAttachment{`,
680 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
681 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "VolumeAttachmentSpec", "VolumeAttachmentSpec", 1), `&`, ``, 1) + `,`,
682 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "VolumeAttachmentStatus", "VolumeAttachmentStatus", 1), `&`, ``, 1) + `,`,
683 `}`,
684 }, "")
685 return s
686}
687func (this *VolumeAttachmentList) String() string {
688 if this == nil {
689 return "nil"
690 }
691 s := strings.Join([]string{`&VolumeAttachmentList{`,
692 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
693 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "VolumeAttachment", "VolumeAttachment", 1), `&`, ``, 1) + `,`,
694 `}`,
695 }, "")
696 return s
697}
698func (this *VolumeAttachmentSource) String() string {
699 if this == nil {
700 return "nil"
701 }
702 s := strings.Join([]string{`&VolumeAttachmentSource{`,
703 `PersistentVolumeName:` + valueToStringGenerated(this.PersistentVolumeName) + `,`,
704 `}`,
705 }, "")
706 return s
707}
708func (this *VolumeAttachmentSpec) String() string {
709 if this == nil {
710 return "nil"
711 }
712 s := strings.Join([]string{`&VolumeAttachmentSpec{`,
713 `Attacher:` + fmt.Sprintf("%v", this.Attacher) + `,`,
714 `Source:` + strings.Replace(strings.Replace(this.Source.String(), "VolumeAttachmentSource", "VolumeAttachmentSource", 1), `&`, ``, 1) + `,`,
715 `NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
716 `}`,
717 }, "")
718 return s
719}
720func (this *VolumeAttachmentStatus) String() string {
721 if this == nil {
722 return "nil"
723 }
724 keysForAttachmentMetadata := make([]string, 0, len(this.AttachmentMetadata))
725 for k := range this.AttachmentMetadata {
726 keysForAttachmentMetadata = append(keysForAttachmentMetadata, k)
727 }
728 github_com_gogo_protobuf_sortkeys.Strings(keysForAttachmentMetadata)
729 mapStringForAttachmentMetadata := "map[string]string{"
730 for _, k := range keysForAttachmentMetadata {
731 mapStringForAttachmentMetadata += fmt.Sprintf("%v: %v,", k, this.AttachmentMetadata[k])
732 }
733 mapStringForAttachmentMetadata += "}"
734 s := strings.Join([]string{`&VolumeAttachmentStatus{`,
735 `Attached:` + fmt.Sprintf("%v", this.Attached) + `,`,
736 `AttachmentMetadata:` + mapStringForAttachmentMetadata + `,`,
737 `AttachError:` + strings.Replace(fmt.Sprintf("%v", this.AttachError), "VolumeError", "VolumeError", 1) + `,`,
738 `DetachError:` + strings.Replace(fmt.Sprintf("%v", this.DetachError), "VolumeError", "VolumeError", 1) + `,`,
739 `}`,
740 }, "")
741 return s
742}
743func (this *VolumeError) String() string {
744 if this == nil {
745 return "nil"
746 }
747 s := strings.Join([]string{`&VolumeError{`,
748 `Time:` + strings.Replace(strings.Replace(this.Time.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
749 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
750 `}`,
751 }, "")
752 return s
753}
754func valueToStringGenerated(v interface{}) string {
755 rv := reflect.ValueOf(v)
756 if rv.IsNil() {
757 return "nil"
758 }
759 pv := reflect.Indirect(rv).Interface()
760 return fmt.Sprintf("*%v", pv)
761}
762func (m *StorageClass) Unmarshal(dAtA []byte) error {
763 l := len(dAtA)
764 iNdEx := 0
765 for iNdEx < l {
766 preIndex := iNdEx
767 var wire uint64
768 for shift := uint(0); ; shift += 7 {
769 if shift >= 64 {
770 return ErrIntOverflowGenerated
771 }
772 if iNdEx >= l {
773 return io.ErrUnexpectedEOF
774 }
775 b := dAtA[iNdEx]
776 iNdEx++
777 wire |= (uint64(b) & 0x7F) << shift
778 if b < 0x80 {
779 break
780 }
781 }
782 fieldNum := int32(wire >> 3)
783 wireType := int(wire & 0x7)
784 if wireType == 4 {
785 return fmt.Errorf("proto: StorageClass: wiretype end group for non-group")
786 }
787 if fieldNum <= 0 {
788 return fmt.Errorf("proto: StorageClass: illegal tag %d (wire type %d)", fieldNum, wire)
789 }
790 switch fieldNum {
791 case 1:
792 if wireType != 2 {
793 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
794 }
795 var msglen int
796 for shift := uint(0); ; shift += 7 {
797 if shift >= 64 {
798 return ErrIntOverflowGenerated
799 }
800 if iNdEx >= l {
801 return io.ErrUnexpectedEOF
802 }
803 b := dAtA[iNdEx]
804 iNdEx++
805 msglen |= (int(b) & 0x7F) << shift
806 if b < 0x80 {
807 break
808 }
809 }
810 if msglen < 0 {
811 return ErrInvalidLengthGenerated
812 }
813 postIndex := iNdEx + msglen
814 if postIndex > l {
815 return io.ErrUnexpectedEOF
816 }
817 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
818 return err
819 }
820 iNdEx = postIndex
821 case 2:
822 if wireType != 2 {
823 return fmt.Errorf("proto: wrong wireType = %d for field Provisioner", wireType)
824 }
825 var stringLen uint64
826 for shift := uint(0); ; shift += 7 {
827 if shift >= 64 {
828 return ErrIntOverflowGenerated
829 }
830 if iNdEx >= l {
831 return io.ErrUnexpectedEOF
832 }
833 b := dAtA[iNdEx]
834 iNdEx++
835 stringLen |= (uint64(b) & 0x7F) << shift
836 if b < 0x80 {
837 break
838 }
839 }
840 intStringLen := int(stringLen)
841 if intStringLen < 0 {
842 return ErrInvalidLengthGenerated
843 }
844 postIndex := iNdEx + intStringLen
845 if postIndex > l {
846 return io.ErrUnexpectedEOF
847 }
848 m.Provisioner = string(dAtA[iNdEx:postIndex])
849 iNdEx = postIndex
850 case 3:
851 if wireType != 2 {
852 return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
853 }
854 var msglen int
855 for shift := uint(0); ; shift += 7 {
856 if shift >= 64 {
857 return ErrIntOverflowGenerated
858 }
859 if iNdEx >= l {
860 return io.ErrUnexpectedEOF
861 }
862 b := dAtA[iNdEx]
863 iNdEx++
864 msglen |= (int(b) & 0x7F) << shift
865 if b < 0x80 {
866 break
867 }
868 }
869 if msglen < 0 {
870 return ErrInvalidLengthGenerated
871 }
872 postIndex := iNdEx + msglen
873 if postIndex > l {
874 return io.ErrUnexpectedEOF
875 }
876 if m.Parameters == nil {
877 m.Parameters = make(map[string]string)
878 }
879 var mapkey string
880 var mapvalue string
881 for iNdEx < postIndex {
882 entryPreIndex := iNdEx
883 var wire uint64
884 for shift := uint(0); ; shift += 7 {
885 if shift >= 64 {
886 return ErrIntOverflowGenerated
887 }
888 if iNdEx >= l {
889 return io.ErrUnexpectedEOF
890 }
891 b := dAtA[iNdEx]
892 iNdEx++
893 wire |= (uint64(b) & 0x7F) << shift
894 if b < 0x80 {
895 break
896 }
897 }
898 fieldNum := int32(wire >> 3)
899 if fieldNum == 1 {
900 var stringLenmapkey uint64
901 for shift := uint(0); ; shift += 7 {
902 if shift >= 64 {
903 return ErrIntOverflowGenerated
904 }
905 if iNdEx >= l {
906 return io.ErrUnexpectedEOF
907 }
908 b := dAtA[iNdEx]
909 iNdEx++
910 stringLenmapkey |= (uint64(b) & 0x7F) << shift
911 if b < 0x80 {
912 break
913 }
914 }
915 intStringLenmapkey := int(stringLenmapkey)
916 if intStringLenmapkey < 0 {
917 return ErrInvalidLengthGenerated
918 }
919 postStringIndexmapkey := iNdEx + intStringLenmapkey
920 if postStringIndexmapkey > l {
921 return io.ErrUnexpectedEOF
922 }
923 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
924 iNdEx = postStringIndexmapkey
925 } else if fieldNum == 2 {
926 var stringLenmapvalue uint64
927 for shift := uint(0); ; shift += 7 {
928 if shift >= 64 {
929 return ErrIntOverflowGenerated
930 }
931 if iNdEx >= l {
932 return io.ErrUnexpectedEOF
933 }
934 b := dAtA[iNdEx]
935 iNdEx++
936 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
937 if b < 0x80 {
938 break
939 }
940 }
941 intStringLenmapvalue := int(stringLenmapvalue)
942 if intStringLenmapvalue < 0 {
943 return ErrInvalidLengthGenerated
944 }
945 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
946 if postStringIndexmapvalue > l {
947 return io.ErrUnexpectedEOF
948 }
949 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
950 iNdEx = postStringIndexmapvalue
951 } else {
952 iNdEx = entryPreIndex
953 skippy, err := skipGenerated(dAtA[iNdEx:])
954 if err != nil {
955 return err
956 }
957 if skippy < 0 {
958 return ErrInvalidLengthGenerated
959 }
960 if (iNdEx + skippy) > postIndex {
961 return io.ErrUnexpectedEOF
962 }
963 iNdEx += skippy
964 }
965 }
966 m.Parameters[mapkey] = mapvalue
967 iNdEx = postIndex
968 case 4:
969 if wireType != 2 {
970 return fmt.Errorf("proto: wrong wireType = %d for field ReclaimPolicy", wireType)
971 }
972 var stringLen uint64
973 for shift := uint(0); ; shift += 7 {
974 if shift >= 64 {
975 return ErrIntOverflowGenerated
976 }
977 if iNdEx >= l {
978 return io.ErrUnexpectedEOF
979 }
980 b := dAtA[iNdEx]
981 iNdEx++
982 stringLen |= (uint64(b) & 0x7F) << shift
983 if b < 0x80 {
984 break
985 }
986 }
987 intStringLen := int(stringLen)
988 if intStringLen < 0 {
989 return ErrInvalidLengthGenerated
990 }
991 postIndex := iNdEx + intStringLen
992 if postIndex > l {
993 return io.ErrUnexpectedEOF
994 }
995 s := k8s_io_api_core_v1.PersistentVolumeReclaimPolicy(dAtA[iNdEx:postIndex])
996 m.ReclaimPolicy = &s
997 iNdEx = postIndex
998 case 5:
999 if wireType != 2 {
1000 return fmt.Errorf("proto: wrong wireType = %d for field MountOptions", wireType)
1001 }
1002 var stringLen uint64
1003 for shift := uint(0); ; shift += 7 {
1004 if shift >= 64 {
1005 return ErrIntOverflowGenerated
1006 }
1007 if iNdEx >= l {
1008 return io.ErrUnexpectedEOF
1009 }
1010 b := dAtA[iNdEx]
1011 iNdEx++
1012 stringLen |= (uint64(b) & 0x7F) << shift
1013 if b < 0x80 {
1014 break
1015 }
1016 }
1017 intStringLen := int(stringLen)
1018 if intStringLen < 0 {
1019 return ErrInvalidLengthGenerated
1020 }
1021 postIndex := iNdEx + intStringLen
1022 if postIndex > l {
1023 return io.ErrUnexpectedEOF
1024 }
1025 m.MountOptions = append(m.MountOptions, string(dAtA[iNdEx:postIndex]))
1026 iNdEx = postIndex
1027 case 6:
1028 if wireType != 0 {
1029 return fmt.Errorf("proto: wrong wireType = %d for field AllowVolumeExpansion", wireType)
1030 }
1031 var v int
1032 for shift := uint(0); ; shift += 7 {
1033 if shift >= 64 {
1034 return ErrIntOverflowGenerated
1035 }
1036 if iNdEx >= l {
1037 return io.ErrUnexpectedEOF
1038 }
1039 b := dAtA[iNdEx]
1040 iNdEx++
1041 v |= (int(b) & 0x7F) << shift
1042 if b < 0x80 {
1043 break
1044 }
1045 }
1046 b := bool(v != 0)
1047 m.AllowVolumeExpansion = &b
1048 case 7:
1049 if wireType != 2 {
1050 return fmt.Errorf("proto: wrong wireType = %d for field VolumeBindingMode", wireType)
1051 }
1052 var stringLen uint64
1053 for shift := uint(0); ; shift += 7 {
1054 if shift >= 64 {
1055 return ErrIntOverflowGenerated
1056 }
1057 if iNdEx >= l {
1058 return io.ErrUnexpectedEOF
1059 }
1060 b := dAtA[iNdEx]
1061 iNdEx++
1062 stringLen |= (uint64(b) & 0x7F) << shift
1063 if b < 0x80 {
1064 break
1065 }
1066 }
1067 intStringLen := int(stringLen)
1068 if intStringLen < 0 {
1069 return ErrInvalidLengthGenerated
1070 }
1071 postIndex := iNdEx + intStringLen
1072 if postIndex > l {
1073 return io.ErrUnexpectedEOF
1074 }
1075 s := VolumeBindingMode(dAtA[iNdEx:postIndex])
1076 m.VolumeBindingMode = &s
1077 iNdEx = postIndex
1078 case 8:
1079 if wireType != 2 {
1080 return fmt.Errorf("proto: wrong wireType = %d for field AllowedTopologies", wireType)
1081 }
1082 var msglen int
1083 for shift := uint(0); ; shift += 7 {
1084 if shift >= 64 {
1085 return ErrIntOverflowGenerated
1086 }
1087 if iNdEx >= l {
1088 return io.ErrUnexpectedEOF
1089 }
1090 b := dAtA[iNdEx]
1091 iNdEx++
1092 msglen |= (int(b) & 0x7F) << shift
1093 if b < 0x80 {
1094 break
1095 }
1096 }
1097 if msglen < 0 {
1098 return ErrInvalidLengthGenerated
1099 }
1100 postIndex := iNdEx + msglen
1101 if postIndex > l {
1102 return io.ErrUnexpectedEOF
1103 }
1104 m.AllowedTopologies = append(m.AllowedTopologies, k8s_io_api_core_v1.TopologySelectorTerm{})
1105 if err := m.AllowedTopologies[len(m.AllowedTopologies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1106 return err
1107 }
1108 iNdEx = postIndex
1109 default:
1110 iNdEx = preIndex
1111 skippy, err := skipGenerated(dAtA[iNdEx:])
1112 if err != nil {
1113 return err
1114 }
1115 if skippy < 0 {
1116 return ErrInvalidLengthGenerated
1117 }
1118 if (iNdEx + skippy) > l {
1119 return io.ErrUnexpectedEOF
1120 }
1121 iNdEx += skippy
1122 }
1123 }
1124
1125 if iNdEx > l {
1126 return io.ErrUnexpectedEOF
1127 }
1128 return nil
1129}
1130func (m *StorageClassList) Unmarshal(dAtA []byte) error {
1131 l := len(dAtA)
1132 iNdEx := 0
1133 for iNdEx < l {
1134 preIndex := iNdEx
1135 var wire uint64
1136 for shift := uint(0); ; shift += 7 {
1137 if shift >= 64 {
1138 return ErrIntOverflowGenerated
1139 }
1140 if iNdEx >= l {
1141 return io.ErrUnexpectedEOF
1142 }
1143 b := dAtA[iNdEx]
1144 iNdEx++
1145 wire |= (uint64(b) & 0x7F) << shift
1146 if b < 0x80 {
1147 break
1148 }
1149 }
1150 fieldNum := int32(wire >> 3)
1151 wireType := int(wire & 0x7)
1152 if wireType == 4 {
1153 return fmt.Errorf("proto: StorageClassList: wiretype end group for non-group")
1154 }
1155 if fieldNum <= 0 {
1156 return fmt.Errorf("proto: StorageClassList: illegal tag %d (wire type %d)", fieldNum, wire)
1157 }
1158 switch fieldNum {
1159 case 1:
1160 if wireType != 2 {
1161 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1162 }
1163 var msglen int
1164 for shift := uint(0); ; shift += 7 {
1165 if shift >= 64 {
1166 return ErrIntOverflowGenerated
1167 }
1168 if iNdEx >= l {
1169 return io.ErrUnexpectedEOF
1170 }
1171 b := dAtA[iNdEx]
1172 iNdEx++
1173 msglen |= (int(b) & 0x7F) << shift
1174 if b < 0x80 {
1175 break
1176 }
1177 }
1178 if msglen < 0 {
1179 return ErrInvalidLengthGenerated
1180 }
1181 postIndex := iNdEx + msglen
1182 if postIndex > l {
1183 return io.ErrUnexpectedEOF
1184 }
1185 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1186 return err
1187 }
1188 iNdEx = postIndex
1189 case 2:
1190 if wireType != 2 {
1191 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1192 }
1193 var msglen int
1194 for shift := uint(0); ; shift += 7 {
1195 if shift >= 64 {
1196 return ErrIntOverflowGenerated
1197 }
1198 if iNdEx >= l {
1199 return io.ErrUnexpectedEOF
1200 }
1201 b := dAtA[iNdEx]
1202 iNdEx++
1203 msglen |= (int(b) & 0x7F) << shift
1204 if b < 0x80 {
1205 break
1206 }
1207 }
1208 if msglen < 0 {
1209 return ErrInvalidLengthGenerated
1210 }
1211 postIndex := iNdEx + msglen
1212 if postIndex > l {
1213 return io.ErrUnexpectedEOF
1214 }
1215 m.Items = append(m.Items, StorageClass{})
1216 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1217 return err
1218 }
1219 iNdEx = postIndex
1220 default:
1221 iNdEx = preIndex
1222 skippy, err := skipGenerated(dAtA[iNdEx:])
1223 if err != nil {
1224 return err
1225 }
1226 if skippy < 0 {
1227 return ErrInvalidLengthGenerated
1228 }
1229 if (iNdEx + skippy) > l {
1230 return io.ErrUnexpectedEOF
1231 }
1232 iNdEx += skippy
1233 }
1234 }
1235
1236 if iNdEx > l {
1237 return io.ErrUnexpectedEOF
1238 }
1239 return nil
1240}
1241func (m *VolumeAttachment) Unmarshal(dAtA []byte) error {
1242 l := len(dAtA)
1243 iNdEx := 0
1244 for iNdEx < l {
1245 preIndex := iNdEx
1246 var wire uint64
1247 for shift := uint(0); ; shift += 7 {
1248 if shift >= 64 {
1249 return ErrIntOverflowGenerated
1250 }
1251 if iNdEx >= l {
1252 return io.ErrUnexpectedEOF
1253 }
1254 b := dAtA[iNdEx]
1255 iNdEx++
1256 wire |= (uint64(b) & 0x7F) << shift
1257 if b < 0x80 {
1258 break
1259 }
1260 }
1261 fieldNum := int32(wire >> 3)
1262 wireType := int(wire & 0x7)
1263 if wireType == 4 {
1264 return fmt.Errorf("proto: VolumeAttachment: wiretype end group for non-group")
1265 }
1266 if fieldNum <= 0 {
1267 return fmt.Errorf("proto: VolumeAttachment: illegal tag %d (wire type %d)", fieldNum, wire)
1268 }
1269 switch fieldNum {
1270 case 1:
1271 if wireType != 2 {
1272 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
1273 }
1274 var msglen int
1275 for shift := uint(0); ; shift += 7 {
1276 if shift >= 64 {
1277 return ErrIntOverflowGenerated
1278 }
1279 if iNdEx >= l {
1280 return io.ErrUnexpectedEOF
1281 }
1282 b := dAtA[iNdEx]
1283 iNdEx++
1284 msglen |= (int(b) & 0x7F) << shift
1285 if b < 0x80 {
1286 break
1287 }
1288 }
1289 if msglen < 0 {
1290 return ErrInvalidLengthGenerated
1291 }
1292 postIndex := iNdEx + msglen
1293 if postIndex > l {
1294 return io.ErrUnexpectedEOF
1295 }
1296 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1297 return err
1298 }
1299 iNdEx = postIndex
1300 case 2:
1301 if wireType != 2 {
1302 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
1303 }
1304 var msglen int
1305 for shift := uint(0); ; shift += 7 {
1306 if shift >= 64 {
1307 return ErrIntOverflowGenerated
1308 }
1309 if iNdEx >= l {
1310 return io.ErrUnexpectedEOF
1311 }
1312 b := dAtA[iNdEx]
1313 iNdEx++
1314 msglen |= (int(b) & 0x7F) << shift
1315 if b < 0x80 {
1316 break
1317 }
1318 }
1319 if msglen < 0 {
1320 return ErrInvalidLengthGenerated
1321 }
1322 postIndex := iNdEx + msglen
1323 if postIndex > l {
1324 return io.ErrUnexpectedEOF
1325 }
1326 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1327 return err
1328 }
1329 iNdEx = postIndex
1330 case 3:
1331 if wireType != 2 {
1332 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
1333 }
1334 var msglen int
1335 for shift := uint(0); ; shift += 7 {
1336 if shift >= 64 {
1337 return ErrIntOverflowGenerated
1338 }
1339 if iNdEx >= l {
1340 return io.ErrUnexpectedEOF
1341 }
1342 b := dAtA[iNdEx]
1343 iNdEx++
1344 msglen |= (int(b) & 0x7F) << shift
1345 if b < 0x80 {
1346 break
1347 }
1348 }
1349 if msglen < 0 {
1350 return ErrInvalidLengthGenerated
1351 }
1352 postIndex := iNdEx + msglen
1353 if postIndex > l {
1354 return io.ErrUnexpectedEOF
1355 }
1356 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1357 return err
1358 }
1359 iNdEx = postIndex
1360 default:
1361 iNdEx = preIndex
1362 skippy, err := skipGenerated(dAtA[iNdEx:])
1363 if err != nil {
1364 return err
1365 }
1366 if skippy < 0 {
1367 return ErrInvalidLengthGenerated
1368 }
1369 if (iNdEx + skippy) > l {
1370 return io.ErrUnexpectedEOF
1371 }
1372 iNdEx += skippy
1373 }
1374 }
1375
1376 if iNdEx > l {
1377 return io.ErrUnexpectedEOF
1378 }
1379 return nil
1380}
1381func (m *VolumeAttachmentList) Unmarshal(dAtA []byte) error {
1382 l := len(dAtA)
1383 iNdEx := 0
1384 for iNdEx < l {
1385 preIndex := iNdEx
1386 var wire uint64
1387 for shift := uint(0); ; shift += 7 {
1388 if shift >= 64 {
1389 return ErrIntOverflowGenerated
1390 }
1391 if iNdEx >= l {
1392 return io.ErrUnexpectedEOF
1393 }
1394 b := dAtA[iNdEx]
1395 iNdEx++
1396 wire |= (uint64(b) & 0x7F) << shift
1397 if b < 0x80 {
1398 break
1399 }
1400 }
1401 fieldNum := int32(wire >> 3)
1402 wireType := int(wire & 0x7)
1403 if wireType == 4 {
1404 return fmt.Errorf("proto: VolumeAttachmentList: wiretype end group for non-group")
1405 }
1406 if fieldNum <= 0 {
1407 return fmt.Errorf("proto: VolumeAttachmentList: illegal tag %d (wire type %d)", fieldNum, wire)
1408 }
1409 switch fieldNum {
1410 case 1:
1411 if wireType != 2 {
1412 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1413 }
1414 var msglen int
1415 for shift := uint(0); ; shift += 7 {
1416 if shift >= 64 {
1417 return ErrIntOverflowGenerated
1418 }
1419 if iNdEx >= l {
1420 return io.ErrUnexpectedEOF
1421 }
1422 b := dAtA[iNdEx]
1423 iNdEx++
1424 msglen |= (int(b) & 0x7F) << shift
1425 if b < 0x80 {
1426 break
1427 }
1428 }
1429 if msglen < 0 {
1430 return ErrInvalidLengthGenerated
1431 }
1432 postIndex := iNdEx + msglen
1433 if postIndex > l {
1434 return io.ErrUnexpectedEOF
1435 }
1436 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1437 return err
1438 }
1439 iNdEx = postIndex
1440 case 2:
1441 if wireType != 2 {
1442 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1443 }
1444 var msglen int
1445 for shift := uint(0); ; shift += 7 {
1446 if shift >= 64 {
1447 return ErrIntOverflowGenerated
1448 }
1449 if iNdEx >= l {
1450 return io.ErrUnexpectedEOF
1451 }
1452 b := dAtA[iNdEx]
1453 iNdEx++
1454 msglen |= (int(b) & 0x7F) << shift
1455 if b < 0x80 {
1456 break
1457 }
1458 }
1459 if msglen < 0 {
1460 return ErrInvalidLengthGenerated
1461 }
1462 postIndex := iNdEx + msglen
1463 if postIndex > l {
1464 return io.ErrUnexpectedEOF
1465 }
1466 m.Items = append(m.Items, VolumeAttachment{})
1467 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1468 return err
1469 }
1470 iNdEx = postIndex
1471 default:
1472 iNdEx = preIndex
1473 skippy, err := skipGenerated(dAtA[iNdEx:])
1474 if err != nil {
1475 return err
1476 }
1477 if skippy < 0 {
1478 return ErrInvalidLengthGenerated
1479 }
1480 if (iNdEx + skippy) > l {
1481 return io.ErrUnexpectedEOF
1482 }
1483 iNdEx += skippy
1484 }
1485 }
1486
1487 if iNdEx > l {
1488 return io.ErrUnexpectedEOF
1489 }
1490 return nil
1491}
1492func (m *VolumeAttachmentSource) Unmarshal(dAtA []byte) error {
1493 l := len(dAtA)
1494 iNdEx := 0
1495 for iNdEx < l {
1496 preIndex := iNdEx
1497 var wire uint64
1498 for shift := uint(0); ; shift += 7 {
1499 if shift >= 64 {
1500 return ErrIntOverflowGenerated
1501 }
1502 if iNdEx >= l {
1503 return io.ErrUnexpectedEOF
1504 }
1505 b := dAtA[iNdEx]
1506 iNdEx++
1507 wire |= (uint64(b) & 0x7F) << shift
1508 if b < 0x80 {
1509 break
1510 }
1511 }
1512 fieldNum := int32(wire >> 3)
1513 wireType := int(wire & 0x7)
1514 if wireType == 4 {
1515 return fmt.Errorf("proto: VolumeAttachmentSource: wiretype end group for non-group")
1516 }
1517 if fieldNum <= 0 {
1518 return fmt.Errorf("proto: VolumeAttachmentSource: illegal tag %d (wire type %d)", fieldNum, wire)
1519 }
1520 switch fieldNum {
1521 case 1:
1522 if wireType != 2 {
1523 return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeName", wireType)
1524 }
1525 var stringLen uint64
1526 for shift := uint(0); ; shift += 7 {
1527 if shift >= 64 {
1528 return ErrIntOverflowGenerated
1529 }
1530 if iNdEx >= l {
1531 return io.ErrUnexpectedEOF
1532 }
1533 b := dAtA[iNdEx]
1534 iNdEx++
1535 stringLen |= (uint64(b) & 0x7F) << shift
1536 if b < 0x80 {
1537 break
1538 }
1539 }
1540 intStringLen := int(stringLen)
1541 if intStringLen < 0 {
1542 return ErrInvalidLengthGenerated
1543 }
1544 postIndex := iNdEx + intStringLen
1545 if postIndex > l {
1546 return io.ErrUnexpectedEOF
1547 }
1548 s := string(dAtA[iNdEx:postIndex])
1549 m.PersistentVolumeName = &s
1550 iNdEx = postIndex
1551 default:
1552 iNdEx = preIndex
1553 skippy, err := skipGenerated(dAtA[iNdEx:])
1554 if err != nil {
1555 return err
1556 }
1557 if skippy < 0 {
1558 return ErrInvalidLengthGenerated
1559 }
1560 if (iNdEx + skippy) > l {
1561 return io.ErrUnexpectedEOF
1562 }
1563 iNdEx += skippy
1564 }
1565 }
1566
1567 if iNdEx > l {
1568 return io.ErrUnexpectedEOF
1569 }
1570 return nil
1571}
1572func (m *VolumeAttachmentSpec) Unmarshal(dAtA []byte) error {
1573 l := len(dAtA)
1574 iNdEx := 0
1575 for iNdEx < l {
1576 preIndex := iNdEx
1577 var wire uint64
1578 for shift := uint(0); ; shift += 7 {
1579 if shift >= 64 {
1580 return ErrIntOverflowGenerated
1581 }
1582 if iNdEx >= l {
1583 return io.ErrUnexpectedEOF
1584 }
1585 b := dAtA[iNdEx]
1586 iNdEx++
1587 wire |= (uint64(b) & 0x7F) << shift
1588 if b < 0x80 {
1589 break
1590 }
1591 }
1592 fieldNum := int32(wire >> 3)
1593 wireType := int(wire & 0x7)
1594 if wireType == 4 {
1595 return fmt.Errorf("proto: VolumeAttachmentSpec: wiretype end group for non-group")
1596 }
1597 if fieldNum <= 0 {
1598 return fmt.Errorf("proto: VolumeAttachmentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1599 }
1600 switch fieldNum {
1601 case 1:
1602 if wireType != 2 {
1603 return fmt.Errorf("proto: wrong wireType = %d for field Attacher", wireType)
1604 }
1605 var stringLen uint64
1606 for shift := uint(0); ; shift += 7 {
1607 if shift >= 64 {
1608 return ErrIntOverflowGenerated
1609 }
1610 if iNdEx >= l {
1611 return io.ErrUnexpectedEOF
1612 }
1613 b := dAtA[iNdEx]
1614 iNdEx++
1615 stringLen |= (uint64(b) & 0x7F) << shift
1616 if b < 0x80 {
1617 break
1618 }
1619 }
1620 intStringLen := int(stringLen)
1621 if intStringLen < 0 {
1622 return ErrInvalidLengthGenerated
1623 }
1624 postIndex := iNdEx + intStringLen
1625 if postIndex > l {
1626 return io.ErrUnexpectedEOF
1627 }
1628 m.Attacher = string(dAtA[iNdEx:postIndex])
1629 iNdEx = postIndex
1630 case 2:
1631 if wireType != 2 {
1632 return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
1633 }
1634 var msglen int
1635 for shift := uint(0); ; shift += 7 {
1636 if shift >= 64 {
1637 return ErrIntOverflowGenerated
1638 }
1639 if iNdEx >= l {
1640 return io.ErrUnexpectedEOF
1641 }
1642 b := dAtA[iNdEx]
1643 iNdEx++
1644 msglen |= (int(b) & 0x7F) << shift
1645 if b < 0x80 {
1646 break
1647 }
1648 }
1649 if msglen < 0 {
1650 return ErrInvalidLengthGenerated
1651 }
1652 postIndex := iNdEx + msglen
1653 if postIndex > l {
1654 return io.ErrUnexpectedEOF
1655 }
1656 if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1657 return err
1658 }
1659 iNdEx = postIndex
1660 case 3:
1661 if wireType != 2 {
1662 return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
1663 }
1664 var stringLen uint64
1665 for shift := uint(0); ; shift += 7 {
1666 if shift >= 64 {
1667 return ErrIntOverflowGenerated
1668 }
1669 if iNdEx >= l {
1670 return io.ErrUnexpectedEOF
1671 }
1672 b := dAtA[iNdEx]
1673 iNdEx++
1674 stringLen |= (uint64(b) & 0x7F) << shift
1675 if b < 0x80 {
1676 break
1677 }
1678 }
1679 intStringLen := int(stringLen)
1680 if intStringLen < 0 {
1681 return ErrInvalidLengthGenerated
1682 }
1683 postIndex := iNdEx + intStringLen
1684 if postIndex > l {
1685 return io.ErrUnexpectedEOF
1686 }
1687 m.NodeName = string(dAtA[iNdEx:postIndex])
1688 iNdEx = postIndex
1689 default:
1690 iNdEx = preIndex
1691 skippy, err := skipGenerated(dAtA[iNdEx:])
1692 if err != nil {
1693 return err
1694 }
1695 if skippy < 0 {
1696 return ErrInvalidLengthGenerated
1697 }
1698 if (iNdEx + skippy) > l {
1699 return io.ErrUnexpectedEOF
1700 }
1701 iNdEx += skippy
1702 }
1703 }
1704
1705 if iNdEx > l {
1706 return io.ErrUnexpectedEOF
1707 }
1708 return nil
1709}
1710func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
1711 l := len(dAtA)
1712 iNdEx := 0
1713 for iNdEx < l {
1714 preIndex := iNdEx
1715 var wire uint64
1716 for shift := uint(0); ; shift += 7 {
1717 if shift >= 64 {
1718 return ErrIntOverflowGenerated
1719 }
1720 if iNdEx >= l {
1721 return io.ErrUnexpectedEOF
1722 }
1723 b := dAtA[iNdEx]
1724 iNdEx++
1725 wire |= (uint64(b) & 0x7F) << shift
1726 if b < 0x80 {
1727 break
1728 }
1729 }
1730 fieldNum := int32(wire >> 3)
1731 wireType := int(wire & 0x7)
1732 if wireType == 4 {
1733 return fmt.Errorf("proto: VolumeAttachmentStatus: wiretype end group for non-group")
1734 }
1735 if fieldNum <= 0 {
1736 return fmt.Errorf("proto: VolumeAttachmentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1737 }
1738 switch fieldNum {
1739 case 1:
1740 if wireType != 0 {
1741 return fmt.Errorf("proto: wrong wireType = %d for field Attached", wireType)
1742 }
1743 var v int
1744 for shift := uint(0); ; shift += 7 {
1745 if shift >= 64 {
1746 return ErrIntOverflowGenerated
1747 }
1748 if iNdEx >= l {
1749 return io.ErrUnexpectedEOF
1750 }
1751 b := dAtA[iNdEx]
1752 iNdEx++
1753 v |= (int(b) & 0x7F) << shift
1754 if b < 0x80 {
1755 break
1756 }
1757 }
1758 m.Attached = bool(v != 0)
1759 case 2:
1760 if wireType != 2 {
1761 return fmt.Errorf("proto: wrong wireType = %d for field AttachmentMetadata", wireType)
1762 }
1763 var msglen int
1764 for shift := uint(0); ; shift += 7 {
1765 if shift >= 64 {
1766 return ErrIntOverflowGenerated
1767 }
1768 if iNdEx >= l {
1769 return io.ErrUnexpectedEOF
1770 }
1771 b := dAtA[iNdEx]
1772 iNdEx++
1773 msglen |= (int(b) & 0x7F) << shift
1774 if b < 0x80 {
1775 break
1776 }
1777 }
1778 if msglen < 0 {
1779 return ErrInvalidLengthGenerated
1780 }
1781 postIndex := iNdEx + msglen
1782 if postIndex > l {
1783 return io.ErrUnexpectedEOF
1784 }
1785 if m.AttachmentMetadata == nil {
1786 m.AttachmentMetadata = make(map[string]string)
1787 }
1788 var mapkey string
1789 var mapvalue string
1790 for iNdEx < postIndex {
1791 entryPreIndex := iNdEx
1792 var wire uint64
1793 for shift := uint(0); ; shift += 7 {
1794 if shift >= 64 {
1795 return ErrIntOverflowGenerated
1796 }
1797 if iNdEx >= l {
1798 return io.ErrUnexpectedEOF
1799 }
1800 b := dAtA[iNdEx]
1801 iNdEx++
1802 wire |= (uint64(b) & 0x7F) << shift
1803 if b < 0x80 {
1804 break
1805 }
1806 }
1807 fieldNum := int32(wire >> 3)
1808 if fieldNum == 1 {
1809 var stringLenmapkey uint64
1810 for shift := uint(0); ; shift += 7 {
1811 if shift >= 64 {
1812 return ErrIntOverflowGenerated
1813 }
1814 if iNdEx >= l {
1815 return io.ErrUnexpectedEOF
1816 }
1817 b := dAtA[iNdEx]
1818 iNdEx++
1819 stringLenmapkey |= (uint64(b) & 0x7F) << shift
1820 if b < 0x80 {
1821 break
1822 }
1823 }
1824 intStringLenmapkey := int(stringLenmapkey)
1825 if intStringLenmapkey < 0 {
1826 return ErrInvalidLengthGenerated
1827 }
1828 postStringIndexmapkey := iNdEx + intStringLenmapkey
1829 if postStringIndexmapkey > l {
1830 return io.ErrUnexpectedEOF
1831 }
1832 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1833 iNdEx = postStringIndexmapkey
1834 } else if fieldNum == 2 {
1835 var stringLenmapvalue uint64
1836 for shift := uint(0); ; shift += 7 {
1837 if shift >= 64 {
1838 return ErrIntOverflowGenerated
1839 }
1840 if iNdEx >= l {
1841 return io.ErrUnexpectedEOF
1842 }
1843 b := dAtA[iNdEx]
1844 iNdEx++
1845 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
1846 if b < 0x80 {
1847 break
1848 }
1849 }
1850 intStringLenmapvalue := int(stringLenmapvalue)
1851 if intStringLenmapvalue < 0 {
1852 return ErrInvalidLengthGenerated
1853 }
1854 postStringIndexmapvalue := iNdEx + intStringLenmapvalue
1855 if postStringIndexmapvalue > l {
1856 return io.ErrUnexpectedEOF
1857 }
1858 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
1859 iNdEx = postStringIndexmapvalue
1860 } else {
1861 iNdEx = entryPreIndex
1862 skippy, err := skipGenerated(dAtA[iNdEx:])
1863 if err != nil {
1864 return err
1865 }
1866 if skippy < 0 {
1867 return ErrInvalidLengthGenerated
1868 }
1869 if (iNdEx + skippy) > postIndex {
1870 return io.ErrUnexpectedEOF
1871 }
1872 iNdEx += skippy
1873 }
1874 }
1875 m.AttachmentMetadata[mapkey] = mapvalue
1876 iNdEx = postIndex
1877 case 3:
1878 if wireType != 2 {
1879 return fmt.Errorf("proto: wrong wireType = %d for field AttachError", wireType)
1880 }
1881 var msglen int
1882 for shift := uint(0); ; shift += 7 {
1883 if shift >= 64 {
1884 return ErrIntOverflowGenerated
1885 }
1886 if iNdEx >= l {
1887 return io.ErrUnexpectedEOF
1888 }
1889 b := dAtA[iNdEx]
1890 iNdEx++
1891 msglen |= (int(b) & 0x7F) << shift
1892 if b < 0x80 {
1893 break
1894 }
1895 }
1896 if msglen < 0 {
1897 return ErrInvalidLengthGenerated
1898 }
1899 postIndex := iNdEx + msglen
1900 if postIndex > l {
1901 return io.ErrUnexpectedEOF
1902 }
1903 if m.AttachError == nil {
1904 m.AttachError = &VolumeError{}
1905 }
1906 if err := m.AttachError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1907 return err
1908 }
1909 iNdEx = postIndex
1910 case 4:
1911 if wireType != 2 {
1912 return fmt.Errorf("proto: wrong wireType = %d for field DetachError", wireType)
1913 }
1914 var msglen int
1915 for shift := uint(0); ; shift += 7 {
1916 if shift >= 64 {
1917 return ErrIntOverflowGenerated
1918 }
1919 if iNdEx >= l {
1920 return io.ErrUnexpectedEOF
1921 }
1922 b := dAtA[iNdEx]
1923 iNdEx++
1924 msglen |= (int(b) & 0x7F) << shift
1925 if b < 0x80 {
1926 break
1927 }
1928 }
1929 if msglen < 0 {
1930 return ErrInvalidLengthGenerated
1931 }
1932 postIndex := iNdEx + msglen
1933 if postIndex > l {
1934 return io.ErrUnexpectedEOF
1935 }
1936 if m.DetachError == nil {
1937 m.DetachError = &VolumeError{}
1938 }
1939 if err := m.DetachError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1940 return err
1941 }
1942 iNdEx = postIndex
1943 default:
1944 iNdEx = preIndex
1945 skippy, err := skipGenerated(dAtA[iNdEx:])
1946 if err != nil {
1947 return err
1948 }
1949 if skippy < 0 {
1950 return ErrInvalidLengthGenerated
1951 }
1952 if (iNdEx + skippy) > l {
1953 return io.ErrUnexpectedEOF
1954 }
1955 iNdEx += skippy
1956 }
1957 }
1958
1959 if iNdEx > l {
1960 return io.ErrUnexpectedEOF
1961 }
1962 return nil
1963}
1964func (m *VolumeError) Unmarshal(dAtA []byte) error {
1965 l := len(dAtA)
1966 iNdEx := 0
1967 for iNdEx < l {
1968 preIndex := iNdEx
1969 var wire uint64
1970 for shift := uint(0); ; shift += 7 {
1971 if shift >= 64 {
1972 return ErrIntOverflowGenerated
1973 }
1974 if iNdEx >= l {
1975 return io.ErrUnexpectedEOF
1976 }
1977 b := dAtA[iNdEx]
1978 iNdEx++
1979 wire |= (uint64(b) & 0x7F) << shift
1980 if b < 0x80 {
1981 break
1982 }
1983 }
1984 fieldNum := int32(wire >> 3)
1985 wireType := int(wire & 0x7)
1986 if wireType == 4 {
1987 return fmt.Errorf("proto: VolumeError: wiretype end group for non-group")
1988 }
1989 if fieldNum <= 0 {
1990 return fmt.Errorf("proto: VolumeError: illegal tag %d (wire type %d)", fieldNum, wire)
1991 }
1992 switch fieldNum {
1993 case 1:
1994 if wireType != 2 {
1995 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
1996 }
1997 var msglen int
1998 for shift := uint(0); ; shift += 7 {
1999 if shift >= 64 {
2000 return ErrIntOverflowGenerated
2001 }
2002 if iNdEx >= l {
2003 return io.ErrUnexpectedEOF
2004 }
2005 b := dAtA[iNdEx]
2006 iNdEx++
2007 msglen |= (int(b) & 0x7F) << shift
2008 if b < 0x80 {
2009 break
2010 }
2011 }
2012 if msglen < 0 {
2013 return ErrInvalidLengthGenerated
2014 }
2015 postIndex := iNdEx + msglen
2016 if postIndex > l {
2017 return io.ErrUnexpectedEOF
2018 }
2019 if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2020 return err
2021 }
2022 iNdEx = postIndex
2023 case 2:
2024 if wireType != 2 {
2025 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
2026 }
2027 var stringLen uint64
2028 for shift := uint(0); ; shift += 7 {
2029 if shift >= 64 {
2030 return ErrIntOverflowGenerated
2031 }
2032 if iNdEx >= l {
2033 return io.ErrUnexpectedEOF
2034 }
2035 b := dAtA[iNdEx]
2036 iNdEx++
2037 stringLen |= (uint64(b) & 0x7F) << shift
2038 if b < 0x80 {
2039 break
2040 }
2041 }
2042 intStringLen := int(stringLen)
2043 if intStringLen < 0 {
2044 return ErrInvalidLengthGenerated
2045 }
2046 postIndex := iNdEx + intStringLen
2047 if postIndex > l {
2048 return io.ErrUnexpectedEOF
2049 }
2050 m.Message = string(dAtA[iNdEx:postIndex])
2051 iNdEx = postIndex
2052 default:
2053 iNdEx = preIndex
2054 skippy, err := skipGenerated(dAtA[iNdEx:])
2055 if err != nil {
2056 return err
2057 }
2058 if skippy < 0 {
2059 return ErrInvalidLengthGenerated
2060 }
2061 if (iNdEx + skippy) > l {
2062 return io.ErrUnexpectedEOF
2063 }
2064 iNdEx += skippy
2065 }
2066 }
2067
2068 if iNdEx > l {
2069 return io.ErrUnexpectedEOF
2070 }
2071 return nil
2072}
2073func skipGenerated(dAtA []byte) (n int, err error) {
2074 l := len(dAtA)
2075 iNdEx := 0
2076 for iNdEx < l {
2077 var wire uint64
2078 for shift := uint(0); ; shift += 7 {
2079 if shift >= 64 {
2080 return 0, ErrIntOverflowGenerated
2081 }
2082 if iNdEx >= l {
2083 return 0, io.ErrUnexpectedEOF
2084 }
2085 b := dAtA[iNdEx]
2086 iNdEx++
2087 wire |= (uint64(b) & 0x7F) << shift
2088 if b < 0x80 {
2089 break
2090 }
2091 }
2092 wireType := int(wire & 0x7)
2093 switch wireType {
2094 case 0:
2095 for shift := uint(0); ; shift += 7 {
2096 if shift >= 64 {
2097 return 0, ErrIntOverflowGenerated
2098 }
2099 if iNdEx >= l {
2100 return 0, io.ErrUnexpectedEOF
2101 }
2102 iNdEx++
2103 if dAtA[iNdEx-1] < 0x80 {
2104 break
2105 }
2106 }
2107 return iNdEx, nil
2108 case 1:
2109 iNdEx += 8
2110 return iNdEx, nil
2111 case 2:
2112 var length int
2113 for shift := uint(0); ; shift += 7 {
2114 if shift >= 64 {
2115 return 0, ErrIntOverflowGenerated
2116 }
2117 if iNdEx >= l {
2118 return 0, io.ErrUnexpectedEOF
2119 }
2120 b := dAtA[iNdEx]
2121 iNdEx++
2122 length |= (int(b) & 0x7F) << shift
2123 if b < 0x80 {
2124 break
2125 }
2126 }
2127 iNdEx += length
2128 if length < 0 {
2129 return 0, ErrInvalidLengthGenerated
2130 }
2131 return iNdEx, nil
2132 case 3:
2133 for {
2134 var innerWire uint64
2135 var start int = iNdEx
2136 for shift := uint(0); ; shift += 7 {
2137 if shift >= 64 {
2138 return 0, ErrIntOverflowGenerated
2139 }
2140 if iNdEx >= l {
2141 return 0, io.ErrUnexpectedEOF
2142 }
2143 b := dAtA[iNdEx]
2144 iNdEx++
2145 innerWire |= (uint64(b) & 0x7F) << shift
2146 if b < 0x80 {
2147 break
2148 }
2149 }
2150 innerWireType := int(innerWire & 0x7)
2151 if innerWireType == 4 {
2152 break
2153 }
2154 next, err := skipGenerated(dAtA[start:])
2155 if err != nil {
2156 return 0, err
2157 }
2158 iNdEx = start + next
2159 }
2160 return iNdEx, nil
2161 case 4:
2162 return iNdEx, nil
2163 case 5:
2164 iNdEx += 4
2165 return iNdEx, nil
2166 default:
2167 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
2168 }
2169 }
2170 panic("unreachable")
2171}
2172
2173var (
2174 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
2175 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
2176)
2177
2178func init() {
2179 proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/storage/v1beta1/generated.proto", fileDescriptorGenerated)
2180}
2181
2182var fileDescriptorGenerated = []byte{
2183 // 988 bytes of a gzipped FileDescriptorProto
2184 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4d, 0x6f, 0x1b, 0x45,
2185 0x18, 0xce, 0xc6, 0xf9, 0x70, 0xc6, 0x09, 0x4d, 0x86, 0x08, 0x8c, 0x0f, 0x76, 0xe4, 0x0b, 0xa6,
2186 0x6a, 0x77, 0x9b, 0xa8, 0xa0, 0x08, 0x89, 0x83, 0xb7, 0xe4, 0x00, 0x8a, 0xdb, 0x30, 0x89, 0x2a,
2187 0x54, 0x71, 0x60, 0xb2, 0xfb, 0x76, 0xb3, 0x78, 0x77, 0x67, 0x99, 0x19, 0x1b, 0x72, 0xe3, 0xc4,
2188 0x19, 0x71, 0xe0, 0x17, 0xf0, 0x3f, 0x38, 0x92, 0x13, 0xea, 0xb1, 0x27, 0x8b, 0x2c, 0xff, 0x22,
2189 0xe2, 0x80, 0x66, 0x76, 0x62, 0xaf, 0xbd, 0x0e, 0x6d, 0x7a, 0xe8, 0xcd, 0xef, 0xc7, 0xf3, 0xbc,
2190 0xdf, 0xb3, 0x46, 0x8f, 0xfa, 0xfb, 0xc2, 0x0e, 0x99, 0xd3, 0x1f, 0x9c, 0x02, 0x4f, 0x40, 0x82,
2191 0x70, 0x86, 0x90, 0xf8, 0x8c, 0x3b, 0xc6, 0x40, 0xd3, 0xd0, 0x11, 0x92, 0x71, 0x1a, 0x80, 0x33,
2192 0xdc, 0x3d, 0x05, 0x49, 0x77, 0x9d, 0x00, 0x12, 0xe0, 0x54, 0x82, 0x6f, 0xa7, 0x9c, 0x49, 0x86,
2193 0x1b, 0xb9, 0xaf, 0x4d, 0xd3, 0xd0, 0x36, 0xbe, 0xb6, 0xf1, 0x6d, 0xdc, 0x0f, 0x42, 0x79, 0x36,
2194 0x38, 0xb5, 0x3d, 0x16, 0x3b, 0x01, 0x0b, 0x98, 0xa3, 0x21, 0xa7, 0x83, 0xe7, 0x5a, 0xd2, 0x82,
2195 0xfe, 0x95, 0x53, 0x35, 0xda, 0x85, 0xb0, 0x1e, 0xe3, 0x2a, 0xe6, 0x6c, 0xb8, 0xc6, 0xc3, 0x89,
2196 0x4f, 0x4c, 0xbd, 0xb3, 0x30, 0x01, 0x7e, 0xee, 0xa4, 0xfd, 0x40, 0x29, 0x84, 0x13, 0x83, 0xa4,
2197 0xf3, 0x50, 0xce, 0x4d, 0x28, 0x3e, 0x48, 0x64, 0x18, 0x43, 0x09, 0xf0, 0xc9, 0xab, 0x00, 0xc2,
2198 0x3b, 0x83, 0x98, 0xce, 0xe2, 0xda, 0xbf, 0xae, 0xa0, 0xf5, 0xe3, 0xbc, 0x0b, 0x8f, 0x22, 0x2a,
2199 0x04, 0xfe, 0x16, 0x55, 0x55, 0x52, 0x3e, 0x95, 0xb4, 0x6e, 0xed, 0x58, 0x9d, 0xda, 0xde, 0x03,
2200 0x7b, 0xd2, 0xb1, 0x31, 0xb7, 0x9d, 0xf6, 0x03, 0xa5, 0x10, 0xb6, 0xf2, 0xb6, 0x87, 0xbb, 0xf6,
2201 0x93, 0xd3, 0xef, 0xc0, 0x93, 0x3d, 0x90, 0xd4, 0xc5, 0x17, 0xa3, 0xd6, 0x42, 0x36, 0x6a, 0xa1,
2202 0x89, 0x8e, 0x8c, 0x59, 0xf1, 0xc7, 0xa8, 0x96, 0x72, 0x36, 0x0c, 0x45, 0xc8, 0x12, 0xe0, 0xf5,
2203 0xc5, 0x1d, 0xab, 0xb3, 0xe6, 0xbe, 0x6b, 0x20, 0xb5, 0xa3, 0x89, 0x89, 0x14, 0xfd, 0x70, 0x84,
2204 0x50, 0x4a, 0x39, 0x8d, 0x41, 0x02, 0x17, 0xf5, 0xca, 0x4e, 0xa5, 0x53, 0xdb, 0xdb, 0xb7, 0x6f,
2205 0x1e, 0xa6, 0x5d, 0x2c, 0xcb, 0x3e, 0x1a, 0x43, 0x0f, 0x12, 0xc9, 0xcf, 0x27, 0x29, 0x4e, 0x0c,
2206 0xa4, 0xc0, 0x8f, 0xfb, 0x68, 0x83, 0x83, 0x17, 0xd1, 0x30, 0x3e, 0x62, 0x51, 0xe8, 0x9d, 0xd7,
2207 0x97, 0x74, 0x9a, 0x07, 0xd9, 0xa8, 0xb5, 0x41, 0x8a, 0x86, 0xab, 0x51, 0xeb, 0x41, 0x79, 0x0d,
2208 0xec, 0x23, 0xe0, 0x22, 0x14, 0x12, 0x12, 0xf9, 0x94, 0x45, 0x83, 0x18, 0xa6, 0x30, 0x64, 0x9a,
2209 0x1b, 0x3f, 0x44, 0xeb, 0x31, 0x1b, 0x24, 0xf2, 0x49, 0x2a, 0x43, 0x96, 0x88, 0xfa, 0xf2, 0x4e,
2210 0xa5, 0xb3, 0xe6, 0x6e, 0x66, 0xa3, 0xd6, 0x7a, 0xaf, 0xa0, 0x27, 0x53, 0x5e, 0xf8, 0x10, 0x6d,
2211 0xd3, 0x28, 0x62, 0x3f, 0xe4, 0x01, 0x0e, 0x7e, 0x4c, 0x69, 0xa2, 0x5a, 0x55, 0x5f, 0xd9, 0xb1,
2212 0x3a, 0x55, 0xb7, 0x9e, 0x8d, 0x5a, 0xdb, 0xdd, 0x39, 0x76, 0x32, 0x17, 0x85, 0xbf, 0x46, 0x5b,
2213 0x43, 0xad, 0x72, 0xc3, 0xc4, 0x0f, 0x93, 0xa0, 0xc7, 0x7c, 0xa8, 0xaf, 0xea, 0xa2, 0xef, 0x66,
2214 0xa3, 0xd6, 0xd6, 0xd3, 0x59, 0xe3, 0xd5, 0x3c, 0x25, 0x29, 0x93, 0xe0, 0xef, 0xd1, 0x96, 0x8e,
2215 0x08, 0xfe, 0x09, 0x4b, 0x59, 0xc4, 0x82, 0x10, 0x44, 0xbd, 0xaa, 0xe7, 0xd7, 0x29, 0xce, 0x4f,
2216 0xb5, 0x4e, 0x2d, 0x92, 0xf1, 0x3a, 0x3f, 0x86, 0x08, 0x3c, 0xc9, 0xf8, 0x09, 0xf0, 0xd8, 0xfd,
2217 0xc0, 0xcc, 0x6b, 0xab, 0x3b, 0x4b, 0x45, 0xca, 0xec, 0x8d, 0xcf, 0xd0, 0x9d, 0x99, 0x81, 0xe3,
2218 0x4d, 0x54, 0xe9, 0xc3, 0xb9, 0x5e, 0xe9, 0x35, 0xa2, 0x7e, 0xe2, 0x6d, 0xb4, 0x3c, 0xa4, 0xd1,
2219 0x00, 0xf2, 0x0d, 0x24, 0xb9, 0xf0, 0xe9, 0xe2, 0xbe, 0xd5, 0xfe, 0xc3, 0x42, 0x9b, 0xc5, 0xed,
2220 0x39, 0x0c, 0x85, 0xc4, 0xdf, 0x94, 0x0e, 0xc3, 0x7e, 0xbd, 0xc3, 0x50, 0x68, 0x7d, 0x16, 0x9b,
2221 0xa6, 0x86, 0xea, 0xb5, 0xa6, 0x70, 0x14, 0x3d, 0xb4, 0x1c, 0x4a, 0x88, 0x45, 0x7d, 0xb1, 0xdc,
2222 0x98, 0xff, 0x5b, 0x6c, 0x77, 0xc3, 0x90, 0x2e, 0x7f, 0xa1, 0xe0, 0x24, 0x67, 0x69, 0xff, 0xbe,
2223 0x88, 0x36, 0xf3, 0xe1, 0x74, 0xa5, 0xa4, 0xde, 0x59, 0x0c, 0x89, 0x7c, 0x0b, 0xa7, 0x4d, 0xd0,
2224 0x92, 0x48, 0xc1, 0xd3, 0x1d, 0x9d, 0x66, 0x2f, 0x15, 0x31, 0x9b, 0xdd, 0x71, 0x0a, 0x9e, 0xbb,
2225 0x6e, 0xd8, 0x97, 0x94, 0x44, 0x34, 0x17, 0x7e, 0x86, 0x56, 0x84, 0xa4, 0x72, 0xa0, 0x6e, 0x5e,
2226 0xb1, 0xee, 0xdd, 0x8a, 0x55, 0x23, 0xdd, 0x77, 0x0c, 0xef, 0x4a, 0x2e, 0x13, 0xc3, 0xd8, 0xfe,
2227 0xd3, 0x42, 0xdb, 0xb3, 0x90, 0xb7, 0x30, 0xec, 0xaf, 0xa6, 0x87, 0x7d, 0xef, 0x36, 0x15, 0xdd,
2228 0x30, 0xf0, 0xe7, 0xe8, 0xbd, 0x52, 0xed, 0x6c, 0xc0, 0x3d, 0x50, 0xcf, 0x44, 0x3a, 0xf3, 0x18,
2229 0x3d, 0xa6, 0x31, 0xe4, 0x97, 0x90, 0x3f, 0x13, 0x47, 0x73, 0xec, 0x64, 0x2e, 0xaa, 0xfd, 0xd7,
2230 0x9c, 0x8e, 0xa9, 0x61, 0xe1, 0x7b, 0xa8, 0x4a, 0xb5, 0x06, 0xb8, 0xa1, 0x1e, 0x77, 0xa0, 0x6b,
2231 0xf4, 0x64, 0xec, 0xa1, 0x87, 0xaa, 0xd3, 0x33, 0xab, 0x72, 0xbb, 0xa1, 0x6a, 0x64, 0x61, 0xa8,
2232 0x5a, 0x26, 0x86, 0x51, 0x65, 0x92, 0x30, 0x3f, 0x2f, 0xb2, 0x32, 0x9d, 0xc9, 0x63, 0xa3, 0x27,
2233 0x63, 0x8f, 0xf6, 0xbf, 0x95, 0x39, 0x9d, 0xd3, 0xdb, 0x51, 0x28, 0xc9, 0xd7, 0x25, 0x55, 0x4b,
2234 0x25, 0xf9, 0xe3, 0x92, 0x7c, 0xfc, 0x9b, 0x85, 0x30, 0x1d, 0x53, 0xf4, 0xae, 0xb7, 0x27, 0x1f,
2235 0xf1, 0x97, 0xb7, 0x5f, 0x5a, 0xbb, 0x5b, 0x22, 0xcb, 0x3f, 0x5d, 0x0d, 0x93, 0x04, 0x2e, 0x3b,
2236 0x90, 0x39, 0x19, 0xe0, 0x10, 0xd5, 0x72, 0xed, 0x01, 0xe7, 0x8c, 0x9b, 0x2b, 0xfa, 0xf0, 0xd5,
2237 0x09, 0x69, 0x77, 0xb7, 0xa9, 0x3e, 0xca, 0xdd, 0x09, 0xfe, 0x6a, 0xd4, 0xaa, 0x15, 0xec, 0xa4,
2238 0xc8, 0xad, 0x42, 0xf9, 0x30, 0x09, 0xb5, 0xf4, 0x06, 0xa1, 0x3e, 0x87, 0x9b, 0x43, 0x15, 0xb8,
2239 0x1b, 0x07, 0xe8, 0xfd, 0x1b, 0x1a, 0x74, 0xab, 0xa7, 0xfe, 0x67, 0x0b, 0x15, 0x63, 0xe0, 0x43,
2240 0xb4, 0xa4, 0xfe, 0x2e, 0x99, 0xa3, 0xbf, 0xfb, 0x7a, 0x47, 0x7f, 0x12, 0xc6, 0x30, 0x79, 0xbb,
2241 0x94, 0x44, 0x34, 0x0b, 0xfe, 0x08, 0xad, 0xc6, 0x20, 0x04, 0x0d, 0x4c, 0x64, 0xf7, 0x8e, 0x71,
2242 0x5a, 0xed, 0xe5, 0x6a, 0x72, 0x6d, 0x77, 0xef, 0x5f, 0x5c, 0x36, 0x17, 0x5e, 0x5c, 0x36, 0x17,
2243 0x5e, 0x5e, 0x36, 0x17, 0x7e, 0xca, 0x9a, 0xd6, 0x45, 0xd6, 0xb4, 0x5e, 0x64, 0x4d, 0xeb, 0x65,
2244 0xd6, 0xb4, 0xfe, 0xce, 0x9a, 0xd6, 0x2f, 0xff, 0x34, 0x17, 0x9e, 0xad, 0x9a, 0xbe, 0xfd, 0x17,
2245 0x00, 0x00, 0xff, 0xff, 0xb4, 0x63, 0x7e, 0xa7, 0x0b, 0x0b, 0x00, 0x00,
2246}