Source file src/k8s.io/api/storage/v1alpha1/generated.pb.go

Documentation: k8s.io/api/storage/v1alpha1

     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/api/storage/v1alpha1/generated.proto
    19  
    20  package v1alpha1
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  
    27  	proto "github.com/gogo/protobuf/proto"
    28  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    29  	v11 "k8s.io/api/core/v1"
    30  	resource "k8s.io/apimachinery/pkg/api/resource"
    31  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    32  
    33  	math "math"
    34  	math_bits "math/bits"
    35  	reflect "reflect"
    36  	strings "strings"
    37  )
    38  
    39  // Reference imports to suppress errors if they are not otherwise used.
    40  var _ = proto.Marshal
    41  var _ = fmt.Errorf
    42  var _ = math.Inf
    43  
    44  // This is a compile-time assertion to ensure that this generated file
    45  // is compatible with the proto package it is being compiled against.
    46  // A compilation error at this line likely means your copy of the
    47  // proto package needs to be updated.
    48  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    49  
    50  func (m *CSIStorageCapacity) Reset()      { *m = CSIStorageCapacity{} }
    51  func (*CSIStorageCapacity) ProtoMessage() {}
    52  func (*CSIStorageCapacity) Descriptor() ([]byte, []int) {
    53  	return fileDescriptor_02e7952e43280c27, []int{0}
    54  }
    55  func (m *CSIStorageCapacity) XXX_Unmarshal(b []byte) error {
    56  	return m.Unmarshal(b)
    57  }
    58  func (m *CSIStorageCapacity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    59  	b = b[:cap(b)]
    60  	n, err := m.MarshalToSizedBuffer(b)
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	return b[:n], nil
    65  }
    66  func (m *CSIStorageCapacity) XXX_Merge(src proto.Message) {
    67  	xxx_messageInfo_CSIStorageCapacity.Merge(m, src)
    68  }
    69  func (m *CSIStorageCapacity) XXX_Size() int {
    70  	return m.Size()
    71  }
    72  func (m *CSIStorageCapacity) XXX_DiscardUnknown() {
    73  	xxx_messageInfo_CSIStorageCapacity.DiscardUnknown(m)
    74  }
    75  
    76  var xxx_messageInfo_CSIStorageCapacity proto.InternalMessageInfo
    77  
    78  func (m *CSIStorageCapacityList) Reset()      { *m = CSIStorageCapacityList{} }
    79  func (*CSIStorageCapacityList) ProtoMessage() {}
    80  func (*CSIStorageCapacityList) Descriptor() ([]byte, []int) {
    81  	return fileDescriptor_02e7952e43280c27, []int{1}
    82  }
    83  func (m *CSIStorageCapacityList) XXX_Unmarshal(b []byte) error {
    84  	return m.Unmarshal(b)
    85  }
    86  func (m *CSIStorageCapacityList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    87  	b = b[:cap(b)]
    88  	n, err := m.MarshalToSizedBuffer(b)
    89  	if err != nil {
    90  		return nil, err
    91  	}
    92  	return b[:n], nil
    93  }
    94  func (m *CSIStorageCapacityList) XXX_Merge(src proto.Message) {
    95  	xxx_messageInfo_CSIStorageCapacityList.Merge(m, src)
    96  }
    97  func (m *CSIStorageCapacityList) XXX_Size() int {
    98  	return m.Size()
    99  }
   100  func (m *CSIStorageCapacityList) XXX_DiscardUnknown() {
   101  	xxx_messageInfo_CSIStorageCapacityList.DiscardUnknown(m)
   102  }
   103  
   104  var xxx_messageInfo_CSIStorageCapacityList proto.InternalMessageInfo
   105  
   106  func (m *VolumeAttachment) Reset()      { *m = VolumeAttachment{} }
   107  func (*VolumeAttachment) ProtoMessage() {}
   108  func (*VolumeAttachment) Descriptor() ([]byte, []int) {
   109  	return fileDescriptor_02e7952e43280c27, []int{2}
   110  }
   111  func (m *VolumeAttachment) XXX_Unmarshal(b []byte) error {
   112  	return m.Unmarshal(b)
   113  }
   114  func (m *VolumeAttachment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   115  	b = b[:cap(b)]
   116  	n, err := m.MarshalToSizedBuffer(b)
   117  	if err != nil {
   118  		return nil, err
   119  	}
   120  	return b[:n], nil
   121  }
   122  func (m *VolumeAttachment) XXX_Merge(src proto.Message) {
   123  	xxx_messageInfo_VolumeAttachment.Merge(m, src)
   124  }
   125  func (m *VolumeAttachment) XXX_Size() int {
   126  	return m.Size()
   127  }
   128  func (m *VolumeAttachment) XXX_DiscardUnknown() {
   129  	xxx_messageInfo_VolumeAttachment.DiscardUnknown(m)
   130  }
   131  
   132  var xxx_messageInfo_VolumeAttachment proto.InternalMessageInfo
   133  
   134  func (m *VolumeAttachmentList) Reset()      { *m = VolumeAttachmentList{} }
   135  func (*VolumeAttachmentList) ProtoMessage() {}
   136  func (*VolumeAttachmentList) Descriptor() ([]byte, []int) {
   137  	return fileDescriptor_02e7952e43280c27, []int{3}
   138  }
   139  func (m *VolumeAttachmentList) XXX_Unmarshal(b []byte) error {
   140  	return m.Unmarshal(b)
   141  }
   142  func (m *VolumeAttachmentList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   143  	b = b[:cap(b)]
   144  	n, err := m.MarshalToSizedBuffer(b)
   145  	if err != nil {
   146  		return nil, err
   147  	}
   148  	return b[:n], nil
   149  }
   150  func (m *VolumeAttachmentList) XXX_Merge(src proto.Message) {
   151  	xxx_messageInfo_VolumeAttachmentList.Merge(m, src)
   152  }
   153  func (m *VolumeAttachmentList) XXX_Size() int {
   154  	return m.Size()
   155  }
   156  func (m *VolumeAttachmentList) XXX_DiscardUnknown() {
   157  	xxx_messageInfo_VolumeAttachmentList.DiscardUnknown(m)
   158  }
   159  
   160  var xxx_messageInfo_VolumeAttachmentList proto.InternalMessageInfo
   161  
   162  func (m *VolumeAttachmentSource) Reset()      { *m = VolumeAttachmentSource{} }
   163  func (*VolumeAttachmentSource) ProtoMessage() {}
   164  func (*VolumeAttachmentSource) Descriptor() ([]byte, []int) {
   165  	return fileDescriptor_02e7952e43280c27, []int{4}
   166  }
   167  func (m *VolumeAttachmentSource) XXX_Unmarshal(b []byte) error {
   168  	return m.Unmarshal(b)
   169  }
   170  func (m *VolumeAttachmentSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   171  	b = b[:cap(b)]
   172  	n, err := m.MarshalToSizedBuffer(b)
   173  	if err != nil {
   174  		return nil, err
   175  	}
   176  	return b[:n], nil
   177  }
   178  func (m *VolumeAttachmentSource) XXX_Merge(src proto.Message) {
   179  	xxx_messageInfo_VolumeAttachmentSource.Merge(m, src)
   180  }
   181  func (m *VolumeAttachmentSource) XXX_Size() int {
   182  	return m.Size()
   183  }
   184  func (m *VolumeAttachmentSource) XXX_DiscardUnknown() {
   185  	xxx_messageInfo_VolumeAttachmentSource.DiscardUnknown(m)
   186  }
   187  
   188  var xxx_messageInfo_VolumeAttachmentSource proto.InternalMessageInfo
   189  
   190  func (m *VolumeAttachmentSpec) Reset()      { *m = VolumeAttachmentSpec{} }
   191  func (*VolumeAttachmentSpec) ProtoMessage() {}
   192  func (*VolumeAttachmentSpec) Descriptor() ([]byte, []int) {
   193  	return fileDescriptor_02e7952e43280c27, []int{5}
   194  }
   195  func (m *VolumeAttachmentSpec) XXX_Unmarshal(b []byte) error {
   196  	return m.Unmarshal(b)
   197  }
   198  func (m *VolumeAttachmentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   199  	b = b[:cap(b)]
   200  	n, err := m.MarshalToSizedBuffer(b)
   201  	if err != nil {
   202  		return nil, err
   203  	}
   204  	return b[:n], nil
   205  }
   206  func (m *VolumeAttachmentSpec) XXX_Merge(src proto.Message) {
   207  	xxx_messageInfo_VolumeAttachmentSpec.Merge(m, src)
   208  }
   209  func (m *VolumeAttachmentSpec) XXX_Size() int {
   210  	return m.Size()
   211  }
   212  func (m *VolumeAttachmentSpec) XXX_DiscardUnknown() {
   213  	xxx_messageInfo_VolumeAttachmentSpec.DiscardUnknown(m)
   214  }
   215  
   216  var xxx_messageInfo_VolumeAttachmentSpec proto.InternalMessageInfo
   217  
   218  func (m *VolumeAttachmentStatus) Reset()      { *m = VolumeAttachmentStatus{} }
   219  func (*VolumeAttachmentStatus) ProtoMessage() {}
   220  func (*VolumeAttachmentStatus) Descriptor() ([]byte, []int) {
   221  	return fileDescriptor_02e7952e43280c27, []int{6}
   222  }
   223  func (m *VolumeAttachmentStatus) XXX_Unmarshal(b []byte) error {
   224  	return m.Unmarshal(b)
   225  }
   226  func (m *VolumeAttachmentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   227  	b = b[:cap(b)]
   228  	n, err := m.MarshalToSizedBuffer(b)
   229  	if err != nil {
   230  		return nil, err
   231  	}
   232  	return b[:n], nil
   233  }
   234  func (m *VolumeAttachmentStatus) XXX_Merge(src proto.Message) {
   235  	xxx_messageInfo_VolumeAttachmentStatus.Merge(m, src)
   236  }
   237  func (m *VolumeAttachmentStatus) XXX_Size() int {
   238  	return m.Size()
   239  }
   240  func (m *VolumeAttachmentStatus) XXX_DiscardUnknown() {
   241  	xxx_messageInfo_VolumeAttachmentStatus.DiscardUnknown(m)
   242  }
   243  
   244  var xxx_messageInfo_VolumeAttachmentStatus proto.InternalMessageInfo
   245  
   246  func (m *VolumeAttributesClass) Reset()      { *m = VolumeAttributesClass{} }
   247  func (*VolumeAttributesClass) ProtoMessage() {}
   248  func (*VolumeAttributesClass) Descriptor() ([]byte, []int) {
   249  	return fileDescriptor_02e7952e43280c27, []int{7}
   250  }
   251  func (m *VolumeAttributesClass) XXX_Unmarshal(b []byte) error {
   252  	return m.Unmarshal(b)
   253  }
   254  func (m *VolumeAttributesClass) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   255  	b = b[:cap(b)]
   256  	n, err := m.MarshalToSizedBuffer(b)
   257  	if err != nil {
   258  		return nil, err
   259  	}
   260  	return b[:n], nil
   261  }
   262  func (m *VolumeAttributesClass) XXX_Merge(src proto.Message) {
   263  	xxx_messageInfo_VolumeAttributesClass.Merge(m, src)
   264  }
   265  func (m *VolumeAttributesClass) XXX_Size() int {
   266  	return m.Size()
   267  }
   268  func (m *VolumeAttributesClass) XXX_DiscardUnknown() {
   269  	xxx_messageInfo_VolumeAttributesClass.DiscardUnknown(m)
   270  }
   271  
   272  var xxx_messageInfo_VolumeAttributesClass proto.InternalMessageInfo
   273  
   274  func (m *VolumeAttributesClassList) Reset()      { *m = VolumeAttributesClassList{} }
   275  func (*VolumeAttributesClassList) ProtoMessage() {}
   276  func (*VolumeAttributesClassList) Descriptor() ([]byte, []int) {
   277  	return fileDescriptor_02e7952e43280c27, []int{8}
   278  }
   279  func (m *VolumeAttributesClassList) XXX_Unmarshal(b []byte) error {
   280  	return m.Unmarshal(b)
   281  }
   282  func (m *VolumeAttributesClassList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   283  	b = b[:cap(b)]
   284  	n, err := m.MarshalToSizedBuffer(b)
   285  	if err != nil {
   286  		return nil, err
   287  	}
   288  	return b[:n], nil
   289  }
   290  func (m *VolumeAttributesClassList) XXX_Merge(src proto.Message) {
   291  	xxx_messageInfo_VolumeAttributesClassList.Merge(m, src)
   292  }
   293  func (m *VolumeAttributesClassList) XXX_Size() int {
   294  	return m.Size()
   295  }
   296  func (m *VolumeAttributesClassList) XXX_DiscardUnknown() {
   297  	xxx_messageInfo_VolumeAttributesClassList.DiscardUnknown(m)
   298  }
   299  
   300  var xxx_messageInfo_VolumeAttributesClassList proto.InternalMessageInfo
   301  
   302  func (m *VolumeError) Reset()      { *m = VolumeError{} }
   303  func (*VolumeError) ProtoMessage() {}
   304  func (*VolumeError) Descriptor() ([]byte, []int) {
   305  	return fileDescriptor_02e7952e43280c27, []int{9}
   306  }
   307  func (m *VolumeError) XXX_Unmarshal(b []byte) error {
   308  	return m.Unmarshal(b)
   309  }
   310  func (m *VolumeError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   311  	b = b[:cap(b)]
   312  	n, err := m.MarshalToSizedBuffer(b)
   313  	if err != nil {
   314  		return nil, err
   315  	}
   316  	return b[:n], nil
   317  }
   318  func (m *VolumeError) XXX_Merge(src proto.Message) {
   319  	xxx_messageInfo_VolumeError.Merge(m, src)
   320  }
   321  func (m *VolumeError) XXX_Size() int {
   322  	return m.Size()
   323  }
   324  func (m *VolumeError) XXX_DiscardUnknown() {
   325  	xxx_messageInfo_VolumeError.DiscardUnknown(m)
   326  }
   327  
   328  var xxx_messageInfo_VolumeError proto.InternalMessageInfo
   329  
   330  func init() {
   331  	proto.RegisterType((*CSIStorageCapacity)(nil), "k8s.io.api.storage.v1alpha1.CSIStorageCapacity")
   332  	proto.RegisterType((*CSIStorageCapacityList)(nil), "k8s.io.api.storage.v1alpha1.CSIStorageCapacityList")
   333  	proto.RegisterType((*VolumeAttachment)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttachment")
   334  	proto.RegisterType((*VolumeAttachmentList)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttachmentList")
   335  	proto.RegisterType((*VolumeAttachmentSource)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttachmentSource")
   336  	proto.RegisterType((*VolumeAttachmentSpec)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttachmentSpec")
   337  	proto.RegisterType((*VolumeAttachmentStatus)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttachmentStatus")
   338  	proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttachmentStatus.AttachmentMetadataEntry")
   339  	proto.RegisterType((*VolumeAttributesClass)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttributesClass")
   340  	proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttributesClass.ParametersEntry")
   341  	proto.RegisterType((*VolumeAttributesClassList)(nil), "k8s.io.api.storage.v1alpha1.VolumeAttributesClassList")
   342  	proto.RegisterType((*VolumeError)(nil), "k8s.io.api.storage.v1alpha1.VolumeError")
   343  }
   344  
   345  func init() {
   346  	proto.RegisterFile("k8s.io/api/storage/v1alpha1/generated.proto", fileDescriptor_02e7952e43280c27)
   347  }
   348  
   349  var fileDescriptor_02e7952e43280c27 = []byte{
   350  	// 1009 bytes of a gzipped FileDescriptorProto
   351  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x3d, 0x6f, 0x23, 0x45,
   352  	0x18, 0xce, 0xda, 0xce, 0x9d, 0x6f, 0x1c, 0x38, 0xdf, 0xc8, 0x77, 0x18, 0x9f, 0xb4, 0x3e, 0xb9,
   353  	0x32, 0x1f, 0x37, 0x4b, 0x02, 0x42, 0x27, 0x24, 0x0a, 0x6f, 0x92, 0x22, 0x22, 0x09, 0xc7, 0x38,
   354  	0x02, 0x04, 0x14, 0x8c, 0xd7, 0x83, 0x3d, 0x89, 0xf7, 0x43, 0x33, 0xb3, 0x16, 0xa6, 0xa2, 0xa2,
   355  	0xa6, 0xe3, 0x1f, 0xf0, 0x5b, 0x52, 0x20, 0x71, 0xba, 0xea, 0x2a, 0x8b, 0x2c, 0xfc, 0x06, 0x0a,
   356  	0x1a, 0xd0, 0xce, 0x8e, 0xd7, 0x1b, 0xaf, 0x1d, 0x9c, 0x14, 0xe9, 0x3c, 0x33, 0xef, 0xfb, 0x3c,
   357  	0xef, 0xc7, 0xf3, 0xbe, 0x9b, 0x80, 0x77, 0xce, 0x9e, 0x09, 0xc4, 0x7c, 0x8b, 0x04, 0xcc, 0x12,
   358  	0xd2, 0xe7, 0x64, 0x40, 0xad, 0xf1, 0x36, 0x19, 0x05, 0x43, 0xb2, 0x6d, 0x0d, 0xa8, 0x47, 0x39,
   359  	0x91, 0xb4, 0x8f, 0x02, 0xee, 0x4b, 0x1f, 0x3e, 0x4e, 0x8c, 0x11, 0x09, 0x18, 0xd2, 0xc6, 0x68,
   360  	0x66, 0xdc, 0x78, 0x3a, 0x60, 0x72, 0x18, 0xf6, 0x90, 0xe3, 0xbb, 0xd6, 0xc0, 0x1f, 0xf8, 0x96,
   361  	0xf2, 0xe9, 0x85, 0xdf, 0xa9, 0x93, 0x3a, 0xa8, 0x5f, 0x09, 0x56, 0xa3, 0x95, 0x21, 0x76, 0x7c,
   362  	0x1e, 0xb3, 0x2e, 0xf2, 0x35, 0x3e, 0x98, 0xdb, 0xb8, 0xc4, 0x19, 0x32, 0x8f, 0xf2, 0x89, 0x15,
   363  	0x9c, 0x0d, 0x94, 0x13, 0xa7, 0xc2, 0x0f, 0xb9, 0x43, 0xaf, 0xe5, 0x25, 0x2c, 0x97, 0x4a, 0xb2,
   364  	0x8c, 0xcb, 0x5a, 0xe5, 0xc5, 0x43, 0x4f, 0x32, 0x37, 0x4f, 0xf3, 0xe1, 0xff, 0x39, 0x08, 0x67,
   365  	0x48, 0x5d, 0xb2, 0xe8, 0xd7, 0xfa, 0xbb, 0x08, 0xe0, 0x6e, 0xf7, 0xa0, 0x9b, 0xd4, 0x6f, 0x97,
   366  	0x04, 0xc4, 0x61, 0x72, 0x02, 0xbf, 0x05, 0xe5, 0x38, 0xb4, 0x3e, 0x91, 0xa4, 0x6e, 0x3c, 0x31,
   367  	0xda, 0x95, 0x9d, 0xf7, 0xd0, 0xbc, 0xdc, 0x29, 0x03, 0x0a, 0xce, 0x06, 0xf1, 0x85, 0x40, 0xb1,
   368  	0x35, 0x1a, 0x6f, 0xa3, 0x4f, 0x7b, 0xa7, 0xd4, 0x91, 0x47, 0x54, 0x12, 0x1b, 0x9e, 0x4f, 0x9b,
   369  	0x1b, 0xd1, 0xb4, 0x09, 0xe6, 0x77, 0x38, 0x45, 0x85, 0x0c, 0x6c, 0x79, 0x7e, 0x9f, 0x9e, 0xf8,
   370  	0x81, 0x3f, 0xf2, 0x07, 0x93, 0x7a, 0x41, 0xb1, 0xbc, 0xbf, 0x1e, 0xcb, 0x21, 0xe9, 0xd1, 0x51,
   371  	0x97, 0x8e, 0xa8, 0x23, 0x7d, 0x6e, 0x57, 0xa3, 0x69, 0x73, 0xeb, 0x38, 0x03, 0x86, 0x2f, 0x41,
   372  	0xc3, 0x3d, 0x50, 0xd5, 0xfa, 0xd8, 0x1d, 0x11, 0x21, 0x8e, 0x89, 0x4b, 0xeb, 0xc5, 0x27, 0x46,
   373  	0xfb, 0x9e, 0x5d, 0xd7, 0x21, 0x56, 0xbb, 0x0b, 0xef, 0x38, 0xe7, 0x01, 0xbf, 0x04, 0x65, 0x47,
   374  	0x97, 0xa7, 0x5e, 0x52, 0xc1, 0xa2, 0xab, 0x82, 0x45, 0x33, 0x45, 0xa0, 0xcf, 0x42, 0xe2, 0x49,
   375  	0x26, 0x27, 0xf6, 0x56, 0x34, 0x6d, 0x96, 0x67, 0x25, 0xc6, 0x29, 0x1a, 0x14, 0xe0, 0x81, 0x4b,
   376  	0xbe, 0x67, 0x6e, 0xe8, 0x7e, 0xee, 0x8f, 0x42, 0x97, 0x76, 0xd9, 0x0f, 0xb4, 0xbe, 0x79, 0x23,
   377  	0x8a, 0x87, 0xd1, 0xb4, 0xf9, 0xe0, 0x68, 0x11, 0x0c, 0xe7, 0xf1, 0x5b, 0xbf, 0x19, 0xe0, 0x51,
   378  	0xbe, 0xf1, 0x87, 0x4c, 0x48, 0xf8, 0x4d, 0xae, 0xf9, 0x68, 0xcd, 0xb6, 0x30, 0x91, 0xb4, 0xbe,
   379  	0xaa, 0xeb, 0x5a, 0x9e, 0xdd, 0x64, 0x1a, 0x7f, 0x02, 0x36, 0x99, 0xa4, 0xae, 0xa8, 0x17, 0x9e,
   380  	0x14, 0xdb, 0x95, 0x1d, 0x0b, 0x5d, 0x31, 0xc6, 0x28, 0x1f, 0xa1, 0xfd, 0x9a, 0xc6, 0xde, 0x3c,
   381  	0x88, 0x51, 0x70, 0x02, 0xd6, 0xfa, 0xb5, 0x00, 0xaa, 0x49, 0x76, 0x1d, 0x29, 0x89, 0x33, 0x74,
   382  	0xa9, 0x27, 0x6f, 0x41, 0xc5, 0x5d, 0x50, 0x12, 0x01, 0x75, 0xb4, 0x7a, 0xb7, 0xaf, 0xcc, 0x65,
   383  	0x31, 0xbc, 0x6e, 0x40, 0x1d, 0x7b, 0x4b, 0xc3, 0x97, 0xe2, 0x13, 0x56, 0x60, 0xf0, 0x6b, 0x70,
   384  	0x47, 0x48, 0x22, 0x43, 0xa1, 0x54, 0x7a, 0x79, 0x28, 0xd6, 0x80, 0x55, 0xae, 0xf6, 0xeb, 0x1a,
   385  	0xf8, 0x4e, 0x72, 0xc6, 0x1a, 0xb2, 0x75, 0x6e, 0x80, 0xda, 0xa2, 0xcb, 0x2d, 0x74, 0x1d, 0x5f,
   386  	0xee, 0xfa, 0xd3, 0x6b, 0xa5, 0xb4, 0xa2, 0xe7, 0x2f, 0x0d, 0xf0, 0x28, 0x97, 0xbd, 0x1a, 0x08,
   387  	0x78, 0x08, 0x6a, 0x01, 0xe5, 0x82, 0x09, 0x49, 0x3d, 0x99, 0xd8, 0xa8, 0xb1, 0x37, 0x92, 0xb1,
   388  	0x8f, 0xa6, 0xcd, 0xda, 0xf3, 0x25, 0xef, 0x78, 0xa9, 0x17, 0x3c, 0x05, 0x55, 0xe6, 0x8d, 0x98,
   389  	0x47, 0xf5, 0xfc, 0xcc, 0x3b, 0xde, 0xce, 0xe6, 0x11, 0x7f, 0x38, 0xe2, 0x82, 0x2c, 0x22, 0xab,
   390  	0x46, 0xd7, 0xe2, 0x35, 0x73, 0xb0, 0x80, 0x82, 0x73, 0xb8, 0xad, 0xdf, 0x97, 0xf4, 0x27, 0x7e,
   391  	0x80, 0xef, 0x82, 0x32, 0x51, 0x37, 0x94, 0xeb, 0x34, 0xd2, 0x7a, 0x77, 0xf4, 0x3d, 0x4e, 0x2d,
   392  	0x94, 0x86, 0x54, 0x29, 0x96, 0x2c, 0xd6, 0x35, 0x34, 0xa4, 0x5c, 0x33, 0x1a, 0x52, 0x67, 0xac,
   393  	0x21, 0xe3, 0x50, 0xe2, 0x05, 0x9b, 0x59, 0xa4, 0x69, 0x28, 0xc7, 0xfa, 0x1e, 0xa7, 0x16, 0xad,
   394  	0x7f, 0x8b, 0x4b, 0xda, 0xa4, 0xc4, 0x98, 0xc9, 0xa9, 0xaf, 0x72, 0x2a, 0xe7, 0x72, 0xea, 0xa7,
   395  	0x39, 0xf5, 0xe1, 0x2f, 0x06, 0x80, 0x24, 0x85, 0x38, 0x9a, 0x89, 0x35, 0x51, 0xd4, 0x27, 0x37,
   396  	0x18, 0x12, 0xd4, 0xc9, 0xa1, 0xed, 0x7b, 0x92, 0x4f, 0xec, 0x86, 0x8e, 0x02, 0xe6, 0x0d, 0xf0,
   397  	0x92, 0x10, 0xe0, 0x29, 0xa8, 0x24, 0xb7, 0xfb, 0x9c, 0xfb, 0x5c, 0x8f, 0x6d, 0x7b, 0x8d, 0x88,
   398  	0x94, 0xbd, 0x6d, 0x46, 0xd3, 0x66, 0xa5, 0x33, 0x07, 0xf8, 0x67, 0xda, 0xac, 0x64, 0xde, 0x71,
   399  	0x16, 0x3c, 0xe6, 0xea, 0xd3, 0x39, 0x57, 0xe9, 0x26, 0x5c, 0x7b, 0x74, 0x35, 0x57, 0x06, 0xbc,
   400  	0xb1, 0x0f, 0xde, 0x58, 0x51, 0x22, 0x58, 0x05, 0xc5, 0x33, 0x3a, 0x49, 0x94, 0x88, 0xe3, 0x9f,
   401  	0xb0, 0x06, 0x36, 0xc7, 0x64, 0x14, 0x26, 0x8a, 0xbb, 0x87, 0x93, 0xc3, 0x47, 0x85, 0x67, 0x46,
   402  	0xeb, 0xaf, 0x02, 0x78, 0x98, 0x76, 0x80, 0xb3, 0x5e, 0x28, 0xa9, 0x50, 0x1f, 0xd6, 0x5b, 0xd8,
   403  	0xd0, 0x3b, 0x00, 0xf4, 0x39, 0x1b, 0x53, 0xae, 0xd4, 0xaa, 0x42, 0x9b, 0x7b, 0xec, 0xa5, 0x2f,
   404  	0x38, 0x63, 0x05, 0xc7, 0x00, 0x04, 0x84, 0x13, 0x97, 0x4a, 0xca, 0xe3, 0x25, 0x1c, 0xeb, 0xcb,
   405  	0x5e, 0x4f, 0x5f, 0xd9, 0xec, 0xd0, 0xf3, 0x14, 0x24, 0x91, 0x55, 0xca, 0x3b, 0x7f, 0xc0, 0x19,
   406  	0xa6, 0xc6, 0xc7, 0xe0, 0xfe, 0x82, 0xcb, 0xb5, 0xca, 0xfc, 0xd2, 0x00, 0x6f, 0x2e, 0x0d, 0xe4,
   407  	0x16, 0xf6, 0xfb, 0x17, 0x97, 0xf7, 0xfb, 0xce, 0xf5, 0xab, 0xb5, 0x62, 0xc9, 0xff, 0x64, 0x80,
   408  	0xac, 0x3e, 0xe1, 0x21, 0x28, 0xc5, 0x7f, 0xcf, 0xea, 0x14, 0xde, 0x5e, 0x2f, 0x85, 0x13, 0xe6,
   409  	0xd2, 0xf9, 0xa7, 0x36, 0x3e, 0x61, 0x85, 0x02, 0xdf, 0x02, 0x77, 0x5d, 0x2a, 0x04, 0x19, 0xcc,
   410  	0xa4, 0x71, 0x5f, 0x1b, 0xdd, 0x3d, 0x4a, 0xae, 0xf1, 0xec, 0xdd, 0xee, 0x9c, 0x5f, 0x98, 0x1b,
   411  	0x2f, 0x2e, 0xcc, 0x8d, 0x57, 0x17, 0xe6, 0xc6, 0x8f, 0x91, 0x69, 0x9c, 0x47, 0xa6, 0xf1, 0x22,
   412  	0x32, 0x8d, 0x57, 0x91, 0x69, 0xfc, 0x11, 0x99, 0xc6, 0xcf, 0x7f, 0x9a, 0x1b, 0x5f, 0x3d, 0xbe,
   413  	0xe2, 0x3f, 0x98, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x19, 0x2c, 0xaa, 0xdf, 0x0c, 0x00,
   414  	0x00,
   415  }
   416  
   417  func (m *CSIStorageCapacity) Marshal() (dAtA []byte, err error) {
   418  	size := m.Size()
   419  	dAtA = make([]byte, size)
   420  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   421  	if err != nil {
   422  		return nil, err
   423  	}
   424  	return dAtA[:n], nil
   425  }
   426  
   427  func (m *CSIStorageCapacity) MarshalTo(dAtA []byte) (int, error) {
   428  	size := m.Size()
   429  	return m.MarshalToSizedBuffer(dAtA[:size])
   430  }
   431  
   432  func (m *CSIStorageCapacity) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   433  	i := len(dAtA)
   434  	_ = i
   435  	var l int
   436  	_ = l
   437  	if m.MaximumVolumeSize != nil {
   438  		{
   439  			size, err := m.MaximumVolumeSize.MarshalToSizedBuffer(dAtA[:i])
   440  			if err != nil {
   441  				return 0, err
   442  			}
   443  			i -= size
   444  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   445  		}
   446  		i--
   447  		dAtA[i] = 0x2a
   448  	}
   449  	if m.Capacity != nil {
   450  		{
   451  			size, err := m.Capacity.MarshalToSizedBuffer(dAtA[:i])
   452  			if err != nil {
   453  				return 0, err
   454  			}
   455  			i -= size
   456  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   457  		}
   458  		i--
   459  		dAtA[i] = 0x22
   460  	}
   461  	i -= len(m.StorageClassName)
   462  	copy(dAtA[i:], m.StorageClassName)
   463  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.StorageClassName)))
   464  	i--
   465  	dAtA[i] = 0x1a
   466  	if m.NodeTopology != nil {
   467  		{
   468  			size, err := m.NodeTopology.MarshalToSizedBuffer(dAtA[:i])
   469  			if err != nil {
   470  				return 0, err
   471  			}
   472  			i -= size
   473  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   474  		}
   475  		i--
   476  		dAtA[i] = 0x12
   477  	}
   478  	{
   479  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   480  		if err != nil {
   481  			return 0, err
   482  		}
   483  		i -= size
   484  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   485  	}
   486  	i--
   487  	dAtA[i] = 0xa
   488  	return len(dAtA) - i, nil
   489  }
   490  
   491  func (m *CSIStorageCapacityList) Marshal() (dAtA []byte, err error) {
   492  	size := m.Size()
   493  	dAtA = make([]byte, size)
   494  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   495  	if err != nil {
   496  		return nil, err
   497  	}
   498  	return dAtA[:n], nil
   499  }
   500  
   501  func (m *CSIStorageCapacityList) MarshalTo(dAtA []byte) (int, error) {
   502  	size := m.Size()
   503  	return m.MarshalToSizedBuffer(dAtA[:size])
   504  }
   505  
   506  func (m *CSIStorageCapacityList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   507  	i := len(dAtA)
   508  	_ = i
   509  	var l int
   510  	_ = l
   511  	if len(m.Items) > 0 {
   512  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   513  			{
   514  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   515  				if err != nil {
   516  					return 0, err
   517  				}
   518  				i -= size
   519  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   520  			}
   521  			i--
   522  			dAtA[i] = 0x12
   523  		}
   524  	}
   525  	{
   526  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   527  		if err != nil {
   528  			return 0, err
   529  		}
   530  		i -= size
   531  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   532  	}
   533  	i--
   534  	dAtA[i] = 0xa
   535  	return len(dAtA) - i, nil
   536  }
   537  
   538  func (m *VolumeAttachment) Marshal() (dAtA []byte, err error) {
   539  	size := m.Size()
   540  	dAtA = make([]byte, size)
   541  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   542  	if err != nil {
   543  		return nil, err
   544  	}
   545  	return dAtA[:n], nil
   546  }
   547  
   548  func (m *VolumeAttachment) MarshalTo(dAtA []byte) (int, error) {
   549  	size := m.Size()
   550  	return m.MarshalToSizedBuffer(dAtA[:size])
   551  }
   552  
   553  func (m *VolumeAttachment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   554  	i := len(dAtA)
   555  	_ = i
   556  	var l int
   557  	_ = l
   558  	{
   559  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
   560  		if err != nil {
   561  			return 0, err
   562  		}
   563  		i -= size
   564  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   565  	}
   566  	i--
   567  	dAtA[i] = 0x1a
   568  	{
   569  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
   570  		if err != nil {
   571  			return 0, err
   572  		}
   573  		i -= size
   574  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   575  	}
   576  	i--
   577  	dAtA[i] = 0x12
   578  	{
   579  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   580  		if err != nil {
   581  			return 0, err
   582  		}
   583  		i -= size
   584  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   585  	}
   586  	i--
   587  	dAtA[i] = 0xa
   588  	return len(dAtA) - i, nil
   589  }
   590  
   591  func (m *VolumeAttachmentList) Marshal() (dAtA []byte, err error) {
   592  	size := m.Size()
   593  	dAtA = make([]byte, size)
   594  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   595  	if err != nil {
   596  		return nil, err
   597  	}
   598  	return dAtA[:n], nil
   599  }
   600  
   601  func (m *VolumeAttachmentList) MarshalTo(dAtA []byte) (int, error) {
   602  	size := m.Size()
   603  	return m.MarshalToSizedBuffer(dAtA[:size])
   604  }
   605  
   606  func (m *VolumeAttachmentList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   607  	i := len(dAtA)
   608  	_ = i
   609  	var l int
   610  	_ = l
   611  	if len(m.Items) > 0 {
   612  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   613  			{
   614  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   615  				if err != nil {
   616  					return 0, err
   617  				}
   618  				i -= size
   619  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   620  			}
   621  			i--
   622  			dAtA[i] = 0x12
   623  		}
   624  	}
   625  	{
   626  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   627  		if err != nil {
   628  			return 0, err
   629  		}
   630  		i -= size
   631  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   632  	}
   633  	i--
   634  	dAtA[i] = 0xa
   635  	return len(dAtA) - i, nil
   636  }
   637  
   638  func (m *VolumeAttachmentSource) Marshal() (dAtA []byte, err error) {
   639  	size := m.Size()
   640  	dAtA = make([]byte, size)
   641  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   642  	if err != nil {
   643  		return nil, err
   644  	}
   645  	return dAtA[:n], nil
   646  }
   647  
   648  func (m *VolumeAttachmentSource) MarshalTo(dAtA []byte) (int, error) {
   649  	size := m.Size()
   650  	return m.MarshalToSizedBuffer(dAtA[:size])
   651  }
   652  
   653  func (m *VolumeAttachmentSource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   654  	i := len(dAtA)
   655  	_ = i
   656  	var l int
   657  	_ = l
   658  	if m.InlineVolumeSpec != nil {
   659  		{
   660  			size, err := m.InlineVolumeSpec.MarshalToSizedBuffer(dAtA[:i])
   661  			if err != nil {
   662  				return 0, err
   663  			}
   664  			i -= size
   665  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   666  		}
   667  		i--
   668  		dAtA[i] = 0x12
   669  	}
   670  	if m.PersistentVolumeName != nil {
   671  		i -= len(*m.PersistentVolumeName)
   672  		copy(dAtA[i:], *m.PersistentVolumeName)
   673  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PersistentVolumeName)))
   674  		i--
   675  		dAtA[i] = 0xa
   676  	}
   677  	return len(dAtA) - i, nil
   678  }
   679  
   680  func (m *VolumeAttachmentSpec) Marshal() (dAtA []byte, err error) {
   681  	size := m.Size()
   682  	dAtA = make([]byte, size)
   683  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   684  	if err != nil {
   685  		return nil, err
   686  	}
   687  	return dAtA[:n], nil
   688  }
   689  
   690  func (m *VolumeAttachmentSpec) MarshalTo(dAtA []byte) (int, error) {
   691  	size := m.Size()
   692  	return m.MarshalToSizedBuffer(dAtA[:size])
   693  }
   694  
   695  func (m *VolumeAttachmentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   696  	i := len(dAtA)
   697  	_ = i
   698  	var l int
   699  	_ = l
   700  	i -= len(m.NodeName)
   701  	copy(dAtA[i:], m.NodeName)
   702  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.NodeName)))
   703  	i--
   704  	dAtA[i] = 0x1a
   705  	{
   706  		size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
   707  		if err != nil {
   708  			return 0, err
   709  		}
   710  		i -= size
   711  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   712  	}
   713  	i--
   714  	dAtA[i] = 0x12
   715  	i -= len(m.Attacher)
   716  	copy(dAtA[i:], m.Attacher)
   717  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Attacher)))
   718  	i--
   719  	dAtA[i] = 0xa
   720  	return len(dAtA) - i, nil
   721  }
   722  
   723  func (m *VolumeAttachmentStatus) Marshal() (dAtA []byte, err error) {
   724  	size := m.Size()
   725  	dAtA = make([]byte, size)
   726  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   727  	if err != nil {
   728  		return nil, err
   729  	}
   730  	return dAtA[:n], nil
   731  }
   732  
   733  func (m *VolumeAttachmentStatus) MarshalTo(dAtA []byte) (int, error) {
   734  	size := m.Size()
   735  	return m.MarshalToSizedBuffer(dAtA[:size])
   736  }
   737  
   738  func (m *VolumeAttachmentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   739  	i := len(dAtA)
   740  	_ = i
   741  	var l int
   742  	_ = l
   743  	if m.DetachError != nil {
   744  		{
   745  			size, err := m.DetachError.MarshalToSizedBuffer(dAtA[:i])
   746  			if err != nil {
   747  				return 0, err
   748  			}
   749  			i -= size
   750  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   751  		}
   752  		i--
   753  		dAtA[i] = 0x22
   754  	}
   755  	if m.AttachError != nil {
   756  		{
   757  			size, err := m.AttachError.MarshalToSizedBuffer(dAtA[:i])
   758  			if err != nil {
   759  				return 0, err
   760  			}
   761  			i -= size
   762  			i = encodeVarintGenerated(dAtA, i, uint64(size))
   763  		}
   764  		i--
   765  		dAtA[i] = 0x1a
   766  	}
   767  	if len(m.AttachmentMetadata) > 0 {
   768  		keysForAttachmentMetadata := make([]string, 0, len(m.AttachmentMetadata))
   769  		for k := range m.AttachmentMetadata {
   770  			keysForAttachmentMetadata = append(keysForAttachmentMetadata, string(k))
   771  		}
   772  		github_com_gogo_protobuf_sortkeys.Strings(keysForAttachmentMetadata)
   773  		for iNdEx := len(keysForAttachmentMetadata) - 1; iNdEx >= 0; iNdEx-- {
   774  			v := m.AttachmentMetadata[string(keysForAttachmentMetadata[iNdEx])]
   775  			baseI := i
   776  			i -= len(v)
   777  			copy(dAtA[i:], v)
   778  			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
   779  			i--
   780  			dAtA[i] = 0x12
   781  			i -= len(keysForAttachmentMetadata[iNdEx])
   782  			copy(dAtA[i:], keysForAttachmentMetadata[iNdEx])
   783  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForAttachmentMetadata[iNdEx])))
   784  			i--
   785  			dAtA[i] = 0xa
   786  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
   787  			i--
   788  			dAtA[i] = 0x12
   789  		}
   790  	}
   791  	i--
   792  	if m.Attached {
   793  		dAtA[i] = 1
   794  	} else {
   795  		dAtA[i] = 0
   796  	}
   797  	i--
   798  	dAtA[i] = 0x8
   799  	return len(dAtA) - i, nil
   800  }
   801  
   802  func (m *VolumeAttributesClass) Marshal() (dAtA []byte, err error) {
   803  	size := m.Size()
   804  	dAtA = make([]byte, size)
   805  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   806  	if err != nil {
   807  		return nil, err
   808  	}
   809  	return dAtA[:n], nil
   810  }
   811  
   812  func (m *VolumeAttributesClass) MarshalTo(dAtA []byte) (int, error) {
   813  	size := m.Size()
   814  	return m.MarshalToSizedBuffer(dAtA[:size])
   815  }
   816  
   817  func (m *VolumeAttributesClass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   818  	i := len(dAtA)
   819  	_ = i
   820  	var l int
   821  	_ = l
   822  	if len(m.Parameters) > 0 {
   823  		keysForParameters := make([]string, 0, len(m.Parameters))
   824  		for k := range m.Parameters {
   825  			keysForParameters = append(keysForParameters, string(k))
   826  		}
   827  		github_com_gogo_protobuf_sortkeys.Strings(keysForParameters)
   828  		for iNdEx := len(keysForParameters) - 1; iNdEx >= 0; iNdEx-- {
   829  			v := m.Parameters[string(keysForParameters[iNdEx])]
   830  			baseI := i
   831  			i -= len(v)
   832  			copy(dAtA[i:], v)
   833  			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
   834  			i--
   835  			dAtA[i] = 0x12
   836  			i -= len(keysForParameters[iNdEx])
   837  			copy(dAtA[i:], keysForParameters[iNdEx])
   838  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForParameters[iNdEx])))
   839  			i--
   840  			dAtA[i] = 0xa
   841  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
   842  			i--
   843  			dAtA[i] = 0x1a
   844  		}
   845  	}
   846  	i -= len(m.DriverName)
   847  	copy(dAtA[i:], m.DriverName)
   848  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.DriverName)))
   849  	i--
   850  	dAtA[i] = 0x12
   851  	{
   852  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   853  		if err != nil {
   854  			return 0, err
   855  		}
   856  		i -= size
   857  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   858  	}
   859  	i--
   860  	dAtA[i] = 0xa
   861  	return len(dAtA) - i, nil
   862  }
   863  
   864  func (m *VolumeAttributesClassList) Marshal() (dAtA []byte, err error) {
   865  	size := m.Size()
   866  	dAtA = make([]byte, size)
   867  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   868  	if err != nil {
   869  		return nil, err
   870  	}
   871  	return dAtA[:n], nil
   872  }
   873  
   874  func (m *VolumeAttributesClassList) MarshalTo(dAtA []byte) (int, error) {
   875  	size := m.Size()
   876  	return m.MarshalToSizedBuffer(dAtA[:size])
   877  }
   878  
   879  func (m *VolumeAttributesClassList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   880  	i := len(dAtA)
   881  	_ = i
   882  	var l int
   883  	_ = l
   884  	if len(m.Items) > 0 {
   885  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   886  			{
   887  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   888  				if err != nil {
   889  					return 0, err
   890  				}
   891  				i -= size
   892  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   893  			}
   894  			i--
   895  			dAtA[i] = 0x12
   896  		}
   897  	}
   898  	{
   899  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   900  		if err != nil {
   901  			return 0, err
   902  		}
   903  		i -= size
   904  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   905  	}
   906  	i--
   907  	dAtA[i] = 0xa
   908  	return len(dAtA) - i, nil
   909  }
   910  
   911  func (m *VolumeError) Marshal() (dAtA []byte, err error) {
   912  	size := m.Size()
   913  	dAtA = make([]byte, size)
   914  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   915  	if err != nil {
   916  		return nil, err
   917  	}
   918  	return dAtA[:n], nil
   919  }
   920  
   921  func (m *VolumeError) MarshalTo(dAtA []byte) (int, error) {
   922  	size := m.Size()
   923  	return m.MarshalToSizedBuffer(dAtA[:size])
   924  }
   925  
   926  func (m *VolumeError) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   927  	i := len(dAtA)
   928  	_ = i
   929  	var l int
   930  	_ = l
   931  	i -= len(m.Message)
   932  	copy(dAtA[i:], m.Message)
   933  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
   934  	i--
   935  	dAtA[i] = 0x12
   936  	{
   937  		size, err := m.Time.MarshalToSizedBuffer(dAtA[:i])
   938  		if err != nil {
   939  			return 0, err
   940  		}
   941  		i -= size
   942  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   943  	}
   944  	i--
   945  	dAtA[i] = 0xa
   946  	return len(dAtA) - i, nil
   947  }
   948  
   949  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   950  	offset -= sovGenerated(v)
   951  	base := offset
   952  	for v >= 1<<7 {
   953  		dAtA[offset] = uint8(v&0x7f | 0x80)
   954  		v >>= 7
   955  		offset++
   956  	}
   957  	dAtA[offset] = uint8(v)
   958  	return base
   959  }
   960  func (m *CSIStorageCapacity) Size() (n int) {
   961  	if m == nil {
   962  		return 0
   963  	}
   964  	var l int
   965  	_ = l
   966  	l = m.ObjectMeta.Size()
   967  	n += 1 + l + sovGenerated(uint64(l))
   968  	if m.NodeTopology != nil {
   969  		l = m.NodeTopology.Size()
   970  		n += 1 + l + sovGenerated(uint64(l))
   971  	}
   972  	l = len(m.StorageClassName)
   973  	n += 1 + l + sovGenerated(uint64(l))
   974  	if m.Capacity != nil {
   975  		l = m.Capacity.Size()
   976  		n += 1 + l + sovGenerated(uint64(l))
   977  	}
   978  	if m.MaximumVolumeSize != nil {
   979  		l = m.MaximumVolumeSize.Size()
   980  		n += 1 + l + sovGenerated(uint64(l))
   981  	}
   982  	return n
   983  }
   984  
   985  func (m *CSIStorageCapacityList) Size() (n int) {
   986  	if m == nil {
   987  		return 0
   988  	}
   989  	var l int
   990  	_ = l
   991  	l = m.ListMeta.Size()
   992  	n += 1 + l + sovGenerated(uint64(l))
   993  	if len(m.Items) > 0 {
   994  		for _, e := range m.Items {
   995  			l = e.Size()
   996  			n += 1 + l + sovGenerated(uint64(l))
   997  		}
   998  	}
   999  	return n
  1000  }
  1001  
  1002  func (m *VolumeAttachment) Size() (n int) {
  1003  	if m == nil {
  1004  		return 0
  1005  	}
  1006  	var l int
  1007  	_ = l
  1008  	l = m.ObjectMeta.Size()
  1009  	n += 1 + l + sovGenerated(uint64(l))
  1010  	l = m.Spec.Size()
  1011  	n += 1 + l + sovGenerated(uint64(l))
  1012  	l = m.Status.Size()
  1013  	n += 1 + l + sovGenerated(uint64(l))
  1014  	return n
  1015  }
  1016  
  1017  func (m *VolumeAttachmentList) Size() (n int) {
  1018  	if m == nil {
  1019  		return 0
  1020  	}
  1021  	var l int
  1022  	_ = l
  1023  	l = m.ListMeta.Size()
  1024  	n += 1 + l + sovGenerated(uint64(l))
  1025  	if len(m.Items) > 0 {
  1026  		for _, e := range m.Items {
  1027  			l = e.Size()
  1028  			n += 1 + l + sovGenerated(uint64(l))
  1029  		}
  1030  	}
  1031  	return n
  1032  }
  1033  
  1034  func (m *VolumeAttachmentSource) Size() (n int) {
  1035  	if m == nil {
  1036  		return 0
  1037  	}
  1038  	var l int
  1039  	_ = l
  1040  	if m.PersistentVolumeName != nil {
  1041  		l = len(*m.PersistentVolumeName)
  1042  		n += 1 + l + sovGenerated(uint64(l))
  1043  	}
  1044  	if m.InlineVolumeSpec != nil {
  1045  		l = m.InlineVolumeSpec.Size()
  1046  		n += 1 + l + sovGenerated(uint64(l))
  1047  	}
  1048  	return n
  1049  }
  1050  
  1051  func (m *VolumeAttachmentSpec) Size() (n int) {
  1052  	if m == nil {
  1053  		return 0
  1054  	}
  1055  	var l int
  1056  	_ = l
  1057  	l = len(m.Attacher)
  1058  	n += 1 + l + sovGenerated(uint64(l))
  1059  	l = m.Source.Size()
  1060  	n += 1 + l + sovGenerated(uint64(l))
  1061  	l = len(m.NodeName)
  1062  	n += 1 + l + sovGenerated(uint64(l))
  1063  	return n
  1064  }
  1065  
  1066  func (m *VolumeAttachmentStatus) Size() (n int) {
  1067  	if m == nil {
  1068  		return 0
  1069  	}
  1070  	var l int
  1071  	_ = l
  1072  	n += 2
  1073  	if len(m.AttachmentMetadata) > 0 {
  1074  		for k, v := range m.AttachmentMetadata {
  1075  			_ = k
  1076  			_ = v
  1077  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
  1078  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
  1079  		}
  1080  	}
  1081  	if m.AttachError != nil {
  1082  		l = m.AttachError.Size()
  1083  		n += 1 + l + sovGenerated(uint64(l))
  1084  	}
  1085  	if m.DetachError != nil {
  1086  		l = m.DetachError.Size()
  1087  		n += 1 + l + sovGenerated(uint64(l))
  1088  	}
  1089  	return n
  1090  }
  1091  
  1092  func (m *VolumeAttributesClass) Size() (n int) {
  1093  	if m == nil {
  1094  		return 0
  1095  	}
  1096  	var l int
  1097  	_ = l
  1098  	l = m.ObjectMeta.Size()
  1099  	n += 1 + l + sovGenerated(uint64(l))
  1100  	l = len(m.DriverName)
  1101  	n += 1 + l + sovGenerated(uint64(l))
  1102  	if len(m.Parameters) > 0 {
  1103  		for k, v := range m.Parameters {
  1104  			_ = k
  1105  			_ = v
  1106  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
  1107  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
  1108  		}
  1109  	}
  1110  	return n
  1111  }
  1112  
  1113  func (m *VolumeAttributesClassList) Size() (n int) {
  1114  	if m == nil {
  1115  		return 0
  1116  	}
  1117  	var l int
  1118  	_ = l
  1119  	l = m.ListMeta.Size()
  1120  	n += 1 + l + sovGenerated(uint64(l))
  1121  	if len(m.Items) > 0 {
  1122  		for _, e := range m.Items {
  1123  			l = e.Size()
  1124  			n += 1 + l + sovGenerated(uint64(l))
  1125  		}
  1126  	}
  1127  	return n
  1128  }
  1129  
  1130  func (m *VolumeError) Size() (n int) {
  1131  	if m == nil {
  1132  		return 0
  1133  	}
  1134  	var l int
  1135  	_ = l
  1136  	l = m.Time.Size()
  1137  	n += 1 + l + sovGenerated(uint64(l))
  1138  	l = len(m.Message)
  1139  	n += 1 + l + sovGenerated(uint64(l))
  1140  	return n
  1141  }
  1142  
  1143  func sovGenerated(x uint64) (n int) {
  1144  	return (math_bits.Len64(x|1) + 6) / 7
  1145  }
  1146  func sozGenerated(x uint64) (n int) {
  1147  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  1148  }
  1149  func (this *CSIStorageCapacity) String() string {
  1150  	if this == nil {
  1151  		return "nil"
  1152  	}
  1153  	s := strings.Join([]string{`&CSIStorageCapacity{`,
  1154  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1155  		`NodeTopology:` + strings.Replace(fmt.Sprintf("%v", this.NodeTopology), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  1156  		`StorageClassName:` + fmt.Sprintf("%v", this.StorageClassName) + `,`,
  1157  		`Capacity:` + strings.Replace(fmt.Sprintf("%v", this.Capacity), "Quantity", "resource.Quantity", 1) + `,`,
  1158  		`MaximumVolumeSize:` + strings.Replace(fmt.Sprintf("%v", this.MaximumVolumeSize), "Quantity", "resource.Quantity", 1) + `,`,
  1159  		`}`,
  1160  	}, "")
  1161  	return s
  1162  }
  1163  func (this *CSIStorageCapacityList) String() string {
  1164  	if this == nil {
  1165  		return "nil"
  1166  	}
  1167  	repeatedStringForItems := "[]CSIStorageCapacity{"
  1168  	for _, f := range this.Items {
  1169  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "CSIStorageCapacity", "CSIStorageCapacity", 1), `&`, ``, 1) + ","
  1170  	}
  1171  	repeatedStringForItems += "}"
  1172  	s := strings.Join([]string{`&CSIStorageCapacityList{`,
  1173  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1174  		`Items:` + repeatedStringForItems + `,`,
  1175  		`}`,
  1176  	}, "")
  1177  	return s
  1178  }
  1179  func (this *VolumeAttachment) String() string {
  1180  	if this == nil {
  1181  		return "nil"
  1182  	}
  1183  	s := strings.Join([]string{`&VolumeAttachment{`,
  1184  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1185  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "VolumeAttachmentSpec", "VolumeAttachmentSpec", 1), `&`, ``, 1) + `,`,
  1186  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "VolumeAttachmentStatus", "VolumeAttachmentStatus", 1), `&`, ``, 1) + `,`,
  1187  		`}`,
  1188  	}, "")
  1189  	return s
  1190  }
  1191  func (this *VolumeAttachmentList) String() string {
  1192  	if this == nil {
  1193  		return "nil"
  1194  	}
  1195  	repeatedStringForItems := "[]VolumeAttachment{"
  1196  	for _, f := range this.Items {
  1197  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "VolumeAttachment", "VolumeAttachment", 1), `&`, ``, 1) + ","
  1198  	}
  1199  	repeatedStringForItems += "}"
  1200  	s := strings.Join([]string{`&VolumeAttachmentList{`,
  1201  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1202  		`Items:` + repeatedStringForItems + `,`,
  1203  		`}`,
  1204  	}, "")
  1205  	return s
  1206  }
  1207  func (this *VolumeAttachmentSource) String() string {
  1208  	if this == nil {
  1209  		return "nil"
  1210  	}
  1211  	s := strings.Join([]string{`&VolumeAttachmentSource{`,
  1212  		`PersistentVolumeName:` + valueToStringGenerated(this.PersistentVolumeName) + `,`,
  1213  		`InlineVolumeSpec:` + strings.Replace(fmt.Sprintf("%v", this.InlineVolumeSpec), "PersistentVolumeSpec", "v11.PersistentVolumeSpec", 1) + `,`,
  1214  		`}`,
  1215  	}, "")
  1216  	return s
  1217  }
  1218  func (this *VolumeAttachmentSpec) String() string {
  1219  	if this == nil {
  1220  		return "nil"
  1221  	}
  1222  	s := strings.Join([]string{`&VolumeAttachmentSpec{`,
  1223  		`Attacher:` + fmt.Sprintf("%v", this.Attacher) + `,`,
  1224  		`Source:` + strings.Replace(strings.Replace(this.Source.String(), "VolumeAttachmentSource", "VolumeAttachmentSource", 1), `&`, ``, 1) + `,`,
  1225  		`NodeName:` + fmt.Sprintf("%v", this.NodeName) + `,`,
  1226  		`}`,
  1227  	}, "")
  1228  	return s
  1229  }
  1230  func (this *VolumeAttachmentStatus) String() string {
  1231  	if this == nil {
  1232  		return "nil"
  1233  	}
  1234  	keysForAttachmentMetadata := make([]string, 0, len(this.AttachmentMetadata))
  1235  	for k := range this.AttachmentMetadata {
  1236  		keysForAttachmentMetadata = append(keysForAttachmentMetadata, k)
  1237  	}
  1238  	github_com_gogo_protobuf_sortkeys.Strings(keysForAttachmentMetadata)
  1239  	mapStringForAttachmentMetadata := "map[string]string{"
  1240  	for _, k := range keysForAttachmentMetadata {
  1241  		mapStringForAttachmentMetadata += fmt.Sprintf("%v: %v,", k, this.AttachmentMetadata[k])
  1242  	}
  1243  	mapStringForAttachmentMetadata += "}"
  1244  	s := strings.Join([]string{`&VolumeAttachmentStatus{`,
  1245  		`Attached:` + fmt.Sprintf("%v", this.Attached) + `,`,
  1246  		`AttachmentMetadata:` + mapStringForAttachmentMetadata + `,`,
  1247  		`AttachError:` + strings.Replace(this.AttachError.String(), "VolumeError", "VolumeError", 1) + `,`,
  1248  		`DetachError:` + strings.Replace(this.DetachError.String(), "VolumeError", "VolumeError", 1) + `,`,
  1249  		`}`,
  1250  	}, "")
  1251  	return s
  1252  }
  1253  func (this *VolumeAttributesClass) String() string {
  1254  	if this == nil {
  1255  		return "nil"
  1256  	}
  1257  	keysForParameters := make([]string, 0, len(this.Parameters))
  1258  	for k := range this.Parameters {
  1259  		keysForParameters = append(keysForParameters, k)
  1260  	}
  1261  	github_com_gogo_protobuf_sortkeys.Strings(keysForParameters)
  1262  	mapStringForParameters := "map[string]string{"
  1263  	for _, k := range keysForParameters {
  1264  		mapStringForParameters += fmt.Sprintf("%v: %v,", k, this.Parameters[k])
  1265  	}
  1266  	mapStringForParameters += "}"
  1267  	s := strings.Join([]string{`&VolumeAttributesClass{`,
  1268  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  1269  		`DriverName:` + fmt.Sprintf("%v", this.DriverName) + `,`,
  1270  		`Parameters:` + mapStringForParameters + `,`,
  1271  		`}`,
  1272  	}, "")
  1273  	return s
  1274  }
  1275  func (this *VolumeAttributesClassList) String() string {
  1276  	if this == nil {
  1277  		return "nil"
  1278  	}
  1279  	repeatedStringForItems := "[]VolumeAttributesClass{"
  1280  	for _, f := range this.Items {
  1281  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "VolumeAttributesClass", "VolumeAttributesClass", 1), `&`, ``, 1) + ","
  1282  	}
  1283  	repeatedStringForItems += "}"
  1284  	s := strings.Join([]string{`&VolumeAttributesClassList{`,
  1285  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  1286  		`Items:` + repeatedStringForItems + `,`,
  1287  		`}`,
  1288  	}, "")
  1289  	return s
  1290  }
  1291  func (this *VolumeError) String() string {
  1292  	if this == nil {
  1293  		return "nil"
  1294  	}
  1295  	s := strings.Join([]string{`&VolumeError{`,
  1296  		`Time:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Time), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
  1297  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
  1298  		`}`,
  1299  	}, "")
  1300  	return s
  1301  }
  1302  func valueToStringGenerated(v interface{}) string {
  1303  	rv := reflect.ValueOf(v)
  1304  	if rv.IsNil() {
  1305  		return "nil"
  1306  	}
  1307  	pv := reflect.Indirect(rv).Interface()
  1308  	return fmt.Sprintf("*%v", pv)
  1309  }
  1310  func (m *CSIStorageCapacity) Unmarshal(dAtA []byte) error {
  1311  	l := len(dAtA)
  1312  	iNdEx := 0
  1313  	for iNdEx < l {
  1314  		preIndex := iNdEx
  1315  		var wire uint64
  1316  		for shift := uint(0); ; shift += 7 {
  1317  			if shift >= 64 {
  1318  				return ErrIntOverflowGenerated
  1319  			}
  1320  			if iNdEx >= l {
  1321  				return io.ErrUnexpectedEOF
  1322  			}
  1323  			b := dAtA[iNdEx]
  1324  			iNdEx++
  1325  			wire |= uint64(b&0x7F) << shift
  1326  			if b < 0x80 {
  1327  				break
  1328  			}
  1329  		}
  1330  		fieldNum := int32(wire >> 3)
  1331  		wireType := int(wire & 0x7)
  1332  		if wireType == 4 {
  1333  			return fmt.Errorf("proto: CSIStorageCapacity: wiretype end group for non-group")
  1334  		}
  1335  		if fieldNum <= 0 {
  1336  			return fmt.Errorf("proto: CSIStorageCapacity: illegal tag %d (wire type %d)", fieldNum, wire)
  1337  		}
  1338  		switch fieldNum {
  1339  		case 1:
  1340  			if wireType != 2 {
  1341  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1342  			}
  1343  			var msglen int
  1344  			for shift := uint(0); ; shift += 7 {
  1345  				if shift >= 64 {
  1346  					return ErrIntOverflowGenerated
  1347  				}
  1348  				if iNdEx >= l {
  1349  					return io.ErrUnexpectedEOF
  1350  				}
  1351  				b := dAtA[iNdEx]
  1352  				iNdEx++
  1353  				msglen |= int(b&0x7F) << shift
  1354  				if b < 0x80 {
  1355  					break
  1356  				}
  1357  			}
  1358  			if msglen < 0 {
  1359  				return ErrInvalidLengthGenerated
  1360  			}
  1361  			postIndex := iNdEx + msglen
  1362  			if postIndex < 0 {
  1363  				return ErrInvalidLengthGenerated
  1364  			}
  1365  			if postIndex > l {
  1366  				return io.ErrUnexpectedEOF
  1367  			}
  1368  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1369  				return err
  1370  			}
  1371  			iNdEx = postIndex
  1372  		case 2:
  1373  			if wireType != 2 {
  1374  				return fmt.Errorf("proto: wrong wireType = %d for field NodeTopology", wireType)
  1375  			}
  1376  			var msglen int
  1377  			for shift := uint(0); ; shift += 7 {
  1378  				if shift >= 64 {
  1379  					return ErrIntOverflowGenerated
  1380  				}
  1381  				if iNdEx >= l {
  1382  					return io.ErrUnexpectedEOF
  1383  				}
  1384  				b := dAtA[iNdEx]
  1385  				iNdEx++
  1386  				msglen |= int(b&0x7F) << shift
  1387  				if b < 0x80 {
  1388  					break
  1389  				}
  1390  			}
  1391  			if msglen < 0 {
  1392  				return ErrInvalidLengthGenerated
  1393  			}
  1394  			postIndex := iNdEx + msglen
  1395  			if postIndex < 0 {
  1396  				return ErrInvalidLengthGenerated
  1397  			}
  1398  			if postIndex > l {
  1399  				return io.ErrUnexpectedEOF
  1400  			}
  1401  			if m.NodeTopology == nil {
  1402  				m.NodeTopology = &v1.LabelSelector{}
  1403  			}
  1404  			if err := m.NodeTopology.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1405  				return err
  1406  			}
  1407  			iNdEx = postIndex
  1408  		case 3:
  1409  			if wireType != 2 {
  1410  				return fmt.Errorf("proto: wrong wireType = %d for field StorageClassName", wireType)
  1411  			}
  1412  			var stringLen uint64
  1413  			for shift := uint(0); ; shift += 7 {
  1414  				if shift >= 64 {
  1415  					return ErrIntOverflowGenerated
  1416  				}
  1417  				if iNdEx >= l {
  1418  					return io.ErrUnexpectedEOF
  1419  				}
  1420  				b := dAtA[iNdEx]
  1421  				iNdEx++
  1422  				stringLen |= uint64(b&0x7F) << shift
  1423  				if b < 0x80 {
  1424  					break
  1425  				}
  1426  			}
  1427  			intStringLen := int(stringLen)
  1428  			if intStringLen < 0 {
  1429  				return ErrInvalidLengthGenerated
  1430  			}
  1431  			postIndex := iNdEx + intStringLen
  1432  			if postIndex < 0 {
  1433  				return ErrInvalidLengthGenerated
  1434  			}
  1435  			if postIndex > l {
  1436  				return io.ErrUnexpectedEOF
  1437  			}
  1438  			m.StorageClassName = string(dAtA[iNdEx:postIndex])
  1439  			iNdEx = postIndex
  1440  		case 4:
  1441  			if wireType != 2 {
  1442  				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", 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 < 0 {
  1464  				return ErrInvalidLengthGenerated
  1465  			}
  1466  			if postIndex > l {
  1467  				return io.ErrUnexpectedEOF
  1468  			}
  1469  			if m.Capacity == nil {
  1470  				m.Capacity = &resource.Quantity{}
  1471  			}
  1472  			if err := m.Capacity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1473  				return err
  1474  			}
  1475  			iNdEx = postIndex
  1476  		case 5:
  1477  			if wireType != 2 {
  1478  				return fmt.Errorf("proto: wrong wireType = %d for field MaximumVolumeSize", wireType)
  1479  			}
  1480  			var msglen int
  1481  			for shift := uint(0); ; shift += 7 {
  1482  				if shift >= 64 {
  1483  					return ErrIntOverflowGenerated
  1484  				}
  1485  				if iNdEx >= l {
  1486  					return io.ErrUnexpectedEOF
  1487  				}
  1488  				b := dAtA[iNdEx]
  1489  				iNdEx++
  1490  				msglen |= int(b&0x7F) << shift
  1491  				if b < 0x80 {
  1492  					break
  1493  				}
  1494  			}
  1495  			if msglen < 0 {
  1496  				return ErrInvalidLengthGenerated
  1497  			}
  1498  			postIndex := iNdEx + msglen
  1499  			if postIndex < 0 {
  1500  				return ErrInvalidLengthGenerated
  1501  			}
  1502  			if postIndex > l {
  1503  				return io.ErrUnexpectedEOF
  1504  			}
  1505  			if m.MaximumVolumeSize == nil {
  1506  				m.MaximumVolumeSize = &resource.Quantity{}
  1507  			}
  1508  			if err := m.MaximumVolumeSize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1509  				return err
  1510  			}
  1511  			iNdEx = postIndex
  1512  		default:
  1513  			iNdEx = preIndex
  1514  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1515  			if err != nil {
  1516  				return err
  1517  			}
  1518  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1519  				return ErrInvalidLengthGenerated
  1520  			}
  1521  			if (iNdEx + skippy) > l {
  1522  				return io.ErrUnexpectedEOF
  1523  			}
  1524  			iNdEx += skippy
  1525  		}
  1526  	}
  1527  
  1528  	if iNdEx > l {
  1529  		return io.ErrUnexpectedEOF
  1530  	}
  1531  	return nil
  1532  }
  1533  func (m *CSIStorageCapacityList) Unmarshal(dAtA []byte) error {
  1534  	l := len(dAtA)
  1535  	iNdEx := 0
  1536  	for iNdEx < l {
  1537  		preIndex := iNdEx
  1538  		var wire uint64
  1539  		for shift := uint(0); ; shift += 7 {
  1540  			if shift >= 64 {
  1541  				return ErrIntOverflowGenerated
  1542  			}
  1543  			if iNdEx >= l {
  1544  				return io.ErrUnexpectedEOF
  1545  			}
  1546  			b := dAtA[iNdEx]
  1547  			iNdEx++
  1548  			wire |= uint64(b&0x7F) << shift
  1549  			if b < 0x80 {
  1550  				break
  1551  			}
  1552  		}
  1553  		fieldNum := int32(wire >> 3)
  1554  		wireType := int(wire & 0x7)
  1555  		if wireType == 4 {
  1556  			return fmt.Errorf("proto: CSIStorageCapacityList: wiretype end group for non-group")
  1557  		}
  1558  		if fieldNum <= 0 {
  1559  			return fmt.Errorf("proto: CSIStorageCapacityList: illegal tag %d (wire type %d)", fieldNum, wire)
  1560  		}
  1561  		switch fieldNum {
  1562  		case 1:
  1563  			if wireType != 2 {
  1564  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1565  			}
  1566  			var msglen int
  1567  			for shift := uint(0); ; shift += 7 {
  1568  				if shift >= 64 {
  1569  					return ErrIntOverflowGenerated
  1570  				}
  1571  				if iNdEx >= l {
  1572  					return io.ErrUnexpectedEOF
  1573  				}
  1574  				b := dAtA[iNdEx]
  1575  				iNdEx++
  1576  				msglen |= int(b&0x7F) << shift
  1577  				if b < 0x80 {
  1578  					break
  1579  				}
  1580  			}
  1581  			if msglen < 0 {
  1582  				return ErrInvalidLengthGenerated
  1583  			}
  1584  			postIndex := iNdEx + msglen
  1585  			if postIndex < 0 {
  1586  				return ErrInvalidLengthGenerated
  1587  			}
  1588  			if postIndex > l {
  1589  				return io.ErrUnexpectedEOF
  1590  			}
  1591  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1592  				return err
  1593  			}
  1594  			iNdEx = postIndex
  1595  		case 2:
  1596  			if wireType != 2 {
  1597  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1598  			}
  1599  			var msglen int
  1600  			for shift := uint(0); ; shift += 7 {
  1601  				if shift >= 64 {
  1602  					return ErrIntOverflowGenerated
  1603  				}
  1604  				if iNdEx >= l {
  1605  					return io.ErrUnexpectedEOF
  1606  				}
  1607  				b := dAtA[iNdEx]
  1608  				iNdEx++
  1609  				msglen |= int(b&0x7F) << shift
  1610  				if b < 0x80 {
  1611  					break
  1612  				}
  1613  			}
  1614  			if msglen < 0 {
  1615  				return ErrInvalidLengthGenerated
  1616  			}
  1617  			postIndex := iNdEx + msglen
  1618  			if postIndex < 0 {
  1619  				return ErrInvalidLengthGenerated
  1620  			}
  1621  			if postIndex > l {
  1622  				return io.ErrUnexpectedEOF
  1623  			}
  1624  			m.Items = append(m.Items, CSIStorageCapacity{})
  1625  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1626  				return err
  1627  			}
  1628  			iNdEx = postIndex
  1629  		default:
  1630  			iNdEx = preIndex
  1631  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1632  			if err != nil {
  1633  				return err
  1634  			}
  1635  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1636  				return ErrInvalidLengthGenerated
  1637  			}
  1638  			if (iNdEx + skippy) > l {
  1639  				return io.ErrUnexpectedEOF
  1640  			}
  1641  			iNdEx += skippy
  1642  		}
  1643  	}
  1644  
  1645  	if iNdEx > l {
  1646  		return io.ErrUnexpectedEOF
  1647  	}
  1648  	return nil
  1649  }
  1650  func (m *VolumeAttachment) Unmarshal(dAtA []byte) error {
  1651  	l := len(dAtA)
  1652  	iNdEx := 0
  1653  	for iNdEx < l {
  1654  		preIndex := iNdEx
  1655  		var wire uint64
  1656  		for shift := uint(0); ; shift += 7 {
  1657  			if shift >= 64 {
  1658  				return ErrIntOverflowGenerated
  1659  			}
  1660  			if iNdEx >= l {
  1661  				return io.ErrUnexpectedEOF
  1662  			}
  1663  			b := dAtA[iNdEx]
  1664  			iNdEx++
  1665  			wire |= uint64(b&0x7F) << shift
  1666  			if b < 0x80 {
  1667  				break
  1668  			}
  1669  		}
  1670  		fieldNum := int32(wire >> 3)
  1671  		wireType := int(wire & 0x7)
  1672  		if wireType == 4 {
  1673  			return fmt.Errorf("proto: VolumeAttachment: wiretype end group for non-group")
  1674  		}
  1675  		if fieldNum <= 0 {
  1676  			return fmt.Errorf("proto: VolumeAttachment: illegal tag %d (wire type %d)", fieldNum, wire)
  1677  		}
  1678  		switch fieldNum {
  1679  		case 1:
  1680  			if wireType != 2 {
  1681  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1682  			}
  1683  			var msglen int
  1684  			for shift := uint(0); ; shift += 7 {
  1685  				if shift >= 64 {
  1686  					return ErrIntOverflowGenerated
  1687  				}
  1688  				if iNdEx >= l {
  1689  					return io.ErrUnexpectedEOF
  1690  				}
  1691  				b := dAtA[iNdEx]
  1692  				iNdEx++
  1693  				msglen |= int(b&0x7F) << shift
  1694  				if b < 0x80 {
  1695  					break
  1696  				}
  1697  			}
  1698  			if msglen < 0 {
  1699  				return ErrInvalidLengthGenerated
  1700  			}
  1701  			postIndex := iNdEx + msglen
  1702  			if postIndex < 0 {
  1703  				return ErrInvalidLengthGenerated
  1704  			}
  1705  			if postIndex > l {
  1706  				return io.ErrUnexpectedEOF
  1707  			}
  1708  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1709  				return err
  1710  			}
  1711  			iNdEx = postIndex
  1712  		case 2:
  1713  			if wireType != 2 {
  1714  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  1715  			}
  1716  			var msglen int
  1717  			for shift := uint(0); ; shift += 7 {
  1718  				if shift >= 64 {
  1719  					return ErrIntOverflowGenerated
  1720  				}
  1721  				if iNdEx >= l {
  1722  					return io.ErrUnexpectedEOF
  1723  				}
  1724  				b := dAtA[iNdEx]
  1725  				iNdEx++
  1726  				msglen |= int(b&0x7F) << shift
  1727  				if b < 0x80 {
  1728  					break
  1729  				}
  1730  			}
  1731  			if msglen < 0 {
  1732  				return ErrInvalidLengthGenerated
  1733  			}
  1734  			postIndex := iNdEx + msglen
  1735  			if postIndex < 0 {
  1736  				return ErrInvalidLengthGenerated
  1737  			}
  1738  			if postIndex > l {
  1739  				return io.ErrUnexpectedEOF
  1740  			}
  1741  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1742  				return err
  1743  			}
  1744  			iNdEx = postIndex
  1745  		case 3:
  1746  			if wireType != 2 {
  1747  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  1748  			}
  1749  			var msglen int
  1750  			for shift := uint(0); ; shift += 7 {
  1751  				if shift >= 64 {
  1752  					return ErrIntOverflowGenerated
  1753  				}
  1754  				if iNdEx >= l {
  1755  					return io.ErrUnexpectedEOF
  1756  				}
  1757  				b := dAtA[iNdEx]
  1758  				iNdEx++
  1759  				msglen |= int(b&0x7F) << shift
  1760  				if b < 0x80 {
  1761  					break
  1762  				}
  1763  			}
  1764  			if msglen < 0 {
  1765  				return ErrInvalidLengthGenerated
  1766  			}
  1767  			postIndex := iNdEx + msglen
  1768  			if postIndex < 0 {
  1769  				return ErrInvalidLengthGenerated
  1770  			}
  1771  			if postIndex > l {
  1772  				return io.ErrUnexpectedEOF
  1773  			}
  1774  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1775  				return err
  1776  			}
  1777  			iNdEx = postIndex
  1778  		default:
  1779  			iNdEx = preIndex
  1780  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1781  			if err != nil {
  1782  				return err
  1783  			}
  1784  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1785  				return ErrInvalidLengthGenerated
  1786  			}
  1787  			if (iNdEx + skippy) > l {
  1788  				return io.ErrUnexpectedEOF
  1789  			}
  1790  			iNdEx += skippy
  1791  		}
  1792  	}
  1793  
  1794  	if iNdEx > l {
  1795  		return io.ErrUnexpectedEOF
  1796  	}
  1797  	return nil
  1798  }
  1799  func (m *VolumeAttachmentList) Unmarshal(dAtA []byte) error {
  1800  	l := len(dAtA)
  1801  	iNdEx := 0
  1802  	for iNdEx < l {
  1803  		preIndex := iNdEx
  1804  		var wire uint64
  1805  		for shift := uint(0); ; shift += 7 {
  1806  			if shift >= 64 {
  1807  				return ErrIntOverflowGenerated
  1808  			}
  1809  			if iNdEx >= l {
  1810  				return io.ErrUnexpectedEOF
  1811  			}
  1812  			b := dAtA[iNdEx]
  1813  			iNdEx++
  1814  			wire |= uint64(b&0x7F) << shift
  1815  			if b < 0x80 {
  1816  				break
  1817  			}
  1818  		}
  1819  		fieldNum := int32(wire >> 3)
  1820  		wireType := int(wire & 0x7)
  1821  		if wireType == 4 {
  1822  			return fmt.Errorf("proto: VolumeAttachmentList: wiretype end group for non-group")
  1823  		}
  1824  		if fieldNum <= 0 {
  1825  			return fmt.Errorf("proto: VolumeAttachmentList: illegal tag %d (wire type %d)", fieldNum, wire)
  1826  		}
  1827  		switch fieldNum {
  1828  		case 1:
  1829  			if wireType != 2 {
  1830  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1831  			}
  1832  			var msglen int
  1833  			for shift := uint(0); ; shift += 7 {
  1834  				if shift >= 64 {
  1835  					return ErrIntOverflowGenerated
  1836  				}
  1837  				if iNdEx >= l {
  1838  					return io.ErrUnexpectedEOF
  1839  				}
  1840  				b := dAtA[iNdEx]
  1841  				iNdEx++
  1842  				msglen |= int(b&0x7F) << shift
  1843  				if b < 0x80 {
  1844  					break
  1845  				}
  1846  			}
  1847  			if msglen < 0 {
  1848  				return ErrInvalidLengthGenerated
  1849  			}
  1850  			postIndex := iNdEx + msglen
  1851  			if postIndex < 0 {
  1852  				return ErrInvalidLengthGenerated
  1853  			}
  1854  			if postIndex > l {
  1855  				return io.ErrUnexpectedEOF
  1856  			}
  1857  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1858  				return err
  1859  			}
  1860  			iNdEx = postIndex
  1861  		case 2:
  1862  			if wireType != 2 {
  1863  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1864  			}
  1865  			var msglen int
  1866  			for shift := uint(0); ; shift += 7 {
  1867  				if shift >= 64 {
  1868  					return ErrIntOverflowGenerated
  1869  				}
  1870  				if iNdEx >= l {
  1871  					return io.ErrUnexpectedEOF
  1872  				}
  1873  				b := dAtA[iNdEx]
  1874  				iNdEx++
  1875  				msglen |= int(b&0x7F) << shift
  1876  				if b < 0x80 {
  1877  					break
  1878  				}
  1879  			}
  1880  			if msglen < 0 {
  1881  				return ErrInvalidLengthGenerated
  1882  			}
  1883  			postIndex := iNdEx + msglen
  1884  			if postIndex < 0 {
  1885  				return ErrInvalidLengthGenerated
  1886  			}
  1887  			if postIndex > l {
  1888  				return io.ErrUnexpectedEOF
  1889  			}
  1890  			m.Items = append(m.Items, VolumeAttachment{})
  1891  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1892  				return err
  1893  			}
  1894  			iNdEx = postIndex
  1895  		default:
  1896  			iNdEx = preIndex
  1897  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1898  			if err != nil {
  1899  				return err
  1900  			}
  1901  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1902  				return ErrInvalidLengthGenerated
  1903  			}
  1904  			if (iNdEx + skippy) > l {
  1905  				return io.ErrUnexpectedEOF
  1906  			}
  1907  			iNdEx += skippy
  1908  		}
  1909  	}
  1910  
  1911  	if iNdEx > l {
  1912  		return io.ErrUnexpectedEOF
  1913  	}
  1914  	return nil
  1915  }
  1916  func (m *VolumeAttachmentSource) Unmarshal(dAtA []byte) error {
  1917  	l := len(dAtA)
  1918  	iNdEx := 0
  1919  	for iNdEx < l {
  1920  		preIndex := iNdEx
  1921  		var wire uint64
  1922  		for shift := uint(0); ; shift += 7 {
  1923  			if shift >= 64 {
  1924  				return ErrIntOverflowGenerated
  1925  			}
  1926  			if iNdEx >= l {
  1927  				return io.ErrUnexpectedEOF
  1928  			}
  1929  			b := dAtA[iNdEx]
  1930  			iNdEx++
  1931  			wire |= uint64(b&0x7F) << shift
  1932  			if b < 0x80 {
  1933  				break
  1934  			}
  1935  		}
  1936  		fieldNum := int32(wire >> 3)
  1937  		wireType := int(wire & 0x7)
  1938  		if wireType == 4 {
  1939  			return fmt.Errorf("proto: VolumeAttachmentSource: wiretype end group for non-group")
  1940  		}
  1941  		if fieldNum <= 0 {
  1942  			return fmt.Errorf("proto: VolumeAttachmentSource: illegal tag %d (wire type %d)", fieldNum, wire)
  1943  		}
  1944  		switch fieldNum {
  1945  		case 1:
  1946  			if wireType != 2 {
  1947  				return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeName", wireType)
  1948  			}
  1949  			var stringLen uint64
  1950  			for shift := uint(0); ; shift += 7 {
  1951  				if shift >= 64 {
  1952  					return ErrIntOverflowGenerated
  1953  				}
  1954  				if iNdEx >= l {
  1955  					return io.ErrUnexpectedEOF
  1956  				}
  1957  				b := dAtA[iNdEx]
  1958  				iNdEx++
  1959  				stringLen |= uint64(b&0x7F) << shift
  1960  				if b < 0x80 {
  1961  					break
  1962  				}
  1963  			}
  1964  			intStringLen := int(stringLen)
  1965  			if intStringLen < 0 {
  1966  				return ErrInvalidLengthGenerated
  1967  			}
  1968  			postIndex := iNdEx + intStringLen
  1969  			if postIndex < 0 {
  1970  				return ErrInvalidLengthGenerated
  1971  			}
  1972  			if postIndex > l {
  1973  				return io.ErrUnexpectedEOF
  1974  			}
  1975  			s := string(dAtA[iNdEx:postIndex])
  1976  			m.PersistentVolumeName = &s
  1977  			iNdEx = postIndex
  1978  		case 2:
  1979  			if wireType != 2 {
  1980  				return fmt.Errorf("proto: wrong wireType = %d for field InlineVolumeSpec", wireType)
  1981  			}
  1982  			var msglen int
  1983  			for shift := uint(0); ; shift += 7 {
  1984  				if shift >= 64 {
  1985  					return ErrIntOverflowGenerated
  1986  				}
  1987  				if iNdEx >= l {
  1988  					return io.ErrUnexpectedEOF
  1989  				}
  1990  				b := dAtA[iNdEx]
  1991  				iNdEx++
  1992  				msglen |= int(b&0x7F) << shift
  1993  				if b < 0x80 {
  1994  					break
  1995  				}
  1996  			}
  1997  			if msglen < 0 {
  1998  				return ErrInvalidLengthGenerated
  1999  			}
  2000  			postIndex := iNdEx + msglen
  2001  			if postIndex < 0 {
  2002  				return ErrInvalidLengthGenerated
  2003  			}
  2004  			if postIndex > l {
  2005  				return io.ErrUnexpectedEOF
  2006  			}
  2007  			if m.InlineVolumeSpec == nil {
  2008  				m.InlineVolumeSpec = &v11.PersistentVolumeSpec{}
  2009  			}
  2010  			if err := m.InlineVolumeSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2011  				return err
  2012  			}
  2013  			iNdEx = postIndex
  2014  		default:
  2015  			iNdEx = preIndex
  2016  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2017  			if err != nil {
  2018  				return err
  2019  			}
  2020  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2021  				return ErrInvalidLengthGenerated
  2022  			}
  2023  			if (iNdEx + skippy) > l {
  2024  				return io.ErrUnexpectedEOF
  2025  			}
  2026  			iNdEx += skippy
  2027  		}
  2028  	}
  2029  
  2030  	if iNdEx > l {
  2031  		return io.ErrUnexpectedEOF
  2032  	}
  2033  	return nil
  2034  }
  2035  func (m *VolumeAttachmentSpec) Unmarshal(dAtA []byte) error {
  2036  	l := len(dAtA)
  2037  	iNdEx := 0
  2038  	for iNdEx < l {
  2039  		preIndex := iNdEx
  2040  		var wire uint64
  2041  		for shift := uint(0); ; shift += 7 {
  2042  			if shift >= 64 {
  2043  				return ErrIntOverflowGenerated
  2044  			}
  2045  			if iNdEx >= l {
  2046  				return io.ErrUnexpectedEOF
  2047  			}
  2048  			b := dAtA[iNdEx]
  2049  			iNdEx++
  2050  			wire |= uint64(b&0x7F) << shift
  2051  			if b < 0x80 {
  2052  				break
  2053  			}
  2054  		}
  2055  		fieldNum := int32(wire >> 3)
  2056  		wireType := int(wire & 0x7)
  2057  		if wireType == 4 {
  2058  			return fmt.Errorf("proto: VolumeAttachmentSpec: wiretype end group for non-group")
  2059  		}
  2060  		if fieldNum <= 0 {
  2061  			return fmt.Errorf("proto: VolumeAttachmentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  2062  		}
  2063  		switch fieldNum {
  2064  		case 1:
  2065  			if wireType != 2 {
  2066  				return fmt.Errorf("proto: wrong wireType = %d for field Attacher", wireType)
  2067  			}
  2068  			var stringLen uint64
  2069  			for shift := uint(0); ; shift += 7 {
  2070  				if shift >= 64 {
  2071  					return ErrIntOverflowGenerated
  2072  				}
  2073  				if iNdEx >= l {
  2074  					return io.ErrUnexpectedEOF
  2075  				}
  2076  				b := dAtA[iNdEx]
  2077  				iNdEx++
  2078  				stringLen |= uint64(b&0x7F) << shift
  2079  				if b < 0x80 {
  2080  					break
  2081  				}
  2082  			}
  2083  			intStringLen := int(stringLen)
  2084  			if intStringLen < 0 {
  2085  				return ErrInvalidLengthGenerated
  2086  			}
  2087  			postIndex := iNdEx + intStringLen
  2088  			if postIndex < 0 {
  2089  				return ErrInvalidLengthGenerated
  2090  			}
  2091  			if postIndex > l {
  2092  				return io.ErrUnexpectedEOF
  2093  			}
  2094  			m.Attacher = string(dAtA[iNdEx:postIndex])
  2095  			iNdEx = postIndex
  2096  		case 2:
  2097  			if wireType != 2 {
  2098  				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
  2099  			}
  2100  			var msglen int
  2101  			for shift := uint(0); ; shift += 7 {
  2102  				if shift >= 64 {
  2103  					return ErrIntOverflowGenerated
  2104  				}
  2105  				if iNdEx >= l {
  2106  					return io.ErrUnexpectedEOF
  2107  				}
  2108  				b := dAtA[iNdEx]
  2109  				iNdEx++
  2110  				msglen |= int(b&0x7F) << shift
  2111  				if b < 0x80 {
  2112  					break
  2113  				}
  2114  			}
  2115  			if msglen < 0 {
  2116  				return ErrInvalidLengthGenerated
  2117  			}
  2118  			postIndex := iNdEx + msglen
  2119  			if postIndex < 0 {
  2120  				return ErrInvalidLengthGenerated
  2121  			}
  2122  			if postIndex > l {
  2123  				return io.ErrUnexpectedEOF
  2124  			}
  2125  			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2126  				return err
  2127  			}
  2128  			iNdEx = postIndex
  2129  		case 3:
  2130  			if wireType != 2 {
  2131  				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
  2132  			}
  2133  			var stringLen uint64
  2134  			for shift := uint(0); ; shift += 7 {
  2135  				if shift >= 64 {
  2136  					return ErrIntOverflowGenerated
  2137  				}
  2138  				if iNdEx >= l {
  2139  					return io.ErrUnexpectedEOF
  2140  				}
  2141  				b := dAtA[iNdEx]
  2142  				iNdEx++
  2143  				stringLen |= uint64(b&0x7F) << shift
  2144  				if b < 0x80 {
  2145  					break
  2146  				}
  2147  			}
  2148  			intStringLen := int(stringLen)
  2149  			if intStringLen < 0 {
  2150  				return ErrInvalidLengthGenerated
  2151  			}
  2152  			postIndex := iNdEx + intStringLen
  2153  			if postIndex < 0 {
  2154  				return ErrInvalidLengthGenerated
  2155  			}
  2156  			if postIndex > l {
  2157  				return io.ErrUnexpectedEOF
  2158  			}
  2159  			m.NodeName = string(dAtA[iNdEx:postIndex])
  2160  			iNdEx = postIndex
  2161  		default:
  2162  			iNdEx = preIndex
  2163  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2164  			if err != nil {
  2165  				return err
  2166  			}
  2167  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2168  				return ErrInvalidLengthGenerated
  2169  			}
  2170  			if (iNdEx + skippy) > l {
  2171  				return io.ErrUnexpectedEOF
  2172  			}
  2173  			iNdEx += skippy
  2174  		}
  2175  	}
  2176  
  2177  	if iNdEx > l {
  2178  		return io.ErrUnexpectedEOF
  2179  	}
  2180  	return nil
  2181  }
  2182  func (m *VolumeAttachmentStatus) Unmarshal(dAtA []byte) error {
  2183  	l := len(dAtA)
  2184  	iNdEx := 0
  2185  	for iNdEx < l {
  2186  		preIndex := iNdEx
  2187  		var wire uint64
  2188  		for shift := uint(0); ; shift += 7 {
  2189  			if shift >= 64 {
  2190  				return ErrIntOverflowGenerated
  2191  			}
  2192  			if iNdEx >= l {
  2193  				return io.ErrUnexpectedEOF
  2194  			}
  2195  			b := dAtA[iNdEx]
  2196  			iNdEx++
  2197  			wire |= uint64(b&0x7F) << shift
  2198  			if b < 0x80 {
  2199  				break
  2200  			}
  2201  		}
  2202  		fieldNum := int32(wire >> 3)
  2203  		wireType := int(wire & 0x7)
  2204  		if wireType == 4 {
  2205  			return fmt.Errorf("proto: VolumeAttachmentStatus: wiretype end group for non-group")
  2206  		}
  2207  		if fieldNum <= 0 {
  2208  			return fmt.Errorf("proto: VolumeAttachmentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  2209  		}
  2210  		switch fieldNum {
  2211  		case 1:
  2212  			if wireType != 0 {
  2213  				return fmt.Errorf("proto: wrong wireType = %d for field Attached", wireType)
  2214  			}
  2215  			var v int
  2216  			for shift := uint(0); ; shift += 7 {
  2217  				if shift >= 64 {
  2218  					return ErrIntOverflowGenerated
  2219  				}
  2220  				if iNdEx >= l {
  2221  					return io.ErrUnexpectedEOF
  2222  				}
  2223  				b := dAtA[iNdEx]
  2224  				iNdEx++
  2225  				v |= int(b&0x7F) << shift
  2226  				if b < 0x80 {
  2227  					break
  2228  				}
  2229  			}
  2230  			m.Attached = bool(v != 0)
  2231  		case 2:
  2232  			if wireType != 2 {
  2233  				return fmt.Errorf("proto: wrong wireType = %d for field AttachmentMetadata", wireType)
  2234  			}
  2235  			var msglen int
  2236  			for shift := uint(0); ; shift += 7 {
  2237  				if shift >= 64 {
  2238  					return ErrIntOverflowGenerated
  2239  				}
  2240  				if iNdEx >= l {
  2241  					return io.ErrUnexpectedEOF
  2242  				}
  2243  				b := dAtA[iNdEx]
  2244  				iNdEx++
  2245  				msglen |= int(b&0x7F) << shift
  2246  				if b < 0x80 {
  2247  					break
  2248  				}
  2249  			}
  2250  			if msglen < 0 {
  2251  				return ErrInvalidLengthGenerated
  2252  			}
  2253  			postIndex := iNdEx + msglen
  2254  			if postIndex < 0 {
  2255  				return ErrInvalidLengthGenerated
  2256  			}
  2257  			if postIndex > l {
  2258  				return io.ErrUnexpectedEOF
  2259  			}
  2260  			if m.AttachmentMetadata == nil {
  2261  				m.AttachmentMetadata = make(map[string]string)
  2262  			}
  2263  			var mapkey string
  2264  			var mapvalue string
  2265  			for iNdEx < postIndex {
  2266  				entryPreIndex := iNdEx
  2267  				var wire uint64
  2268  				for shift := uint(0); ; shift += 7 {
  2269  					if shift >= 64 {
  2270  						return ErrIntOverflowGenerated
  2271  					}
  2272  					if iNdEx >= l {
  2273  						return io.ErrUnexpectedEOF
  2274  					}
  2275  					b := dAtA[iNdEx]
  2276  					iNdEx++
  2277  					wire |= uint64(b&0x7F) << shift
  2278  					if b < 0x80 {
  2279  						break
  2280  					}
  2281  				}
  2282  				fieldNum := int32(wire >> 3)
  2283  				if fieldNum == 1 {
  2284  					var stringLenmapkey uint64
  2285  					for shift := uint(0); ; shift += 7 {
  2286  						if shift >= 64 {
  2287  							return ErrIntOverflowGenerated
  2288  						}
  2289  						if iNdEx >= l {
  2290  							return io.ErrUnexpectedEOF
  2291  						}
  2292  						b := dAtA[iNdEx]
  2293  						iNdEx++
  2294  						stringLenmapkey |= uint64(b&0x7F) << shift
  2295  						if b < 0x80 {
  2296  							break
  2297  						}
  2298  					}
  2299  					intStringLenmapkey := int(stringLenmapkey)
  2300  					if intStringLenmapkey < 0 {
  2301  						return ErrInvalidLengthGenerated
  2302  					}
  2303  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  2304  					if postStringIndexmapkey < 0 {
  2305  						return ErrInvalidLengthGenerated
  2306  					}
  2307  					if postStringIndexmapkey > l {
  2308  						return io.ErrUnexpectedEOF
  2309  					}
  2310  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  2311  					iNdEx = postStringIndexmapkey
  2312  				} else if fieldNum == 2 {
  2313  					var stringLenmapvalue uint64
  2314  					for shift := uint(0); ; shift += 7 {
  2315  						if shift >= 64 {
  2316  							return ErrIntOverflowGenerated
  2317  						}
  2318  						if iNdEx >= l {
  2319  							return io.ErrUnexpectedEOF
  2320  						}
  2321  						b := dAtA[iNdEx]
  2322  						iNdEx++
  2323  						stringLenmapvalue |= uint64(b&0x7F) << shift
  2324  						if b < 0x80 {
  2325  							break
  2326  						}
  2327  					}
  2328  					intStringLenmapvalue := int(stringLenmapvalue)
  2329  					if intStringLenmapvalue < 0 {
  2330  						return ErrInvalidLengthGenerated
  2331  					}
  2332  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  2333  					if postStringIndexmapvalue < 0 {
  2334  						return ErrInvalidLengthGenerated
  2335  					}
  2336  					if postStringIndexmapvalue > l {
  2337  						return io.ErrUnexpectedEOF
  2338  					}
  2339  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  2340  					iNdEx = postStringIndexmapvalue
  2341  				} else {
  2342  					iNdEx = entryPreIndex
  2343  					skippy, err := skipGenerated(dAtA[iNdEx:])
  2344  					if err != nil {
  2345  						return err
  2346  					}
  2347  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  2348  						return ErrInvalidLengthGenerated
  2349  					}
  2350  					if (iNdEx + skippy) > postIndex {
  2351  						return io.ErrUnexpectedEOF
  2352  					}
  2353  					iNdEx += skippy
  2354  				}
  2355  			}
  2356  			m.AttachmentMetadata[mapkey] = mapvalue
  2357  			iNdEx = postIndex
  2358  		case 3:
  2359  			if wireType != 2 {
  2360  				return fmt.Errorf("proto: wrong wireType = %d for field AttachError", wireType)
  2361  			}
  2362  			var msglen int
  2363  			for shift := uint(0); ; shift += 7 {
  2364  				if shift >= 64 {
  2365  					return ErrIntOverflowGenerated
  2366  				}
  2367  				if iNdEx >= l {
  2368  					return io.ErrUnexpectedEOF
  2369  				}
  2370  				b := dAtA[iNdEx]
  2371  				iNdEx++
  2372  				msglen |= int(b&0x7F) << shift
  2373  				if b < 0x80 {
  2374  					break
  2375  				}
  2376  			}
  2377  			if msglen < 0 {
  2378  				return ErrInvalidLengthGenerated
  2379  			}
  2380  			postIndex := iNdEx + msglen
  2381  			if postIndex < 0 {
  2382  				return ErrInvalidLengthGenerated
  2383  			}
  2384  			if postIndex > l {
  2385  				return io.ErrUnexpectedEOF
  2386  			}
  2387  			if m.AttachError == nil {
  2388  				m.AttachError = &VolumeError{}
  2389  			}
  2390  			if err := m.AttachError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2391  				return err
  2392  			}
  2393  			iNdEx = postIndex
  2394  		case 4:
  2395  			if wireType != 2 {
  2396  				return fmt.Errorf("proto: wrong wireType = %d for field DetachError", wireType)
  2397  			}
  2398  			var msglen int
  2399  			for shift := uint(0); ; shift += 7 {
  2400  				if shift >= 64 {
  2401  					return ErrIntOverflowGenerated
  2402  				}
  2403  				if iNdEx >= l {
  2404  					return io.ErrUnexpectedEOF
  2405  				}
  2406  				b := dAtA[iNdEx]
  2407  				iNdEx++
  2408  				msglen |= int(b&0x7F) << shift
  2409  				if b < 0x80 {
  2410  					break
  2411  				}
  2412  			}
  2413  			if msglen < 0 {
  2414  				return ErrInvalidLengthGenerated
  2415  			}
  2416  			postIndex := iNdEx + msglen
  2417  			if postIndex < 0 {
  2418  				return ErrInvalidLengthGenerated
  2419  			}
  2420  			if postIndex > l {
  2421  				return io.ErrUnexpectedEOF
  2422  			}
  2423  			if m.DetachError == nil {
  2424  				m.DetachError = &VolumeError{}
  2425  			}
  2426  			if err := m.DetachError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2427  				return err
  2428  			}
  2429  			iNdEx = postIndex
  2430  		default:
  2431  			iNdEx = preIndex
  2432  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2433  			if err != nil {
  2434  				return err
  2435  			}
  2436  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2437  				return ErrInvalidLengthGenerated
  2438  			}
  2439  			if (iNdEx + skippy) > l {
  2440  				return io.ErrUnexpectedEOF
  2441  			}
  2442  			iNdEx += skippy
  2443  		}
  2444  	}
  2445  
  2446  	if iNdEx > l {
  2447  		return io.ErrUnexpectedEOF
  2448  	}
  2449  	return nil
  2450  }
  2451  func (m *VolumeAttributesClass) Unmarshal(dAtA []byte) error {
  2452  	l := len(dAtA)
  2453  	iNdEx := 0
  2454  	for iNdEx < l {
  2455  		preIndex := iNdEx
  2456  		var wire uint64
  2457  		for shift := uint(0); ; shift += 7 {
  2458  			if shift >= 64 {
  2459  				return ErrIntOverflowGenerated
  2460  			}
  2461  			if iNdEx >= l {
  2462  				return io.ErrUnexpectedEOF
  2463  			}
  2464  			b := dAtA[iNdEx]
  2465  			iNdEx++
  2466  			wire |= uint64(b&0x7F) << shift
  2467  			if b < 0x80 {
  2468  				break
  2469  			}
  2470  		}
  2471  		fieldNum := int32(wire >> 3)
  2472  		wireType := int(wire & 0x7)
  2473  		if wireType == 4 {
  2474  			return fmt.Errorf("proto: VolumeAttributesClass: wiretype end group for non-group")
  2475  		}
  2476  		if fieldNum <= 0 {
  2477  			return fmt.Errorf("proto: VolumeAttributesClass: illegal tag %d (wire type %d)", fieldNum, wire)
  2478  		}
  2479  		switch fieldNum {
  2480  		case 1:
  2481  			if wireType != 2 {
  2482  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  2483  			}
  2484  			var msglen int
  2485  			for shift := uint(0); ; shift += 7 {
  2486  				if shift >= 64 {
  2487  					return ErrIntOverflowGenerated
  2488  				}
  2489  				if iNdEx >= l {
  2490  					return io.ErrUnexpectedEOF
  2491  				}
  2492  				b := dAtA[iNdEx]
  2493  				iNdEx++
  2494  				msglen |= int(b&0x7F) << shift
  2495  				if b < 0x80 {
  2496  					break
  2497  				}
  2498  			}
  2499  			if msglen < 0 {
  2500  				return ErrInvalidLengthGenerated
  2501  			}
  2502  			postIndex := iNdEx + msglen
  2503  			if postIndex < 0 {
  2504  				return ErrInvalidLengthGenerated
  2505  			}
  2506  			if postIndex > l {
  2507  				return io.ErrUnexpectedEOF
  2508  			}
  2509  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2510  				return err
  2511  			}
  2512  			iNdEx = postIndex
  2513  		case 2:
  2514  			if wireType != 2 {
  2515  				return fmt.Errorf("proto: wrong wireType = %d for field DriverName", wireType)
  2516  			}
  2517  			var stringLen uint64
  2518  			for shift := uint(0); ; shift += 7 {
  2519  				if shift >= 64 {
  2520  					return ErrIntOverflowGenerated
  2521  				}
  2522  				if iNdEx >= l {
  2523  					return io.ErrUnexpectedEOF
  2524  				}
  2525  				b := dAtA[iNdEx]
  2526  				iNdEx++
  2527  				stringLen |= uint64(b&0x7F) << shift
  2528  				if b < 0x80 {
  2529  					break
  2530  				}
  2531  			}
  2532  			intStringLen := int(stringLen)
  2533  			if intStringLen < 0 {
  2534  				return ErrInvalidLengthGenerated
  2535  			}
  2536  			postIndex := iNdEx + intStringLen
  2537  			if postIndex < 0 {
  2538  				return ErrInvalidLengthGenerated
  2539  			}
  2540  			if postIndex > l {
  2541  				return io.ErrUnexpectedEOF
  2542  			}
  2543  			m.DriverName = string(dAtA[iNdEx:postIndex])
  2544  			iNdEx = postIndex
  2545  		case 3:
  2546  			if wireType != 2 {
  2547  				return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
  2548  			}
  2549  			var msglen int
  2550  			for shift := uint(0); ; shift += 7 {
  2551  				if shift >= 64 {
  2552  					return ErrIntOverflowGenerated
  2553  				}
  2554  				if iNdEx >= l {
  2555  					return io.ErrUnexpectedEOF
  2556  				}
  2557  				b := dAtA[iNdEx]
  2558  				iNdEx++
  2559  				msglen |= int(b&0x7F) << shift
  2560  				if b < 0x80 {
  2561  					break
  2562  				}
  2563  			}
  2564  			if msglen < 0 {
  2565  				return ErrInvalidLengthGenerated
  2566  			}
  2567  			postIndex := iNdEx + msglen
  2568  			if postIndex < 0 {
  2569  				return ErrInvalidLengthGenerated
  2570  			}
  2571  			if postIndex > l {
  2572  				return io.ErrUnexpectedEOF
  2573  			}
  2574  			if m.Parameters == nil {
  2575  				m.Parameters = make(map[string]string)
  2576  			}
  2577  			var mapkey string
  2578  			var mapvalue string
  2579  			for iNdEx < postIndex {
  2580  				entryPreIndex := iNdEx
  2581  				var wire uint64
  2582  				for shift := uint(0); ; shift += 7 {
  2583  					if shift >= 64 {
  2584  						return ErrIntOverflowGenerated
  2585  					}
  2586  					if iNdEx >= l {
  2587  						return io.ErrUnexpectedEOF
  2588  					}
  2589  					b := dAtA[iNdEx]
  2590  					iNdEx++
  2591  					wire |= uint64(b&0x7F) << shift
  2592  					if b < 0x80 {
  2593  						break
  2594  					}
  2595  				}
  2596  				fieldNum := int32(wire >> 3)
  2597  				if fieldNum == 1 {
  2598  					var stringLenmapkey uint64
  2599  					for shift := uint(0); ; shift += 7 {
  2600  						if shift >= 64 {
  2601  							return ErrIntOverflowGenerated
  2602  						}
  2603  						if iNdEx >= l {
  2604  							return io.ErrUnexpectedEOF
  2605  						}
  2606  						b := dAtA[iNdEx]
  2607  						iNdEx++
  2608  						stringLenmapkey |= uint64(b&0x7F) << shift
  2609  						if b < 0x80 {
  2610  							break
  2611  						}
  2612  					}
  2613  					intStringLenmapkey := int(stringLenmapkey)
  2614  					if intStringLenmapkey < 0 {
  2615  						return ErrInvalidLengthGenerated
  2616  					}
  2617  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  2618  					if postStringIndexmapkey < 0 {
  2619  						return ErrInvalidLengthGenerated
  2620  					}
  2621  					if postStringIndexmapkey > l {
  2622  						return io.ErrUnexpectedEOF
  2623  					}
  2624  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  2625  					iNdEx = postStringIndexmapkey
  2626  				} else if fieldNum == 2 {
  2627  					var stringLenmapvalue uint64
  2628  					for shift := uint(0); ; shift += 7 {
  2629  						if shift >= 64 {
  2630  							return ErrIntOverflowGenerated
  2631  						}
  2632  						if iNdEx >= l {
  2633  							return io.ErrUnexpectedEOF
  2634  						}
  2635  						b := dAtA[iNdEx]
  2636  						iNdEx++
  2637  						stringLenmapvalue |= uint64(b&0x7F) << shift
  2638  						if b < 0x80 {
  2639  							break
  2640  						}
  2641  					}
  2642  					intStringLenmapvalue := int(stringLenmapvalue)
  2643  					if intStringLenmapvalue < 0 {
  2644  						return ErrInvalidLengthGenerated
  2645  					}
  2646  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  2647  					if postStringIndexmapvalue < 0 {
  2648  						return ErrInvalidLengthGenerated
  2649  					}
  2650  					if postStringIndexmapvalue > l {
  2651  						return io.ErrUnexpectedEOF
  2652  					}
  2653  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  2654  					iNdEx = postStringIndexmapvalue
  2655  				} else {
  2656  					iNdEx = entryPreIndex
  2657  					skippy, err := skipGenerated(dAtA[iNdEx:])
  2658  					if err != nil {
  2659  						return err
  2660  					}
  2661  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  2662  						return ErrInvalidLengthGenerated
  2663  					}
  2664  					if (iNdEx + skippy) > postIndex {
  2665  						return io.ErrUnexpectedEOF
  2666  					}
  2667  					iNdEx += skippy
  2668  				}
  2669  			}
  2670  			m.Parameters[mapkey] = mapvalue
  2671  			iNdEx = postIndex
  2672  		default:
  2673  			iNdEx = preIndex
  2674  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2675  			if err != nil {
  2676  				return err
  2677  			}
  2678  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2679  				return ErrInvalidLengthGenerated
  2680  			}
  2681  			if (iNdEx + skippy) > l {
  2682  				return io.ErrUnexpectedEOF
  2683  			}
  2684  			iNdEx += skippy
  2685  		}
  2686  	}
  2687  
  2688  	if iNdEx > l {
  2689  		return io.ErrUnexpectedEOF
  2690  	}
  2691  	return nil
  2692  }
  2693  func (m *VolumeAttributesClassList) Unmarshal(dAtA []byte) error {
  2694  	l := len(dAtA)
  2695  	iNdEx := 0
  2696  	for iNdEx < l {
  2697  		preIndex := iNdEx
  2698  		var wire uint64
  2699  		for shift := uint(0); ; shift += 7 {
  2700  			if shift >= 64 {
  2701  				return ErrIntOverflowGenerated
  2702  			}
  2703  			if iNdEx >= l {
  2704  				return io.ErrUnexpectedEOF
  2705  			}
  2706  			b := dAtA[iNdEx]
  2707  			iNdEx++
  2708  			wire |= uint64(b&0x7F) << shift
  2709  			if b < 0x80 {
  2710  				break
  2711  			}
  2712  		}
  2713  		fieldNum := int32(wire >> 3)
  2714  		wireType := int(wire & 0x7)
  2715  		if wireType == 4 {
  2716  			return fmt.Errorf("proto: VolumeAttributesClassList: wiretype end group for non-group")
  2717  		}
  2718  		if fieldNum <= 0 {
  2719  			return fmt.Errorf("proto: VolumeAttributesClassList: illegal tag %d (wire type %d)", fieldNum, wire)
  2720  		}
  2721  		switch fieldNum {
  2722  		case 1:
  2723  			if wireType != 2 {
  2724  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  2725  			}
  2726  			var msglen int
  2727  			for shift := uint(0); ; shift += 7 {
  2728  				if shift >= 64 {
  2729  					return ErrIntOverflowGenerated
  2730  				}
  2731  				if iNdEx >= l {
  2732  					return io.ErrUnexpectedEOF
  2733  				}
  2734  				b := dAtA[iNdEx]
  2735  				iNdEx++
  2736  				msglen |= int(b&0x7F) << shift
  2737  				if b < 0x80 {
  2738  					break
  2739  				}
  2740  			}
  2741  			if msglen < 0 {
  2742  				return ErrInvalidLengthGenerated
  2743  			}
  2744  			postIndex := iNdEx + msglen
  2745  			if postIndex < 0 {
  2746  				return ErrInvalidLengthGenerated
  2747  			}
  2748  			if postIndex > l {
  2749  				return io.ErrUnexpectedEOF
  2750  			}
  2751  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2752  				return err
  2753  			}
  2754  			iNdEx = postIndex
  2755  		case 2:
  2756  			if wireType != 2 {
  2757  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  2758  			}
  2759  			var msglen int
  2760  			for shift := uint(0); ; shift += 7 {
  2761  				if shift >= 64 {
  2762  					return ErrIntOverflowGenerated
  2763  				}
  2764  				if iNdEx >= l {
  2765  					return io.ErrUnexpectedEOF
  2766  				}
  2767  				b := dAtA[iNdEx]
  2768  				iNdEx++
  2769  				msglen |= int(b&0x7F) << shift
  2770  				if b < 0x80 {
  2771  					break
  2772  				}
  2773  			}
  2774  			if msglen < 0 {
  2775  				return ErrInvalidLengthGenerated
  2776  			}
  2777  			postIndex := iNdEx + msglen
  2778  			if postIndex < 0 {
  2779  				return ErrInvalidLengthGenerated
  2780  			}
  2781  			if postIndex > l {
  2782  				return io.ErrUnexpectedEOF
  2783  			}
  2784  			m.Items = append(m.Items, VolumeAttributesClass{})
  2785  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2786  				return err
  2787  			}
  2788  			iNdEx = postIndex
  2789  		default:
  2790  			iNdEx = preIndex
  2791  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2792  			if err != nil {
  2793  				return err
  2794  			}
  2795  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2796  				return ErrInvalidLengthGenerated
  2797  			}
  2798  			if (iNdEx + skippy) > l {
  2799  				return io.ErrUnexpectedEOF
  2800  			}
  2801  			iNdEx += skippy
  2802  		}
  2803  	}
  2804  
  2805  	if iNdEx > l {
  2806  		return io.ErrUnexpectedEOF
  2807  	}
  2808  	return nil
  2809  }
  2810  func (m *VolumeError) Unmarshal(dAtA []byte) error {
  2811  	l := len(dAtA)
  2812  	iNdEx := 0
  2813  	for iNdEx < l {
  2814  		preIndex := iNdEx
  2815  		var wire uint64
  2816  		for shift := uint(0); ; shift += 7 {
  2817  			if shift >= 64 {
  2818  				return ErrIntOverflowGenerated
  2819  			}
  2820  			if iNdEx >= l {
  2821  				return io.ErrUnexpectedEOF
  2822  			}
  2823  			b := dAtA[iNdEx]
  2824  			iNdEx++
  2825  			wire |= uint64(b&0x7F) << shift
  2826  			if b < 0x80 {
  2827  				break
  2828  			}
  2829  		}
  2830  		fieldNum := int32(wire >> 3)
  2831  		wireType := int(wire & 0x7)
  2832  		if wireType == 4 {
  2833  			return fmt.Errorf("proto: VolumeError: wiretype end group for non-group")
  2834  		}
  2835  		if fieldNum <= 0 {
  2836  			return fmt.Errorf("proto: VolumeError: illegal tag %d (wire type %d)", fieldNum, wire)
  2837  		}
  2838  		switch fieldNum {
  2839  		case 1:
  2840  			if wireType != 2 {
  2841  				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
  2842  			}
  2843  			var msglen int
  2844  			for shift := uint(0); ; shift += 7 {
  2845  				if shift >= 64 {
  2846  					return ErrIntOverflowGenerated
  2847  				}
  2848  				if iNdEx >= l {
  2849  					return io.ErrUnexpectedEOF
  2850  				}
  2851  				b := dAtA[iNdEx]
  2852  				iNdEx++
  2853  				msglen |= int(b&0x7F) << shift
  2854  				if b < 0x80 {
  2855  					break
  2856  				}
  2857  			}
  2858  			if msglen < 0 {
  2859  				return ErrInvalidLengthGenerated
  2860  			}
  2861  			postIndex := iNdEx + msglen
  2862  			if postIndex < 0 {
  2863  				return ErrInvalidLengthGenerated
  2864  			}
  2865  			if postIndex > l {
  2866  				return io.ErrUnexpectedEOF
  2867  			}
  2868  			if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  2869  				return err
  2870  			}
  2871  			iNdEx = postIndex
  2872  		case 2:
  2873  			if wireType != 2 {
  2874  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  2875  			}
  2876  			var stringLen uint64
  2877  			for shift := uint(0); ; shift += 7 {
  2878  				if shift >= 64 {
  2879  					return ErrIntOverflowGenerated
  2880  				}
  2881  				if iNdEx >= l {
  2882  					return io.ErrUnexpectedEOF
  2883  				}
  2884  				b := dAtA[iNdEx]
  2885  				iNdEx++
  2886  				stringLen |= uint64(b&0x7F) << shift
  2887  				if b < 0x80 {
  2888  					break
  2889  				}
  2890  			}
  2891  			intStringLen := int(stringLen)
  2892  			if intStringLen < 0 {
  2893  				return ErrInvalidLengthGenerated
  2894  			}
  2895  			postIndex := iNdEx + intStringLen
  2896  			if postIndex < 0 {
  2897  				return ErrInvalidLengthGenerated
  2898  			}
  2899  			if postIndex > l {
  2900  				return io.ErrUnexpectedEOF
  2901  			}
  2902  			m.Message = string(dAtA[iNdEx:postIndex])
  2903  			iNdEx = postIndex
  2904  		default:
  2905  			iNdEx = preIndex
  2906  			skippy, err := skipGenerated(dAtA[iNdEx:])
  2907  			if err != nil {
  2908  				return err
  2909  			}
  2910  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  2911  				return ErrInvalidLengthGenerated
  2912  			}
  2913  			if (iNdEx + skippy) > l {
  2914  				return io.ErrUnexpectedEOF
  2915  			}
  2916  			iNdEx += skippy
  2917  		}
  2918  	}
  2919  
  2920  	if iNdEx > l {
  2921  		return io.ErrUnexpectedEOF
  2922  	}
  2923  	return nil
  2924  }
  2925  func skipGenerated(dAtA []byte) (n int, err error) {
  2926  	l := len(dAtA)
  2927  	iNdEx := 0
  2928  	depth := 0
  2929  	for iNdEx < l {
  2930  		var wire uint64
  2931  		for shift := uint(0); ; shift += 7 {
  2932  			if shift >= 64 {
  2933  				return 0, ErrIntOverflowGenerated
  2934  			}
  2935  			if iNdEx >= l {
  2936  				return 0, io.ErrUnexpectedEOF
  2937  			}
  2938  			b := dAtA[iNdEx]
  2939  			iNdEx++
  2940  			wire |= (uint64(b) & 0x7F) << shift
  2941  			if b < 0x80 {
  2942  				break
  2943  			}
  2944  		}
  2945  		wireType := int(wire & 0x7)
  2946  		switch wireType {
  2947  		case 0:
  2948  			for shift := uint(0); ; shift += 7 {
  2949  				if shift >= 64 {
  2950  					return 0, ErrIntOverflowGenerated
  2951  				}
  2952  				if iNdEx >= l {
  2953  					return 0, io.ErrUnexpectedEOF
  2954  				}
  2955  				iNdEx++
  2956  				if dAtA[iNdEx-1] < 0x80 {
  2957  					break
  2958  				}
  2959  			}
  2960  		case 1:
  2961  			iNdEx += 8
  2962  		case 2:
  2963  			var length int
  2964  			for shift := uint(0); ; shift += 7 {
  2965  				if shift >= 64 {
  2966  					return 0, ErrIntOverflowGenerated
  2967  				}
  2968  				if iNdEx >= l {
  2969  					return 0, io.ErrUnexpectedEOF
  2970  				}
  2971  				b := dAtA[iNdEx]
  2972  				iNdEx++
  2973  				length |= (int(b) & 0x7F) << shift
  2974  				if b < 0x80 {
  2975  					break
  2976  				}
  2977  			}
  2978  			if length < 0 {
  2979  				return 0, ErrInvalidLengthGenerated
  2980  			}
  2981  			iNdEx += length
  2982  		case 3:
  2983  			depth++
  2984  		case 4:
  2985  			if depth == 0 {
  2986  				return 0, ErrUnexpectedEndOfGroupGenerated
  2987  			}
  2988  			depth--
  2989  		case 5:
  2990  			iNdEx += 4
  2991  		default:
  2992  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  2993  		}
  2994  		if iNdEx < 0 {
  2995  			return 0, ErrInvalidLengthGenerated
  2996  		}
  2997  		if depth == 0 {
  2998  			return iNdEx, nil
  2999  		}
  3000  	}
  3001  	return 0, io.ErrUnexpectedEOF
  3002  }
  3003  
  3004  var (
  3005  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  3006  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  3007  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  3008  )
  3009  

View as plain text