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