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

Documentation: k8s.io/api/apiserverinternal/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/apiserverinternal/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  
    29  	math "math"
    30  	math_bits "math/bits"
    31  	reflect "reflect"
    32  	strings "strings"
    33  )
    34  
    35  // Reference imports to suppress errors if they are not otherwise used.
    36  var _ = proto.Marshal
    37  var _ = fmt.Errorf
    38  var _ = math.Inf
    39  
    40  // This is a compile-time assertion to ensure that this generated file
    41  // is compatible with the proto package it is being compiled against.
    42  // A compilation error at this line likely means your copy of the
    43  // proto package needs to be updated.
    44  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    45  
    46  func (m *ServerStorageVersion) Reset()      { *m = ServerStorageVersion{} }
    47  func (*ServerStorageVersion) ProtoMessage() {}
    48  func (*ServerStorageVersion) Descriptor() ([]byte, []int) {
    49  	return fileDescriptor_126bcbf538b54729, []int{0}
    50  }
    51  func (m *ServerStorageVersion) XXX_Unmarshal(b []byte) error {
    52  	return m.Unmarshal(b)
    53  }
    54  func (m *ServerStorageVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    55  	b = b[:cap(b)]
    56  	n, err := m.MarshalToSizedBuffer(b)
    57  	if err != nil {
    58  		return nil, err
    59  	}
    60  	return b[:n], nil
    61  }
    62  func (m *ServerStorageVersion) XXX_Merge(src proto.Message) {
    63  	xxx_messageInfo_ServerStorageVersion.Merge(m, src)
    64  }
    65  func (m *ServerStorageVersion) XXX_Size() int {
    66  	return m.Size()
    67  }
    68  func (m *ServerStorageVersion) XXX_DiscardUnknown() {
    69  	xxx_messageInfo_ServerStorageVersion.DiscardUnknown(m)
    70  }
    71  
    72  var xxx_messageInfo_ServerStorageVersion proto.InternalMessageInfo
    73  
    74  func (m *StorageVersion) Reset()      { *m = StorageVersion{} }
    75  func (*StorageVersion) ProtoMessage() {}
    76  func (*StorageVersion) Descriptor() ([]byte, []int) {
    77  	return fileDescriptor_126bcbf538b54729, []int{1}
    78  }
    79  func (m *StorageVersion) XXX_Unmarshal(b []byte) error {
    80  	return m.Unmarshal(b)
    81  }
    82  func (m *StorageVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    83  	b = b[:cap(b)]
    84  	n, err := m.MarshalToSizedBuffer(b)
    85  	if err != nil {
    86  		return nil, err
    87  	}
    88  	return b[:n], nil
    89  }
    90  func (m *StorageVersion) XXX_Merge(src proto.Message) {
    91  	xxx_messageInfo_StorageVersion.Merge(m, src)
    92  }
    93  func (m *StorageVersion) XXX_Size() int {
    94  	return m.Size()
    95  }
    96  func (m *StorageVersion) XXX_DiscardUnknown() {
    97  	xxx_messageInfo_StorageVersion.DiscardUnknown(m)
    98  }
    99  
   100  var xxx_messageInfo_StorageVersion proto.InternalMessageInfo
   101  
   102  func (m *StorageVersionCondition) Reset()      { *m = StorageVersionCondition{} }
   103  func (*StorageVersionCondition) ProtoMessage() {}
   104  func (*StorageVersionCondition) Descriptor() ([]byte, []int) {
   105  	return fileDescriptor_126bcbf538b54729, []int{2}
   106  }
   107  func (m *StorageVersionCondition) XXX_Unmarshal(b []byte) error {
   108  	return m.Unmarshal(b)
   109  }
   110  func (m *StorageVersionCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   111  	b = b[:cap(b)]
   112  	n, err := m.MarshalToSizedBuffer(b)
   113  	if err != nil {
   114  		return nil, err
   115  	}
   116  	return b[:n], nil
   117  }
   118  func (m *StorageVersionCondition) XXX_Merge(src proto.Message) {
   119  	xxx_messageInfo_StorageVersionCondition.Merge(m, src)
   120  }
   121  func (m *StorageVersionCondition) XXX_Size() int {
   122  	return m.Size()
   123  }
   124  func (m *StorageVersionCondition) XXX_DiscardUnknown() {
   125  	xxx_messageInfo_StorageVersionCondition.DiscardUnknown(m)
   126  }
   127  
   128  var xxx_messageInfo_StorageVersionCondition proto.InternalMessageInfo
   129  
   130  func (m *StorageVersionList) Reset()      { *m = StorageVersionList{} }
   131  func (*StorageVersionList) ProtoMessage() {}
   132  func (*StorageVersionList) Descriptor() ([]byte, []int) {
   133  	return fileDescriptor_126bcbf538b54729, []int{3}
   134  }
   135  func (m *StorageVersionList) XXX_Unmarshal(b []byte) error {
   136  	return m.Unmarshal(b)
   137  }
   138  func (m *StorageVersionList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   139  	b = b[:cap(b)]
   140  	n, err := m.MarshalToSizedBuffer(b)
   141  	if err != nil {
   142  		return nil, err
   143  	}
   144  	return b[:n], nil
   145  }
   146  func (m *StorageVersionList) XXX_Merge(src proto.Message) {
   147  	xxx_messageInfo_StorageVersionList.Merge(m, src)
   148  }
   149  func (m *StorageVersionList) XXX_Size() int {
   150  	return m.Size()
   151  }
   152  func (m *StorageVersionList) XXX_DiscardUnknown() {
   153  	xxx_messageInfo_StorageVersionList.DiscardUnknown(m)
   154  }
   155  
   156  var xxx_messageInfo_StorageVersionList proto.InternalMessageInfo
   157  
   158  func (m *StorageVersionSpec) Reset()      { *m = StorageVersionSpec{} }
   159  func (*StorageVersionSpec) ProtoMessage() {}
   160  func (*StorageVersionSpec) Descriptor() ([]byte, []int) {
   161  	return fileDescriptor_126bcbf538b54729, []int{4}
   162  }
   163  func (m *StorageVersionSpec) XXX_Unmarshal(b []byte) error {
   164  	return m.Unmarshal(b)
   165  }
   166  func (m *StorageVersionSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   167  	b = b[:cap(b)]
   168  	n, err := m.MarshalToSizedBuffer(b)
   169  	if err != nil {
   170  		return nil, err
   171  	}
   172  	return b[:n], nil
   173  }
   174  func (m *StorageVersionSpec) XXX_Merge(src proto.Message) {
   175  	xxx_messageInfo_StorageVersionSpec.Merge(m, src)
   176  }
   177  func (m *StorageVersionSpec) XXX_Size() int {
   178  	return m.Size()
   179  }
   180  func (m *StorageVersionSpec) XXX_DiscardUnknown() {
   181  	xxx_messageInfo_StorageVersionSpec.DiscardUnknown(m)
   182  }
   183  
   184  var xxx_messageInfo_StorageVersionSpec proto.InternalMessageInfo
   185  
   186  func (m *StorageVersionStatus) Reset()      { *m = StorageVersionStatus{} }
   187  func (*StorageVersionStatus) ProtoMessage() {}
   188  func (*StorageVersionStatus) Descriptor() ([]byte, []int) {
   189  	return fileDescriptor_126bcbf538b54729, []int{5}
   190  }
   191  func (m *StorageVersionStatus) XXX_Unmarshal(b []byte) error {
   192  	return m.Unmarshal(b)
   193  }
   194  func (m *StorageVersionStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   195  	b = b[:cap(b)]
   196  	n, err := m.MarshalToSizedBuffer(b)
   197  	if err != nil {
   198  		return nil, err
   199  	}
   200  	return b[:n], nil
   201  }
   202  func (m *StorageVersionStatus) XXX_Merge(src proto.Message) {
   203  	xxx_messageInfo_StorageVersionStatus.Merge(m, src)
   204  }
   205  func (m *StorageVersionStatus) XXX_Size() int {
   206  	return m.Size()
   207  }
   208  func (m *StorageVersionStatus) XXX_DiscardUnknown() {
   209  	xxx_messageInfo_StorageVersionStatus.DiscardUnknown(m)
   210  }
   211  
   212  var xxx_messageInfo_StorageVersionStatus proto.InternalMessageInfo
   213  
   214  func init() {
   215  	proto.RegisterType((*ServerStorageVersion)(nil), "k8s.io.api.apiserverinternal.v1alpha1.ServerStorageVersion")
   216  	proto.RegisterType((*StorageVersion)(nil), "k8s.io.api.apiserverinternal.v1alpha1.StorageVersion")
   217  	proto.RegisterType((*StorageVersionCondition)(nil), "k8s.io.api.apiserverinternal.v1alpha1.StorageVersionCondition")
   218  	proto.RegisterType((*StorageVersionList)(nil), "k8s.io.api.apiserverinternal.v1alpha1.StorageVersionList")
   219  	proto.RegisterType((*StorageVersionSpec)(nil), "k8s.io.api.apiserverinternal.v1alpha1.StorageVersionSpec")
   220  	proto.RegisterType((*StorageVersionStatus)(nil), "k8s.io.api.apiserverinternal.v1alpha1.StorageVersionStatus")
   221  }
   222  
   223  func init() {
   224  	proto.RegisterFile("k8s.io/api/apiserverinternal/v1alpha1/generated.proto", fileDescriptor_126bcbf538b54729)
   225  }
   226  
   227  var fileDescriptor_126bcbf538b54729 = []byte{
   228  	// 770 bytes of a gzipped FileDescriptorProto
   229  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0x41, 0x4f, 0x13, 0x41,
   230  	0x14, 0xee, 0xd2, 0x52, 0x60, 0xaa, 0xad, 0x8c, 0x10, 0x6a, 0x4d, 0xb6, 0xd8, 0x04, 0x83, 0x1a,
   231  	0x77, 0xa5, 0x11, 0x23, 0x9a, 0x68, 0x58, 0x20, 0x06, 0x85, 0x60, 0xa6, 0xc4, 0x03, 0x7a, 0x70,
   232  	0xba, 0x1d, 0xb7, 0x2b, 0xdd, 0x9d, 0xcd, 0xce, 0xb4, 0x09, 0x17, 0xe3, 0x4f, 0xd0, 0xff, 0xe1,
   233  	0xd1, 0x1f, 0xc1, 0xc9, 0x70, 0x24, 0x31, 0x69, 0x64, 0xfd, 0x17, 0x9c, 0xcc, 0xcc, 0x6e, 0xb7,
   234  	0x6c, 0x5b, 0x62, 0xc3, 0xa1, 0x49, 0xe7, 0xbd, 0xf7, 0x7d, 0xef, 0xcd, 0x37, 0xdf, 0xcc, 0x82,
   235  	0xd5, 0xc3, 0xa7, 0x4c, 0xb3, 0xa9, 0x8e, 0x3d, 0x5b, 0xfc, 0x18, 0xf1, 0x3b, 0xc4, 0xb7, 0x5d,
   236  	0x4e, 0x7c, 0x17, 0xb7, 0xf4, 0xce, 0x0a, 0x6e, 0x79, 0x4d, 0xbc, 0xa2, 0x5b, 0xc4, 0x25, 0x3e,
   237  	0xe6, 0xa4, 0xa1, 0x79, 0x3e, 0xe5, 0x14, 0x2e, 0x85, 0x30, 0x0d, 0x7b, 0xb6, 0x36, 0x04, 0xd3,
   238  	0x7a, 0xb0, 0xd2, 0x43, 0xcb, 0xe6, 0xcd, 0x76, 0x5d, 0x33, 0xa9, 0xa3, 0x5b, 0xd4, 0xa2, 0xba,
   239  	0x44, 0xd7, 0xdb, 0x9f, 0xe4, 0x4a, 0x2e, 0xe4, 0xbf, 0x90, 0xb5, 0xf4, 0xb8, 0x3f, 0x8c, 0x83,
   240  	0xcd, 0xa6, 0xed, 0x12, 0xff, 0x48, 0xf7, 0x0e, 0x2d, 0x39, 0x99, 0xee, 0x10, 0x8e, 0xf5, 0xce,
   241  	0xd0, 0x2c, 0x25, 0xfd, 0x32, 0x94, 0xdf, 0x76, 0xb9, 0xed, 0x90, 0x21, 0xc0, 0x93, 0xff, 0x01,
   242  	0x98, 0xd9, 0x24, 0x0e, 0x1e, 0xc4, 0x55, 0xbe, 0x4f, 0x80, 0xb9, 0x9a, 0xdc, 0x69, 0x8d, 0x53,
   243  	0x1f, 0x5b, 0xe4, 0x1d, 0xf1, 0x99, 0x4d, 0x5d, 0xb8, 0x0a, 0x72, 0xd8, 0xb3, 0xc3, 0xd4, 0xf6,
   244  	0x66, 0x51, 0x59, 0x54, 0x96, 0x67, 0x8c, 0x9b, 0xc7, 0xdd, 0x72, 0x2a, 0xe8, 0x96, 0x73, 0xeb,
   245  	0x6f, 0xb7, 0x7b, 0x29, 0x74, 0xb1, 0x0e, 0xae, 0x83, 0x02, 0x71, 0x4d, 0xda, 0xb0, 0x5d, 0x2b,
   246  	0x62, 0x2a, 0x4e, 0x48, 0xe8, 0x42, 0x04, 0x2d, 0x6c, 0x25, 0xd3, 0x68, 0xb0, 0x1e, 0x6e, 0x80,
   247  	0xd9, 0x06, 0x31, 0x69, 0x03, 0xd7, 0x5b, 0xbd, 0x69, 0x58, 0x31, 0xbd, 0x98, 0x5e, 0x9e, 0x31,
   248  	0xe6, 0x83, 0x6e, 0x79, 0x76, 0x73, 0x30, 0x89, 0x86, 0xeb, 0xe1, 0x33, 0x90, 0x97, 0x07, 0xd8,
   249  	0x88, 0x19, 0x32, 0x92, 0x01, 0x06, 0xdd, 0x72, 0xbe, 0x96, 0xc8, 0xa0, 0x81, 0xca, 0xca, 0xcf,
   250  	0x09, 0x90, 0x1f, 0x50, 0xe3, 0x23, 0x98, 0x16, 0x47, 0xd5, 0xc0, 0x1c, 0x4b, 0x29, 0x72, 0xd5,
   251  	0x47, 0x5a, 0xdf, 0x2e, 0xb1, 0xe2, 0x9a, 0x77, 0x68, 0x49, 0xef, 0x68, 0xa2, 0x5a, 0xeb, 0xac,
   252  	0x68, 0x7b, 0xf5, 0xcf, 0xc4, 0xe4, 0xbb, 0x84, 0x63, 0x03, 0x46, 0x0a, 0x80, 0x7e, 0x0c, 0xc5,
   253  	0xac, 0xf0, 0x3d, 0xc8, 0x30, 0x8f, 0x98, 0x52, 0xad, 0x5c, 0x75, 0x4d, 0x1b, 0xcb, 0x8c, 0x5a,
   254  	0x72, 0xcc, 0x9a, 0x47, 0x4c, 0xe3, 0x5a, 0xd4, 0x26, 0x23, 0x56, 0x48, 0x92, 0x42, 0x13, 0x64,
   255  	0x19, 0xc7, 0xbc, 0x2d, 0x74, 0x14, 0xf4, 0xcf, 0xaf, 0x46, 0x2f, 0x29, 0x8c, 0x7c, 0xd4, 0x20,
   256  	0x1b, 0xae, 0x51, 0x44, 0x5d, 0xf9, 0x91, 0x06, 0x0b, 0x49, 0xc0, 0x06, 0x75, 0x1b, 0x36, 0x17,
   257  	0xfa, 0xbd, 0x04, 0x19, 0x7e, 0xe4, 0x91, 0xc8, 0x46, 0x0f, 0x7a, 0x23, 0xee, 0x1f, 0x79, 0xe4,
   258  	0xbc, 0x5b, 0xbe, 0x7d, 0x09, 0x4c, 0xa4, 0x91, 0x04, 0xc2, 0xb5, 0x78, 0x07, 0xa1, 0x9d, 0xee,
   259  	0x24, 0x87, 0x38, 0xef, 0x96, 0x0b, 0x31, 0x2c, 0x39, 0x17, 0x7c, 0x0d, 0x20, 0xad, 0x87, 0x47,
   260  	0xfc, 0x2a, 0x74, 0xbf, 0x70, 0xa5, 0x10, 0x22, 0x6d, 0x94, 0x22, 0x1a, 0xb8, 0x37, 0x54, 0x81,
   261  	0x46, 0xa0, 0x60, 0x07, 0xc0, 0x16, 0x66, 0x7c, 0xdf, 0xc7, 0x2e, 0x0b, 0x47, 0xb4, 0x1d, 0x52,
   262  	0xcc, 0x48, 0x51, 0xef, 0x8f, 0xe7, 0x08, 0x81, 0xe8, 0xf7, 0xdd, 0x19, 0x62, 0x43, 0x23, 0x3a,
   263  	0xc0, 0xbb, 0x20, 0xeb, 0x13, 0xcc, 0xa8, 0x5b, 0x9c, 0x94, 0xdb, 0x8f, 0xcf, 0x00, 0xc9, 0x28,
   264  	0x8a, 0xb2, 0xf0, 0x1e, 0x98, 0x72, 0x08, 0x63, 0xd8, 0x22, 0xc5, 0xac, 0x2c, 0x2c, 0x44, 0x85,
   265  	0x53, 0xbb, 0x61, 0x18, 0xf5, 0xf2, 0x95, 0x5f, 0x0a, 0x80, 0x49, 0xdd, 0x77, 0x6c, 0xc6, 0xe1,
   266  	0x87, 0x21, 0xa7, 0x6b, 0xe3, 0xed, 0x4b, 0xa0, 0xa5, 0xcf, 0x6f, 0x44, 0x2d, 0xa7, 0x7b, 0x91,
   267  	0x0b, 0x2e, 0x3f, 0x00, 0x93, 0x36, 0x27, 0x8e, 0x38, 0xc5, 0xf4, 0x72, 0xae, 0xba, 0x7a, 0x25,
   268  	0x1f, 0x1a, 0xd7, 0xa3, 0x0e, 0x93, 0xdb, 0x82, 0x0b, 0x85, 0x94, 0x95, 0xb9, 0xc1, 0xfd, 0x88,
   269  	0x0b, 0x50, 0xf9, 0x2d, 0x1e, 0xb8, 0x11, 0x36, 0x86, 0x5f, 0x40, 0x81, 0x25, 0xe2, 0xac, 0xa8,
   270  	0xc8, 0xa1, 0xc6, 0xbe, 0x1c, 0x23, 0x9e, 0xcd, 0xfe, 0x33, 0x97, 0x8c, 0x33, 0x34, 0xd8, 0x0c,
   271  	0xee, 0x81, 0x79, 0x93, 0x3a, 0x0e, 0x75, 0xb7, 0x46, 0xbe, 0x97, 0xb7, 0x82, 0x6e, 0x79, 0x7e,
   272  	0x63, 0x54, 0x01, 0x1a, 0x8d, 0x83, 0x3e, 0x00, 0x66, 0xef, 0x0a, 0x84, 0x0f, 0x66, 0xae, 0xfa,
   273  	0xe2, 0x4a, 0x02, 0xc7, 0x37, 0xa9, 0xff, 0x66, 0xc5, 0x21, 0x86, 0x2e, 0x74, 0x31, 0xde, 0x1c,
   274  	0x9f, 0xa9, 0xa9, 0x93, 0x33, 0x35, 0x75, 0x7a, 0xa6, 0xa6, 0xbe, 0x06, 0xaa, 0x72, 0x1c, 0xa8,
   275  	0xca, 0x49, 0xa0, 0x2a, 0xa7, 0x81, 0xaa, 0xfc, 0x09, 0x54, 0xe5, 0xdb, 0x5f, 0x35, 0x75, 0xb0,
   276  	0x34, 0xd6, 0x07, 0xf9, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x79, 0x04, 0x7d, 0x78, 0xb8, 0x07,
   277  	0x00, 0x00,
   278  }
   279  
   280  func (m *ServerStorageVersion) Marshal() (dAtA []byte, err error) {
   281  	size := m.Size()
   282  	dAtA = make([]byte, size)
   283  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   284  	if err != nil {
   285  		return nil, err
   286  	}
   287  	return dAtA[:n], nil
   288  }
   289  
   290  func (m *ServerStorageVersion) MarshalTo(dAtA []byte) (int, error) {
   291  	size := m.Size()
   292  	return m.MarshalToSizedBuffer(dAtA[:size])
   293  }
   294  
   295  func (m *ServerStorageVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   296  	i := len(dAtA)
   297  	_ = i
   298  	var l int
   299  	_ = l
   300  	if len(m.ServedVersions) > 0 {
   301  		for iNdEx := len(m.ServedVersions) - 1; iNdEx >= 0; iNdEx-- {
   302  			i -= len(m.ServedVersions[iNdEx])
   303  			copy(dAtA[i:], m.ServedVersions[iNdEx])
   304  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServedVersions[iNdEx])))
   305  			i--
   306  			dAtA[i] = 0x22
   307  		}
   308  	}
   309  	if len(m.DecodableVersions) > 0 {
   310  		for iNdEx := len(m.DecodableVersions) - 1; iNdEx >= 0; iNdEx-- {
   311  			i -= len(m.DecodableVersions[iNdEx])
   312  			copy(dAtA[i:], m.DecodableVersions[iNdEx])
   313  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.DecodableVersions[iNdEx])))
   314  			i--
   315  			dAtA[i] = 0x1a
   316  		}
   317  	}
   318  	i -= len(m.EncodingVersion)
   319  	copy(dAtA[i:], m.EncodingVersion)
   320  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.EncodingVersion)))
   321  	i--
   322  	dAtA[i] = 0x12
   323  	i -= len(m.APIServerID)
   324  	copy(dAtA[i:], m.APIServerID)
   325  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIServerID)))
   326  	i--
   327  	dAtA[i] = 0xa
   328  	return len(dAtA) - i, nil
   329  }
   330  
   331  func (m *StorageVersion) Marshal() (dAtA []byte, err error) {
   332  	size := m.Size()
   333  	dAtA = make([]byte, size)
   334  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   335  	if err != nil {
   336  		return nil, err
   337  	}
   338  	return dAtA[:n], nil
   339  }
   340  
   341  func (m *StorageVersion) MarshalTo(dAtA []byte) (int, error) {
   342  	size := m.Size()
   343  	return m.MarshalToSizedBuffer(dAtA[:size])
   344  }
   345  
   346  func (m *StorageVersion) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   347  	i := len(dAtA)
   348  	_ = i
   349  	var l int
   350  	_ = l
   351  	{
   352  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
   353  		if err != nil {
   354  			return 0, err
   355  		}
   356  		i -= size
   357  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   358  	}
   359  	i--
   360  	dAtA[i] = 0x1a
   361  	{
   362  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
   363  		if err != nil {
   364  			return 0, err
   365  		}
   366  		i -= size
   367  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   368  	}
   369  	i--
   370  	dAtA[i] = 0x12
   371  	{
   372  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
   373  		if err != nil {
   374  			return 0, err
   375  		}
   376  		i -= size
   377  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   378  	}
   379  	i--
   380  	dAtA[i] = 0xa
   381  	return len(dAtA) - i, nil
   382  }
   383  
   384  func (m *StorageVersionCondition) Marshal() (dAtA []byte, err error) {
   385  	size := m.Size()
   386  	dAtA = make([]byte, size)
   387  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   388  	if err != nil {
   389  		return nil, err
   390  	}
   391  	return dAtA[:n], nil
   392  }
   393  
   394  func (m *StorageVersionCondition) MarshalTo(dAtA []byte) (int, error) {
   395  	size := m.Size()
   396  	return m.MarshalToSizedBuffer(dAtA[:size])
   397  }
   398  
   399  func (m *StorageVersionCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   400  	i := len(dAtA)
   401  	_ = i
   402  	var l int
   403  	_ = l
   404  	i -= len(m.Message)
   405  	copy(dAtA[i:], m.Message)
   406  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
   407  	i--
   408  	dAtA[i] = 0x32
   409  	i -= len(m.Reason)
   410  	copy(dAtA[i:], m.Reason)
   411  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
   412  	i--
   413  	dAtA[i] = 0x2a
   414  	{
   415  		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
   416  		if err != nil {
   417  			return 0, err
   418  		}
   419  		i -= size
   420  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   421  	}
   422  	i--
   423  	dAtA[i] = 0x22
   424  	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
   425  	i--
   426  	dAtA[i] = 0x18
   427  	i -= len(m.Status)
   428  	copy(dAtA[i:], m.Status)
   429  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
   430  	i--
   431  	dAtA[i] = 0x12
   432  	i -= len(m.Type)
   433  	copy(dAtA[i:], m.Type)
   434  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
   435  	i--
   436  	dAtA[i] = 0xa
   437  	return len(dAtA) - i, nil
   438  }
   439  
   440  func (m *StorageVersionList) Marshal() (dAtA []byte, err error) {
   441  	size := m.Size()
   442  	dAtA = make([]byte, size)
   443  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   444  	if err != nil {
   445  		return nil, err
   446  	}
   447  	return dAtA[:n], nil
   448  }
   449  
   450  func (m *StorageVersionList) MarshalTo(dAtA []byte) (int, error) {
   451  	size := m.Size()
   452  	return m.MarshalToSizedBuffer(dAtA[:size])
   453  }
   454  
   455  func (m *StorageVersionList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   456  	i := len(dAtA)
   457  	_ = i
   458  	var l int
   459  	_ = l
   460  	if len(m.Items) > 0 {
   461  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
   462  			{
   463  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   464  				if err != nil {
   465  					return 0, err
   466  				}
   467  				i -= size
   468  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   469  			}
   470  			i--
   471  			dAtA[i] = 0x12
   472  		}
   473  	}
   474  	{
   475  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
   476  		if err != nil {
   477  			return 0, err
   478  		}
   479  		i -= size
   480  		i = encodeVarintGenerated(dAtA, i, uint64(size))
   481  	}
   482  	i--
   483  	dAtA[i] = 0xa
   484  	return len(dAtA) - i, nil
   485  }
   486  
   487  func (m *StorageVersionSpec) Marshal() (dAtA []byte, err error) {
   488  	size := m.Size()
   489  	dAtA = make([]byte, size)
   490  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   491  	if err != nil {
   492  		return nil, err
   493  	}
   494  	return dAtA[:n], nil
   495  }
   496  
   497  func (m *StorageVersionSpec) MarshalTo(dAtA []byte) (int, error) {
   498  	size := m.Size()
   499  	return m.MarshalToSizedBuffer(dAtA[:size])
   500  }
   501  
   502  func (m *StorageVersionSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   503  	i := len(dAtA)
   504  	_ = i
   505  	var l int
   506  	_ = l
   507  	return len(dAtA) - i, nil
   508  }
   509  
   510  func (m *StorageVersionStatus) Marshal() (dAtA []byte, err error) {
   511  	size := m.Size()
   512  	dAtA = make([]byte, size)
   513  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   514  	if err != nil {
   515  		return nil, err
   516  	}
   517  	return dAtA[:n], nil
   518  }
   519  
   520  func (m *StorageVersionStatus) MarshalTo(dAtA []byte) (int, error) {
   521  	size := m.Size()
   522  	return m.MarshalToSizedBuffer(dAtA[:size])
   523  }
   524  
   525  func (m *StorageVersionStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   526  	i := len(dAtA)
   527  	_ = i
   528  	var l int
   529  	_ = l
   530  	if len(m.Conditions) > 0 {
   531  		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
   532  			{
   533  				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   534  				if err != nil {
   535  					return 0, err
   536  				}
   537  				i -= size
   538  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   539  			}
   540  			i--
   541  			dAtA[i] = 0x1a
   542  		}
   543  	}
   544  	if m.CommonEncodingVersion != nil {
   545  		i -= len(*m.CommonEncodingVersion)
   546  		copy(dAtA[i:], *m.CommonEncodingVersion)
   547  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.CommonEncodingVersion)))
   548  		i--
   549  		dAtA[i] = 0x12
   550  	}
   551  	if len(m.StorageVersions) > 0 {
   552  		for iNdEx := len(m.StorageVersions) - 1; iNdEx >= 0; iNdEx-- {
   553  			{
   554  				size, err := m.StorageVersions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
   555  				if err != nil {
   556  					return 0, err
   557  				}
   558  				i -= size
   559  				i = encodeVarintGenerated(dAtA, i, uint64(size))
   560  			}
   561  			i--
   562  			dAtA[i] = 0xa
   563  		}
   564  	}
   565  	return len(dAtA) - i, nil
   566  }
   567  
   568  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
   569  	offset -= sovGenerated(v)
   570  	base := offset
   571  	for v >= 1<<7 {
   572  		dAtA[offset] = uint8(v&0x7f | 0x80)
   573  		v >>= 7
   574  		offset++
   575  	}
   576  	dAtA[offset] = uint8(v)
   577  	return base
   578  }
   579  func (m *ServerStorageVersion) Size() (n int) {
   580  	if m == nil {
   581  		return 0
   582  	}
   583  	var l int
   584  	_ = l
   585  	l = len(m.APIServerID)
   586  	n += 1 + l + sovGenerated(uint64(l))
   587  	l = len(m.EncodingVersion)
   588  	n += 1 + l + sovGenerated(uint64(l))
   589  	if len(m.DecodableVersions) > 0 {
   590  		for _, s := range m.DecodableVersions {
   591  			l = len(s)
   592  			n += 1 + l + sovGenerated(uint64(l))
   593  		}
   594  	}
   595  	if len(m.ServedVersions) > 0 {
   596  		for _, s := range m.ServedVersions {
   597  			l = len(s)
   598  			n += 1 + l + sovGenerated(uint64(l))
   599  		}
   600  	}
   601  	return n
   602  }
   603  
   604  func (m *StorageVersion) Size() (n int) {
   605  	if m == nil {
   606  		return 0
   607  	}
   608  	var l int
   609  	_ = l
   610  	l = m.ObjectMeta.Size()
   611  	n += 1 + l + sovGenerated(uint64(l))
   612  	l = m.Spec.Size()
   613  	n += 1 + l + sovGenerated(uint64(l))
   614  	l = m.Status.Size()
   615  	n += 1 + l + sovGenerated(uint64(l))
   616  	return n
   617  }
   618  
   619  func (m *StorageVersionCondition) Size() (n int) {
   620  	if m == nil {
   621  		return 0
   622  	}
   623  	var l int
   624  	_ = l
   625  	l = len(m.Type)
   626  	n += 1 + l + sovGenerated(uint64(l))
   627  	l = len(m.Status)
   628  	n += 1 + l + sovGenerated(uint64(l))
   629  	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
   630  	l = m.LastTransitionTime.Size()
   631  	n += 1 + l + sovGenerated(uint64(l))
   632  	l = len(m.Reason)
   633  	n += 1 + l + sovGenerated(uint64(l))
   634  	l = len(m.Message)
   635  	n += 1 + l + sovGenerated(uint64(l))
   636  	return n
   637  }
   638  
   639  func (m *StorageVersionList) Size() (n int) {
   640  	if m == nil {
   641  		return 0
   642  	}
   643  	var l int
   644  	_ = l
   645  	l = m.ListMeta.Size()
   646  	n += 1 + l + sovGenerated(uint64(l))
   647  	if len(m.Items) > 0 {
   648  		for _, e := range m.Items {
   649  			l = e.Size()
   650  			n += 1 + l + sovGenerated(uint64(l))
   651  		}
   652  	}
   653  	return n
   654  }
   655  
   656  func (m *StorageVersionSpec) Size() (n int) {
   657  	if m == nil {
   658  		return 0
   659  	}
   660  	var l int
   661  	_ = l
   662  	return n
   663  }
   664  
   665  func (m *StorageVersionStatus) Size() (n int) {
   666  	if m == nil {
   667  		return 0
   668  	}
   669  	var l int
   670  	_ = l
   671  	if len(m.StorageVersions) > 0 {
   672  		for _, e := range m.StorageVersions {
   673  			l = e.Size()
   674  			n += 1 + l + sovGenerated(uint64(l))
   675  		}
   676  	}
   677  	if m.CommonEncodingVersion != nil {
   678  		l = len(*m.CommonEncodingVersion)
   679  		n += 1 + l + sovGenerated(uint64(l))
   680  	}
   681  	if len(m.Conditions) > 0 {
   682  		for _, e := range m.Conditions {
   683  			l = e.Size()
   684  			n += 1 + l + sovGenerated(uint64(l))
   685  		}
   686  	}
   687  	return n
   688  }
   689  
   690  func sovGenerated(x uint64) (n int) {
   691  	return (math_bits.Len64(x|1) + 6) / 7
   692  }
   693  func sozGenerated(x uint64) (n int) {
   694  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   695  }
   696  func (this *ServerStorageVersion) String() string {
   697  	if this == nil {
   698  		return "nil"
   699  	}
   700  	s := strings.Join([]string{`&ServerStorageVersion{`,
   701  		`APIServerID:` + fmt.Sprintf("%v", this.APIServerID) + `,`,
   702  		`EncodingVersion:` + fmt.Sprintf("%v", this.EncodingVersion) + `,`,
   703  		`DecodableVersions:` + fmt.Sprintf("%v", this.DecodableVersions) + `,`,
   704  		`ServedVersions:` + fmt.Sprintf("%v", this.ServedVersions) + `,`,
   705  		`}`,
   706  	}, "")
   707  	return s
   708  }
   709  func (this *StorageVersion) String() string {
   710  	if this == nil {
   711  		return "nil"
   712  	}
   713  	s := strings.Join([]string{`&StorageVersion{`,
   714  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
   715  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "StorageVersionSpec", "StorageVersionSpec", 1), `&`, ``, 1) + `,`,
   716  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "StorageVersionStatus", "StorageVersionStatus", 1), `&`, ``, 1) + `,`,
   717  		`}`,
   718  	}, "")
   719  	return s
   720  }
   721  func (this *StorageVersionCondition) String() string {
   722  	if this == nil {
   723  		return "nil"
   724  	}
   725  	s := strings.Join([]string{`&StorageVersionCondition{`,
   726  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
   727  		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
   728  		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
   729  		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
   730  		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
   731  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
   732  		`}`,
   733  	}, "")
   734  	return s
   735  }
   736  func (this *StorageVersionList) String() string {
   737  	if this == nil {
   738  		return "nil"
   739  	}
   740  	repeatedStringForItems := "[]StorageVersion{"
   741  	for _, f := range this.Items {
   742  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "StorageVersion", "StorageVersion", 1), `&`, ``, 1) + ","
   743  	}
   744  	repeatedStringForItems += "}"
   745  	s := strings.Join([]string{`&StorageVersionList{`,
   746  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
   747  		`Items:` + repeatedStringForItems + `,`,
   748  		`}`,
   749  	}, "")
   750  	return s
   751  }
   752  func (this *StorageVersionSpec) String() string {
   753  	if this == nil {
   754  		return "nil"
   755  	}
   756  	s := strings.Join([]string{`&StorageVersionSpec{`,
   757  		`}`,
   758  	}, "")
   759  	return s
   760  }
   761  func (this *StorageVersionStatus) String() string {
   762  	if this == nil {
   763  		return "nil"
   764  	}
   765  	repeatedStringForStorageVersions := "[]ServerStorageVersion{"
   766  	for _, f := range this.StorageVersions {
   767  		repeatedStringForStorageVersions += strings.Replace(strings.Replace(f.String(), "ServerStorageVersion", "ServerStorageVersion", 1), `&`, ``, 1) + ","
   768  	}
   769  	repeatedStringForStorageVersions += "}"
   770  	repeatedStringForConditions := "[]StorageVersionCondition{"
   771  	for _, f := range this.Conditions {
   772  		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "StorageVersionCondition", "StorageVersionCondition", 1), `&`, ``, 1) + ","
   773  	}
   774  	repeatedStringForConditions += "}"
   775  	s := strings.Join([]string{`&StorageVersionStatus{`,
   776  		`StorageVersions:` + repeatedStringForStorageVersions + `,`,
   777  		`CommonEncodingVersion:` + valueToStringGenerated(this.CommonEncodingVersion) + `,`,
   778  		`Conditions:` + repeatedStringForConditions + `,`,
   779  		`}`,
   780  	}, "")
   781  	return s
   782  }
   783  func valueToStringGenerated(v interface{}) string {
   784  	rv := reflect.ValueOf(v)
   785  	if rv.IsNil() {
   786  		return "nil"
   787  	}
   788  	pv := reflect.Indirect(rv).Interface()
   789  	return fmt.Sprintf("*%v", pv)
   790  }
   791  func (m *ServerStorageVersion) Unmarshal(dAtA []byte) error {
   792  	l := len(dAtA)
   793  	iNdEx := 0
   794  	for iNdEx < l {
   795  		preIndex := iNdEx
   796  		var wire uint64
   797  		for shift := uint(0); ; shift += 7 {
   798  			if shift >= 64 {
   799  				return ErrIntOverflowGenerated
   800  			}
   801  			if iNdEx >= l {
   802  				return io.ErrUnexpectedEOF
   803  			}
   804  			b := dAtA[iNdEx]
   805  			iNdEx++
   806  			wire |= uint64(b&0x7F) << shift
   807  			if b < 0x80 {
   808  				break
   809  			}
   810  		}
   811  		fieldNum := int32(wire >> 3)
   812  		wireType := int(wire & 0x7)
   813  		if wireType == 4 {
   814  			return fmt.Errorf("proto: ServerStorageVersion: wiretype end group for non-group")
   815  		}
   816  		if fieldNum <= 0 {
   817  			return fmt.Errorf("proto: ServerStorageVersion: illegal tag %d (wire type %d)", fieldNum, wire)
   818  		}
   819  		switch fieldNum {
   820  		case 1:
   821  			if wireType != 2 {
   822  				return fmt.Errorf("proto: wrong wireType = %d for field APIServerID", wireType)
   823  			}
   824  			var stringLen uint64
   825  			for shift := uint(0); ; shift += 7 {
   826  				if shift >= 64 {
   827  					return ErrIntOverflowGenerated
   828  				}
   829  				if iNdEx >= l {
   830  					return io.ErrUnexpectedEOF
   831  				}
   832  				b := dAtA[iNdEx]
   833  				iNdEx++
   834  				stringLen |= uint64(b&0x7F) << shift
   835  				if b < 0x80 {
   836  					break
   837  				}
   838  			}
   839  			intStringLen := int(stringLen)
   840  			if intStringLen < 0 {
   841  				return ErrInvalidLengthGenerated
   842  			}
   843  			postIndex := iNdEx + intStringLen
   844  			if postIndex < 0 {
   845  				return ErrInvalidLengthGenerated
   846  			}
   847  			if postIndex > l {
   848  				return io.ErrUnexpectedEOF
   849  			}
   850  			m.APIServerID = string(dAtA[iNdEx:postIndex])
   851  			iNdEx = postIndex
   852  		case 2:
   853  			if wireType != 2 {
   854  				return fmt.Errorf("proto: wrong wireType = %d for field EncodingVersion", wireType)
   855  			}
   856  			var stringLen uint64
   857  			for shift := uint(0); ; shift += 7 {
   858  				if shift >= 64 {
   859  					return ErrIntOverflowGenerated
   860  				}
   861  				if iNdEx >= l {
   862  					return io.ErrUnexpectedEOF
   863  				}
   864  				b := dAtA[iNdEx]
   865  				iNdEx++
   866  				stringLen |= uint64(b&0x7F) << shift
   867  				if b < 0x80 {
   868  					break
   869  				}
   870  			}
   871  			intStringLen := int(stringLen)
   872  			if intStringLen < 0 {
   873  				return ErrInvalidLengthGenerated
   874  			}
   875  			postIndex := iNdEx + intStringLen
   876  			if postIndex < 0 {
   877  				return ErrInvalidLengthGenerated
   878  			}
   879  			if postIndex > l {
   880  				return io.ErrUnexpectedEOF
   881  			}
   882  			m.EncodingVersion = string(dAtA[iNdEx:postIndex])
   883  			iNdEx = postIndex
   884  		case 3:
   885  			if wireType != 2 {
   886  				return fmt.Errorf("proto: wrong wireType = %d for field DecodableVersions", wireType)
   887  			}
   888  			var stringLen uint64
   889  			for shift := uint(0); ; shift += 7 {
   890  				if shift >= 64 {
   891  					return ErrIntOverflowGenerated
   892  				}
   893  				if iNdEx >= l {
   894  					return io.ErrUnexpectedEOF
   895  				}
   896  				b := dAtA[iNdEx]
   897  				iNdEx++
   898  				stringLen |= uint64(b&0x7F) << shift
   899  				if b < 0x80 {
   900  					break
   901  				}
   902  			}
   903  			intStringLen := int(stringLen)
   904  			if intStringLen < 0 {
   905  				return ErrInvalidLengthGenerated
   906  			}
   907  			postIndex := iNdEx + intStringLen
   908  			if postIndex < 0 {
   909  				return ErrInvalidLengthGenerated
   910  			}
   911  			if postIndex > l {
   912  				return io.ErrUnexpectedEOF
   913  			}
   914  			m.DecodableVersions = append(m.DecodableVersions, string(dAtA[iNdEx:postIndex]))
   915  			iNdEx = postIndex
   916  		case 4:
   917  			if wireType != 2 {
   918  				return fmt.Errorf("proto: wrong wireType = %d for field ServedVersions", wireType)
   919  			}
   920  			var stringLen uint64
   921  			for shift := uint(0); ; shift += 7 {
   922  				if shift >= 64 {
   923  					return ErrIntOverflowGenerated
   924  				}
   925  				if iNdEx >= l {
   926  					return io.ErrUnexpectedEOF
   927  				}
   928  				b := dAtA[iNdEx]
   929  				iNdEx++
   930  				stringLen |= uint64(b&0x7F) << shift
   931  				if b < 0x80 {
   932  					break
   933  				}
   934  			}
   935  			intStringLen := int(stringLen)
   936  			if intStringLen < 0 {
   937  				return ErrInvalidLengthGenerated
   938  			}
   939  			postIndex := iNdEx + intStringLen
   940  			if postIndex < 0 {
   941  				return ErrInvalidLengthGenerated
   942  			}
   943  			if postIndex > l {
   944  				return io.ErrUnexpectedEOF
   945  			}
   946  			m.ServedVersions = append(m.ServedVersions, string(dAtA[iNdEx:postIndex]))
   947  			iNdEx = postIndex
   948  		default:
   949  			iNdEx = preIndex
   950  			skippy, err := skipGenerated(dAtA[iNdEx:])
   951  			if err != nil {
   952  				return err
   953  			}
   954  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   955  				return ErrInvalidLengthGenerated
   956  			}
   957  			if (iNdEx + skippy) > l {
   958  				return io.ErrUnexpectedEOF
   959  			}
   960  			iNdEx += skippy
   961  		}
   962  	}
   963  
   964  	if iNdEx > l {
   965  		return io.ErrUnexpectedEOF
   966  	}
   967  	return nil
   968  }
   969  func (m *StorageVersion) Unmarshal(dAtA []byte) error {
   970  	l := len(dAtA)
   971  	iNdEx := 0
   972  	for iNdEx < l {
   973  		preIndex := iNdEx
   974  		var wire uint64
   975  		for shift := uint(0); ; shift += 7 {
   976  			if shift >= 64 {
   977  				return ErrIntOverflowGenerated
   978  			}
   979  			if iNdEx >= l {
   980  				return io.ErrUnexpectedEOF
   981  			}
   982  			b := dAtA[iNdEx]
   983  			iNdEx++
   984  			wire |= uint64(b&0x7F) << shift
   985  			if b < 0x80 {
   986  				break
   987  			}
   988  		}
   989  		fieldNum := int32(wire >> 3)
   990  		wireType := int(wire & 0x7)
   991  		if wireType == 4 {
   992  			return fmt.Errorf("proto: StorageVersion: wiretype end group for non-group")
   993  		}
   994  		if fieldNum <= 0 {
   995  			return fmt.Errorf("proto: StorageVersion: illegal tag %d (wire type %d)", fieldNum, wire)
   996  		}
   997  		switch fieldNum {
   998  		case 1:
   999  			if wireType != 2 {
  1000  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  1001  			}
  1002  			var msglen int
  1003  			for shift := uint(0); ; shift += 7 {
  1004  				if shift >= 64 {
  1005  					return ErrIntOverflowGenerated
  1006  				}
  1007  				if iNdEx >= l {
  1008  					return io.ErrUnexpectedEOF
  1009  				}
  1010  				b := dAtA[iNdEx]
  1011  				iNdEx++
  1012  				msglen |= int(b&0x7F) << shift
  1013  				if b < 0x80 {
  1014  					break
  1015  				}
  1016  			}
  1017  			if msglen < 0 {
  1018  				return ErrInvalidLengthGenerated
  1019  			}
  1020  			postIndex := iNdEx + msglen
  1021  			if postIndex < 0 {
  1022  				return ErrInvalidLengthGenerated
  1023  			}
  1024  			if postIndex > l {
  1025  				return io.ErrUnexpectedEOF
  1026  			}
  1027  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1028  				return err
  1029  			}
  1030  			iNdEx = postIndex
  1031  		case 2:
  1032  			if wireType != 2 {
  1033  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  1034  			}
  1035  			var msglen int
  1036  			for shift := uint(0); ; shift += 7 {
  1037  				if shift >= 64 {
  1038  					return ErrIntOverflowGenerated
  1039  				}
  1040  				if iNdEx >= l {
  1041  					return io.ErrUnexpectedEOF
  1042  				}
  1043  				b := dAtA[iNdEx]
  1044  				iNdEx++
  1045  				msglen |= int(b&0x7F) << shift
  1046  				if b < 0x80 {
  1047  					break
  1048  				}
  1049  			}
  1050  			if msglen < 0 {
  1051  				return ErrInvalidLengthGenerated
  1052  			}
  1053  			postIndex := iNdEx + msglen
  1054  			if postIndex < 0 {
  1055  				return ErrInvalidLengthGenerated
  1056  			}
  1057  			if postIndex > l {
  1058  				return io.ErrUnexpectedEOF
  1059  			}
  1060  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1061  				return err
  1062  			}
  1063  			iNdEx = postIndex
  1064  		case 3:
  1065  			if wireType != 2 {
  1066  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  1067  			}
  1068  			var msglen int
  1069  			for shift := uint(0); ; shift += 7 {
  1070  				if shift >= 64 {
  1071  					return ErrIntOverflowGenerated
  1072  				}
  1073  				if iNdEx >= l {
  1074  					return io.ErrUnexpectedEOF
  1075  				}
  1076  				b := dAtA[iNdEx]
  1077  				iNdEx++
  1078  				msglen |= int(b&0x7F) << shift
  1079  				if b < 0x80 {
  1080  					break
  1081  				}
  1082  			}
  1083  			if msglen < 0 {
  1084  				return ErrInvalidLengthGenerated
  1085  			}
  1086  			postIndex := iNdEx + msglen
  1087  			if postIndex < 0 {
  1088  				return ErrInvalidLengthGenerated
  1089  			}
  1090  			if postIndex > l {
  1091  				return io.ErrUnexpectedEOF
  1092  			}
  1093  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1094  				return err
  1095  			}
  1096  			iNdEx = postIndex
  1097  		default:
  1098  			iNdEx = preIndex
  1099  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1100  			if err != nil {
  1101  				return err
  1102  			}
  1103  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1104  				return ErrInvalidLengthGenerated
  1105  			}
  1106  			if (iNdEx + skippy) > l {
  1107  				return io.ErrUnexpectedEOF
  1108  			}
  1109  			iNdEx += skippy
  1110  		}
  1111  	}
  1112  
  1113  	if iNdEx > l {
  1114  		return io.ErrUnexpectedEOF
  1115  	}
  1116  	return nil
  1117  }
  1118  func (m *StorageVersionCondition) Unmarshal(dAtA []byte) error {
  1119  	l := len(dAtA)
  1120  	iNdEx := 0
  1121  	for iNdEx < l {
  1122  		preIndex := iNdEx
  1123  		var wire uint64
  1124  		for shift := uint(0); ; shift += 7 {
  1125  			if shift >= 64 {
  1126  				return ErrIntOverflowGenerated
  1127  			}
  1128  			if iNdEx >= l {
  1129  				return io.ErrUnexpectedEOF
  1130  			}
  1131  			b := dAtA[iNdEx]
  1132  			iNdEx++
  1133  			wire |= uint64(b&0x7F) << shift
  1134  			if b < 0x80 {
  1135  				break
  1136  			}
  1137  		}
  1138  		fieldNum := int32(wire >> 3)
  1139  		wireType := int(wire & 0x7)
  1140  		if wireType == 4 {
  1141  			return fmt.Errorf("proto: StorageVersionCondition: wiretype end group for non-group")
  1142  		}
  1143  		if fieldNum <= 0 {
  1144  			return fmt.Errorf("proto: StorageVersionCondition: illegal tag %d (wire type %d)", fieldNum, wire)
  1145  		}
  1146  		switch fieldNum {
  1147  		case 1:
  1148  			if wireType != 2 {
  1149  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  1150  			}
  1151  			var stringLen uint64
  1152  			for shift := uint(0); ; shift += 7 {
  1153  				if shift >= 64 {
  1154  					return ErrIntOverflowGenerated
  1155  				}
  1156  				if iNdEx >= l {
  1157  					return io.ErrUnexpectedEOF
  1158  				}
  1159  				b := dAtA[iNdEx]
  1160  				iNdEx++
  1161  				stringLen |= uint64(b&0x7F) << shift
  1162  				if b < 0x80 {
  1163  					break
  1164  				}
  1165  			}
  1166  			intStringLen := int(stringLen)
  1167  			if intStringLen < 0 {
  1168  				return ErrInvalidLengthGenerated
  1169  			}
  1170  			postIndex := iNdEx + intStringLen
  1171  			if postIndex < 0 {
  1172  				return ErrInvalidLengthGenerated
  1173  			}
  1174  			if postIndex > l {
  1175  				return io.ErrUnexpectedEOF
  1176  			}
  1177  			m.Type = StorageVersionConditionType(dAtA[iNdEx:postIndex])
  1178  			iNdEx = postIndex
  1179  		case 2:
  1180  			if wireType != 2 {
  1181  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  1182  			}
  1183  			var stringLen uint64
  1184  			for shift := uint(0); ; shift += 7 {
  1185  				if shift >= 64 {
  1186  					return ErrIntOverflowGenerated
  1187  				}
  1188  				if iNdEx >= l {
  1189  					return io.ErrUnexpectedEOF
  1190  				}
  1191  				b := dAtA[iNdEx]
  1192  				iNdEx++
  1193  				stringLen |= uint64(b&0x7F) << shift
  1194  				if b < 0x80 {
  1195  					break
  1196  				}
  1197  			}
  1198  			intStringLen := int(stringLen)
  1199  			if intStringLen < 0 {
  1200  				return ErrInvalidLengthGenerated
  1201  			}
  1202  			postIndex := iNdEx + intStringLen
  1203  			if postIndex < 0 {
  1204  				return ErrInvalidLengthGenerated
  1205  			}
  1206  			if postIndex > l {
  1207  				return io.ErrUnexpectedEOF
  1208  			}
  1209  			m.Status = ConditionStatus(dAtA[iNdEx:postIndex])
  1210  			iNdEx = postIndex
  1211  		case 3:
  1212  			if wireType != 0 {
  1213  				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
  1214  			}
  1215  			m.ObservedGeneration = 0
  1216  			for shift := uint(0); ; shift += 7 {
  1217  				if shift >= 64 {
  1218  					return ErrIntOverflowGenerated
  1219  				}
  1220  				if iNdEx >= l {
  1221  					return io.ErrUnexpectedEOF
  1222  				}
  1223  				b := dAtA[iNdEx]
  1224  				iNdEx++
  1225  				m.ObservedGeneration |= int64(b&0x7F) << shift
  1226  				if b < 0x80 {
  1227  					break
  1228  				}
  1229  			}
  1230  		case 4:
  1231  			if wireType != 2 {
  1232  				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
  1233  			}
  1234  			var msglen int
  1235  			for shift := uint(0); ; shift += 7 {
  1236  				if shift >= 64 {
  1237  					return ErrIntOverflowGenerated
  1238  				}
  1239  				if iNdEx >= l {
  1240  					return io.ErrUnexpectedEOF
  1241  				}
  1242  				b := dAtA[iNdEx]
  1243  				iNdEx++
  1244  				msglen |= int(b&0x7F) << shift
  1245  				if b < 0x80 {
  1246  					break
  1247  				}
  1248  			}
  1249  			if msglen < 0 {
  1250  				return ErrInvalidLengthGenerated
  1251  			}
  1252  			postIndex := iNdEx + msglen
  1253  			if postIndex < 0 {
  1254  				return ErrInvalidLengthGenerated
  1255  			}
  1256  			if postIndex > l {
  1257  				return io.ErrUnexpectedEOF
  1258  			}
  1259  			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1260  				return err
  1261  			}
  1262  			iNdEx = postIndex
  1263  		case 5:
  1264  			if wireType != 2 {
  1265  				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
  1266  			}
  1267  			var stringLen uint64
  1268  			for shift := uint(0); ; shift += 7 {
  1269  				if shift >= 64 {
  1270  					return ErrIntOverflowGenerated
  1271  				}
  1272  				if iNdEx >= l {
  1273  					return io.ErrUnexpectedEOF
  1274  				}
  1275  				b := dAtA[iNdEx]
  1276  				iNdEx++
  1277  				stringLen |= uint64(b&0x7F) << shift
  1278  				if b < 0x80 {
  1279  					break
  1280  				}
  1281  			}
  1282  			intStringLen := int(stringLen)
  1283  			if intStringLen < 0 {
  1284  				return ErrInvalidLengthGenerated
  1285  			}
  1286  			postIndex := iNdEx + intStringLen
  1287  			if postIndex < 0 {
  1288  				return ErrInvalidLengthGenerated
  1289  			}
  1290  			if postIndex > l {
  1291  				return io.ErrUnexpectedEOF
  1292  			}
  1293  			m.Reason = string(dAtA[iNdEx:postIndex])
  1294  			iNdEx = postIndex
  1295  		case 6:
  1296  			if wireType != 2 {
  1297  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  1298  			}
  1299  			var stringLen uint64
  1300  			for shift := uint(0); ; shift += 7 {
  1301  				if shift >= 64 {
  1302  					return ErrIntOverflowGenerated
  1303  				}
  1304  				if iNdEx >= l {
  1305  					return io.ErrUnexpectedEOF
  1306  				}
  1307  				b := dAtA[iNdEx]
  1308  				iNdEx++
  1309  				stringLen |= uint64(b&0x7F) << shift
  1310  				if b < 0x80 {
  1311  					break
  1312  				}
  1313  			}
  1314  			intStringLen := int(stringLen)
  1315  			if intStringLen < 0 {
  1316  				return ErrInvalidLengthGenerated
  1317  			}
  1318  			postIndex := iNdEx + intStringLen
  1319  			if postIndex < 0 {
  1320  				return ErrInvalidLengthGenerated
  1321  			}
  1322  			if postIndex > l {
  1323  				return io.ErrUnexpectedEOF
  1324  			}
  1325  			m.Message = string(dAtA[iNdEx:postIndex])
  1326  			iNdEx = postIndex
  1327  		default:
  1328  			iNdEx = preIndex
  1329  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1330  			if err != nil {
  1331  				return err
  1332  			}
  1333  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1334  				return ErrInvalidLengthGenerated
  1335  			}
  1336  			if (iNdEx + skippy) > l {
  1337  				return io.ErrUnexpectedEOF
  1338  			}
  1339  			iNdEx += skippy
  1340  		}
  1341  	}
  1342  
  1343  	if iNdEx > l {
  1344  		return io.ErrUnexpectedEOF
  1345  	}
  1346  	return nil
  1347  }
  1348  func (m *StorageVersionList) Unmarshal(dAtA []byte) error {
  1349  	l := len(dAtA)
  1350  	iNdEx := 0
  1351  	for iNdEx < l {
  1352  		preIndex := iNdEx
  1353  		var wire uint64
  1354  		for shift := uint(0); ; shift += 7 {
  1355  			if shift >= 64 {
  1356  				return ErrIntOverflowGenerated
  1357  			}
  1358  			if iNdEx >= l {
  1359  				return io.ErrUnexpectedEOF
  1360  			}
  1361  			b := dAtA[iNdEx]
  1362  			iNdEx++
  1363  			wire |= uint64(b&0x7F) << shift
  1364  			if b < 0x80 {
  1365  				break
  1366  			}
  1367  		}
  1368  		fieldNum := int32(wire >> 3)
  1369  		wireType := int(wire & 0x7)
  1370  		if wireType == 4 {
  1371  			return fmt.Errorf("proto: StorageVersionList: wiretype end group for non-group")
  1372  		}
  1373  		if fieldNum <= 0 {
  1374  			return fmt.Errorf("proto: StorageVersionList: illegal tag %d (wire type %d)", fieldNum, wire)
  1375  		}
  1376  		switch fieldNum {
  1377  		case 1:
  1378  			if wireType != 2 {
  1379  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  1380  			}
  1381  			var msglen int
  1382  			for shift := uint(0); ; shift += 7 {
  1383  				if shift >= 64 {
  1384  					return ErrIntOverflowGenerated
  1385  				}
  1386  				if iNdEx >= l {
  1387  					return io.ErrUnexpectedEOF
  1388  				}
  1389  				b := dAtA[iNdEx]
  1390  				iNdEx++
  1391  				msglen |= int(b&0x7F) << shift
  1392  				if b < 0x80 {
  1393  					break
  1394  				}
  1395  			}
  1396  			if msglen < 0 {
  1397  				return ErrInvalidLengthGenerated
  1398  			}
  1399  			postIndex := iNdEx + msglen
  1400  			if postIndex < 0 {
  1401  				return ErrInvalidLengthGenerated
  1402  			}
  1403  			if postIndex > l {
  1404  				return io.ErrUnexpectedEOF
  1405  			}
  1406  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1407  				return err
  1408  			}
  1409  			iNdEx = postIndex
  1410  		case 2:
  1411  			if wireType != 2 {
  1412  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  1413  			}
  1414  			var msglen int
  1415  			for shift := uint(0); ; shift += 7 {
  1416  				if shift >= 64 {
  1417  					return ErrIntOverflowGenerated
  1418  				}
  1419  				if iNdEx >= l {
  1420  					return io.ErrUnexpectedEOF
  1421  				}
  1422  				b := dAtA[iNdEx]
  1423  				iNdEx++
  1424  				msglen |= int(b&0x7F) << shift
  1425  				if b < 0x80 {
  1426  					break
  1427  				}
  1428  			}
  1429  			if msglen < 0 {
  1430  				return ErrInvalidLengthGenerated
  1431  			}
  1432  			postIndex := iNdEx + msglen
  1433  			if postIndex < 0 {
  1434  				return ErrInvalidLengthGenerated
  1435  			}
  1436  			if postIndex > l {
  1437  				return io.ErrUnexpectedEOF
  1438  			}
  1439  			m.Items = append(m.Items, StorageVersion{})
  1440  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1441  				return err
  1442  			}
  1443  			iNdEx = postIndex
  1444  		default:
  1445  			iNdEx = preIndex
  1446  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1447  			if err != nil {
  1448  				return err
  1449  			}
  1450  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1451  				return ErrInvalidLengthGenerated
  1452  			}
  1453  			if (iNdEx + skippy) > l {
  1454  				return io.ErrUnexpectedEOF
  1455  			}
  1456  			iNdEx += skippy
  1457  		}
  1458  	}
  1459  
  1460  	if iNdEx > l {
  1461  		return io.ErrUnexpectedEOF
  1462  	}
  1463  	return nil
  1464  }
  1465  func (m *StorageVersionSpec) Unmarshal(dAtA []byte) error {
  1466  	l := len(dAtA)
  1467  	iNdEx := 0
  1468  	for iNdEx < l {
  1469  		preIndex := iNdEx
  1470  		var wire uint64
  1471  		for shift := uint(0); ; shift += 7 {
  1472  			if shift >= 64 {
  1473  				return ErrIntOverflowGenerated
  1474  			}
  1475  			if iNdEx >= l {
  1476  				return io.ErrUnexpectedEOF
  1477  			}
  1478  			b := dAtA[iNdEx]
  1479  			iNdEx++
  1480  			wire |= uint64(b&0x7F) << shift
  1481  			if b < 0x80 {
  1482  				break
  1483  			}
  1484  		}
  1485  		fieldNum := int32(wire >> 3)
  1486  		wireType := int(wire & 0x7)
  1487  		if wireType == 4 {
  1488  			return fmt.Errorf("proto: StorageVersionSpec: wiretype end group for non-group")
  1489  		}
  1490  		if fieldNum <= 0 {
  1491  			return fmt.Errorf("proto: StorageVersionSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  1492  		}
  1493  		switch fieldNum {
  1494  		default:
  1495  			iNdEx = preIndex
  1496  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1497  			if err != nil {
  1498  				return err
  1499  			}
  1500  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1501  				return ErrInvalidLengthGenerated
  1502  			}
  1503  			if (iNdEx + skippy) > l {
  1504  				return io.ErrUnexpectedEOF
  1505  			}
  1506  			iNdEx += skippy
  1507  		}
  1508  	}
  1509  
  1510  	if iNdEx > l {
  1511  		return io.ErrUnexpectedEOF
  1512  	}
  1513  	return nil
  1514  }
  1515  func (m *StorageVersionStatus) Unmarshal(dAtA []byte) error {
  1516  	l := len(dAtA)
  1517  	iNdEx := 0
  1518  	for iNdEx < l {
  1519  		preIndex := iNdEx
  1520  		var wire uint64
  1521  		for shift := uint(0); ; shift += 7 {
  1522  			if shift >= 64 {
  1523  				return ErrIntOverflowGenerated
  1524  			}
  1525  			if iNdEx >= l {
  1526  				return io.ErrUnexpectedEOF
  1527  			}
  1528  			b := dAtA[iNdEx]
  1529  			iNdEx++
  1530  			wire |= uint64(b&0x7F) << shift
  1531  			if b < 0x80 {
  1532  				break
  1533  			}
  1534  		}
  1535  		fieldNum := int32(wire >> 3)
  1536  		wireType := int(wire & 0x7)
  1537  		if wireType == 4 {
  1538  			return fmt.Errorf("proto: StorageVersionStatus: wiretype end group for non-group")
  1539  		}
  1540  		if fieldNum <= 0 {
  1541  			return fmt.Errorf("proto: StorageVersionStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  1542  		}
  1543  		switch fieldNum {
  1544  		case 1:
  1545  			if wireType != 2 {
  1546  				return fmt.Errorf("proto: wrong wireType = %d for field StorageVersions", wireType)
  1547  			}
  1548  			var msglen int
  1549  			for shift := uint(0); ; shift += 7 {
  1550  				if shift >= 64 {
  1551  					return ErrIntOverflowGenerated
  1552  				}
  1553  				if iNdEx >= l {
  1554  					return io.ErrUnexpectedEOF
  1555  				}
  1556  				b := dAtA[iNdEx]
  1557  				iNdEx++
  1558  				msglen |= int(b&0x7F) << shift
  1559  				if b < 0x80 {
  1560  					break
  1561  				}
  1562  			}
  1563  			if msglen < 0 {
  1564  				return ErrInvalidLengthGenerated
  1565  			}
  1566  			postIndex := iNdEx + msglen
  1567  			if postIndex < 0 {
  1568  				return ErrInvalidLengthGenerated
  1569  			}
  1570  			if postIndex > l {
  1571  				return io.ErrUnexpectedEOF
  1572  			}
  1573  			m.StorageVersions = append(m.StorageVersions, ServerStorageVersion{})
  1574  			if err := m.StorageVersions[len(m.StorageVersions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1575  				return err
  1576  			}
  1577  			iNdEx = postIndex
  1578  		case 2:
  1579  			if wireType != 2 {
  1580  				return fmt.Errorf("proto: wrong wireType = %d for field CommonEncodingVersion", wireType)
  1581  			}
  1582  			var stringLen uint64
  1583  			for shift := uint(0); ; shift += 7 {
  1584  				if shift >= 64 {
  1585  					return ErrIntOverflowGenerated
  1586  				}
  1587  				if iNdEx >= l {
  1588  					return io.ErrUnexpectedEOF
  1589  				}
  1590  				b := dAtA[iNdEx]
  1591  				iNdEx++
  1592  				stringLen |= uint64(b&0x7F) << shift
  1593  				if b < 0x80 {
  1594  					break
  1595  				}
  1596  			}
  1597  			intStringLen := int(stringLen)
  1598  			if intStringLen < 0 {
  1599  				return ErrInvalidLengthGenerated
  1600  			}
  1601  			postIndex := iNdEx + intStringLen
  1602  			if postIndex < 0 {
  1603  				return ErrInvalidLengthGenerated
  1604  			}
  1605  			if postIndex > l {
  1606  				return io.ErrUnexpectedEOF
  1607  			}
  1608  			s := string(dAtA[iNdEx:postIndex])
  1609  			m.CommonEncodingVersion = &s
  1610  			iNdEx = postIndex
  1611  		case 3:
  1612  			if wireType != 2 {
  1613  				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
  1614  			}
  1615  			var msglen int
  1616  			for shift := uint(0); ; shift += 7 {
  1617  				if shift >= 64 {
  1618  					return ErrIntOverflowGenerated
  1619  				}
  1620  				if iNdEx >= l {
  1621  					return io.ErrUnexpectedEOF
  1622  				}
  1623  				b := dAtA[iNdEx]
  1624  				iNdEx++
  1625  				msglen |= int(b&0x7F) << shift
  1626  				if b < 0x80 {
  1627  					break
  1628  				}
  1629  			}
  1630  			if msglen < 0 {
  1631  				return ErrInvalidLengthGenerated
  1632  			}
  1633  			postIndex := iNdEx + msglen
  1634  			if postIndex < 0 {
  1635  				return ErrInvalidLengthGenerated
  1636  			}
  1637  			if postIndex > l {
  1638  				return io.ErrUnexpectedEOF
  1639  			}
  1640  			m.Conditions = append(m.Conditions, StorageVersionCondition{})
  1641  			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1642  				return err
  1643  			}
  1644  			iNdEx = postIndex
  1645  		default:
  1646  			iNdEx = preIndex
  1647  			skippy, err := skipGenerated(dAtA[iNdEx:])
  1648  			if err != nil {
  1649  				return err
  1650  			}
  1651  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  1652  				return ErrInvalidLengthGenerated
  1653  			}
  1654  			if (iNdEx + skippy) > l {
  1655  				return io.ErrUnexpectedEOF
  1656  			}
  1657  			iNdEx += skippy
  1658  		}
  1659  	}
  1660  
  1661  	if iNdEx > l {
  1662  		return io.ErrUnexpectedEOF
  1663  	}
  1664  	return nil
  1665  }
  1666  func skipGenerated(dAtA []byte) (n int, err error) {
  1667  	l := len(dAtA)
  1668  	iNdEx := 0
  1669  	depth := 0
  1670  	for iNdEx < l {
  1671  		var wire uint64
  1672  		for shift := uint(0); ; shift += 7 {
  1673  			if shift >= 64 {
  1674  				return 0, ErrIntOverflowGenerated
  1675  			}
  1676  			if iNdEx >= l {
  1677  				return 0, io.ErrUnexpectedEOF
  1678  			}
  1679  			b := dAtA[iNdEx]
  1680  			iNdEx++
  1681  			wire |= (uint64(b) & 0x7F) << shift
  1682  			if b < 0x80 {
  1683  				break
  1684  			}
  1685  		}
  1686  		wireType := int(wire & 0x7)
  1687  		switch wireType {
  1688  		case 0:
  1689  			for shift := uint(0); ; shift += 7 {
  1690  				if shift >= 64 {
  1691  					return 0, ErrIntOverflowGenerated
  1692  				}
  1693  				if iNdEx >= l {
  1694  					return 0, io.ErrUnexpectedEOF
  1695  				}
  1696  				iNdEx++
  1697  				if dAtA[iNdEx-1] < 0x80 {
  1698  					break
  1699  				}
  1700  			}
  1701  		case 1:
  1702  			iNdEx += 8
  1703  		case 2:
  1704  			var length int
  1705  			for shift := uint(0); ; shift += 7 {
  1706  				if shift >= 64 {
  1707  					return 0, ErrIntOverflowGenerated
  1708  				}
  1709  				if iNdEx >= l {
  1710  					return 0, io.ErrUnexpectedEOF
  1711  				}
  1712  				b := dAtA[iNdEx]
  1713  				iNdEx++
  1714  				length |= (int(b) & 0x7F) << shift
  1715  				if b < 0x80 {
  1716  					break
  1717  				}
  1718  			}
  1719  			if length < 0 {
  1720  				return 0, ErrInvalidLengthGenerated
  1721  			}
  1722  			iNdEx += length
  1723  		case 3:
  1724  			depth++
  1725  		case 4:
  1726  			if depth == 0 {
  1727  				return 0, ErrUnexpectedEndOfGroupGenerated
  1728  			}
  1729  			depth--
  1730  		case 5:
  1731  			iNdEx += 4
  1732  		default:
  1733  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1734  		}
  1735  		if iNdEx < 0 {
  1736  			return 0, ErrInvalidLengthGenerated
  1737  		}
  1738  		if depth == 0 {
  1739  			return iNdEx, nil
  1740  		}
  1741  	}
  1742  	return 0, io.ErrUnexpectedEOF
  1743  }
  1744  
  1745  var (
  1746  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
  1747  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
  1748  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
  1749  )
  1750  

View as plain text