Source file src/k8s.io/api/admission/v1beta1/generated.pb.go

Documentation: k8s.io/api/admission/v1beta1

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

View as plain text