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