cmd/bpa-operator/vendor/k8s.io/api/storage/v1alpha1/generated.pb.go

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