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