cmd/bpa-operator/vendor/k8s.io/api/admission/v1beta1/generated.pb.go

   1 /*
   2 Copyright The Kubernetes Authors.
   3
   4 Licensed under the Apache License, Version 2.0 (the "License");
   5 you may not use this file except in compliance with the License.
   6 You may obtain a copy of the License at
   7
   8     http://www.apache.org/licenses/LICENSE-2.0
   9
  10 Unless required by applicable law or agreed to in writing, software
  11 distributed under the License is distributed on an "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 See the License for the specific language governing permissions and
  14 limitations under the License.
  15 */
  16
  17 // Code generated by protoc-gen-gogo. DO NOT EDIT.
  18 // source: k8s.io/kubernetes/vendor/k8s.io/api/admission/v1beta1/generated.proto
  19
  20 /*
  21         Package v1beta1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/admission/v1beta1/generated.proto
  25
  26         It has these top-level messages:
  27                 AdmissionRequest
  28                 AdmissionResponse
  29                 AdmissionReview
  30 */
  31 package v1beta1
  32
  33 import proto "github.com/gogo/protobuf/proto"
  34 import fmt "fmt"
  35 import math "math"
  36
  37 import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  38
  39 import k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types"
  40
  41 import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
  42
  43 import strings "strings"
  44 import reflect "reflect"
  45
  46 import io "io"
  47
  48 // Reference imports to suppress errors if they are not otherwise used.
  49 var _ = proto.Marshal
  50 var _ = fmt.Errorf
  51 var _ = math.Inf
  52
  53 // This is a compile-time assertion to ensure that this generated file
  54 // is compatible with the proto package it is being compiled against.
  55 // A compilation error at this line likely means your copy of the
  56 // proto package needs to be updated.
  57 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  58
  59 func (m *AdmissionRequest) Reset()                    { *m = AdmissionRequest{} }
  60 func (*AdmissionRequest) ProtoMessage()               {}
  61 func (*AdmissionRequest) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  62
  63 func (m *AdmissionResponse) Reset()                    { *m = AdmissionResponse{} }
  64 func (*AdmissionResponse) ProtoMessage()               {}
  65 func (*AdmissionResponse) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  66
  67 func (m *AdmissionReview) Reset()                    { *m = AdmissionReview{} }
  68 func (*AdmissionReview) ProtoMessage()               {}
  69 func (*AdmissionReview) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  70
  71 func init() {
  72         proto.RegisterType((*AdmissionRequest)(nil), "k8s.io.api.admission.v1beta1.AdmissionRequest")
  73         proto.RegisterType((*AdmissionResponse)(nil), "k8s.io.api.admission.v1beta1.AdmissionResponse")
  74         proto.RegisterType((*AdmissionReview)(nil), "k8s.io.api.admission.v1beta1.AdmissionReview")
  75 }
  76 func (m *AdmissionRequest) Marshal() (dAtA []byte, err error) {
  77         size := m.Size()
  78         dAtA = make([]byte, size)
  79         n, err := m.MarshalTo(dAtA)
  80         if err != nil {
  81                 return nil, err
  82         }
  83         return dAtA[:n], nil
  84 }
  85
  86 func (m *AdmissionRequest) MarshalTo(dAtA []byte) (int, error) {
  87         var i int
  88         _ = i
  89         var l int
  90         _ = l
  91         dAtA[i] = 0xa
  92         i++
  93         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
  94         i += copy(dAtA[i:], m.UID)
  95         dAtA[i] = 0x12
  96         i++
  97         i = encodeVarintGenerated(dAtA, i, uint64(m.Kind.Size()))
  98         n1, err := m.Kind.MarshalTo(dAtA[i:])
  99         if err != nil {
 100                 return 0, err
 101         }
 102         i += n1
 103         dAtA[i] = 0x1a
 104         i++
 105         i = encodeVarintGenerated(dAtA, i, uint64(m.Resource.Size()))
 106         n2, err := m.Resource.MarshalTo(dAtA[i:])
 107         if err != nil {
 108                 return 0, err
 109         }
 110         i += n2
 111         dAtA[i] = 0x22
 112         i++
 113         i = encodeVarintGenerated(dAtA, i, uint64(len(m.SubResource)))
 114         i += copy(dAtA[i:], m.SubResource)
 115         dAtA[i] = 0x2a
 116         i++
 117         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 118         i += copy(dAtA[i:], m.Name)
 119         dAtA[i] = 0x32
 120         i++
 121         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
 122         i += copy(dAtA[i:], m.Namespace)
 123         dAtA[i] = 0x3a
 124         i++
 125         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operation)))
 126         i += copy(dAtA[i:], m.Operation)
 127         dAtA[i] = 0x42
 128         i++
 129         i = encodeVarintGenerated(dAtA, i, uint64(m.UserInfo.Size()))
 130         n3, err := m.UserInfo.MarshalTo(dAtA[i:])
 131         if err != nil {
 132                 return 0, err
 133         }
 134         i += n3
 135         dAtA[i] = 0x4a
 136         i++
 137         i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size()))
 138         n4, err := m.Object.MarshalTo(dAtA[i:])
 139         if err != nil {
 140                 return 0, err
 141         }
 142         i += n4
 143         dAtA[i] = 0x52
 144         i++
 145         i = encodeVarintGenerated(dAtA, i, uint64(m.OldObject.Size()))
 146         n5, err := m.OldObject.MarshalTo(dAtA[i:])
 147         if err != nil {
 148                 return 0, err
 149         }
 150         i += n5
 151         if m.DryRun != nil {
 152                 dAtA[i] = 0x58
 153                 i++
 154                 if *m.DryRun {
 155                         dAtA[i] = 1
 156                 } else {
 157                         dAtA[i] = 0
 158                 }
 159                 i++
 160         }
 161         return i, nil
 162 }
 163
 164 func (m *AdmissionResponse) Marshal() (dAtA []byte, err error) {
 165         size := m.Size()
 166         dAtA = make([]byte, size)
 167         n, err := m.MarshalTo(dAtA)
 168         if err != nil {
 169                 return nil, err
 170         }
 171         return dAtA[:n], nil
 172 }
 173
 174 func (m *AdmissionResponse) MarshalTo(dAtA []byte) (int, error) {
 175         var i int
 176         _ = i
 177         var l int
 178         _ = l
 179         dAtA[i] = 0xa
 180         i++
 181         i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID)))
 182         i += copy(dAtA[i:], m.UID)
 183         dAtA[i] = 0x10
 184         i++
 185         if m.Allowed {
 186                 dAtA[i] = 1
 187         } else {
 188                 dAtA[i] = 0
 189         }
 190         i++
 191         if m.Result != nil {
 192                 dAtA[i] = 0x1a
 193                 i++
 194                 i = encodeVarintGenerated(dAtA, i, uint64(m.Result.Size()))
 195                 n6, err := m.Result.MarshalTo(dAtA[i:])
 196                 if err != nil {
 197                         return 0, err
 198                 }
 199                 i += n6
 200         }
 201         if m.Patch != nil {
 202                 dAtA[i] = 0x22
 203                 i++
 204                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Patch)))
 205                 i += copy(dAtA[i:], m.Patch)
 206         }
 207         if m.PatchType != nil {
 208                 dAtA[i] = 0x2a
 209                 i++
 210                 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PatchType)))
 211                 i += copy(dAtA[i:], *m.PatchType)
 212         }
 213         if len(m.AuditAnnotations) > 0 {
 214                 keysForAuditAnnotations := make([]string, 0, len(m.AuditAnnotations))
 215                 for k := range m.AuditAnnotations {
 216                         keysForAuditAnnotations = append(keysForAuditAnnotations, string(k))
 217                 }
 218                 github_com_gogo_protobuf_sortkeys.Strings(keysForAuditAnnotations)
 219                 for _, k := range keysForAuditAnnotations {
 220                         dAtA[i] = 0x32
 221                         i++
 222                         v := m.AuditAnnotations[string(k)]
 223                         mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 224                         i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
 225                         dAtA[i] = 0xa
 226                         i++
 227                         i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
 228                         i += copy(dAtA[i:], k)
 229                         dAtA[i] = 0x12
 230                         i++
 231                         i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
 232                         i += copy(dAtA[i:], v)
 233                 }
 234         }
 235         return i, nil
 236 }
 237
 238 func (m *AdmissionReview) Marshal() (dAtA []byte, err error) {
 239         size := m.Size()
 240         dAtA = make([]byte, size)
 241         n, err := m.MarshalTo(dAtA)
 242         if err != nil {
 243                 return nil, err
 244         }
 245         return dAtA[:n], nil
 246 }
 247
 248 func (m *AdmissionReview) MarshalTo(dAtA []byte) (int, error) {
 249         var i int
 250         _ = i
 251         var l int
 252         _ = l
 253         if m.Request != nil {
 254                 dAtA[i] = 0xa
 255                 i++
 256                 i = encodeVarintGenerated(dAtA, i, uint64(m.Request.Size()))
 257                 n7, err := m.Request.MarshalTo(dAtA[i:])
 258                 if err != nil {
 259                         return 0, err
 260                 }
 261                 i += n7
 262         }
 263         if m.Response != nil {
 264                 dAtA[i] = 0x12
 265                 i++
 266                 i = encodeVarintGenerated(dAtA, i, uint64(m.Response.Size()))
 267                 n8, err := m.Response.MarshalTo(dAtA[i:])
 268                 if err != nil {
 269                         return 0, err
 270                 }
 271                 i += n8
 272         }
 273         return i, nil
 274 }
 275
 276 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 277         for v >= 1<<7 {
 278                 dAtA[offset] = uint8(v&0x7f | 0x80)
 279                 v >>= 7
 280                 offset++
 281         }
 282         dAtA[offset] = uint8(v)
 283         return offset + 1
 284 }
 285 func (m *AdmissionRequest) Size() (n int) {
 286         var l int
 287         _ = l
 288         l = len(m.UID)
 289         n += 1 + l + sovGenerated(uint64(l))
 290         l = m.Kind.Size()
 291         n += 1 + l + sovGenerated(uint64(l))
 292         l = m.Resource.Size()
 293         n += 1 + l + sovGenerated(uint64(l))
 294         l = len(m.SubResource)
 295         n += 1 + l + sovGenerated(uint64(l))
 296         l = len(m.Name)
 297         n += 1 + l + sovGenerated(uint64(l))
 298         l = len(m.Namespace)
 299         n += 1 + l + sovGenerated(uint64(l))
 300         l = len(m.Operation)
 301         n += 1 + l + sovGenerated(uint64(l))
 302         l = m.UserInfo.Size()
 303         n += 1 + l + sovGenerated(uint64(l))
 304         l = m.Object.Size()
 305         n += 1 + l + sovGenerated(uint64(l))
 306         l = m.OldObject.Size()
 307         n += 1 + l + sovGenerated(uint64(l))
 308         if m.DryRun != nil {
 309                 n += 2
 310         }
 311         return n
 312 }
 313
 314 func (m *AdmissionResponse) Size() (n int) {
 315         var l int
 316         _ = l
 317         l = len(m.UID)
 318         n += 1 + l + sovGenerated(uint64(l))
 319         n += 2
 320         if m.Result != nil {
 321                 l = m.Result.Size()
 322                 n += 1 + l + sovGenerated(uint64(l))
 323         }
 324         if m.Patch != nil {
 325                 l = len(m.Patch)
 326                 n += 1 + l + sovGenerated(uint64(l))
 327         }
 328         if m.PatchType != nil {
 329                 l = len(*m.PatchType)
 330                 n += 1 + l + sovGenerated(uint64(l))
 331         }
 332         if len(m.AuditAnnotations) > 0 {
 333                 for k, v := range m.AuditAnnotations {
 334                         _ = k
 335                         _ = v
 336                         mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
 337                         n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
 338                 }
 339         }
 340         return n
 341 }
 342
 343 func (m *AdmissionReview) Size() (n int) {
 344         var l int
 345         _ = l
 346         if m.Request != nil {
 347                 l = m.Request.Size()
 348                 n += 1 + l + sovGenerated(uint64(l))
 349         }
 350         if m.Response != nil {
 351                 l = m.Response.Size()
 352                 n += 1 + l + sovGenerated(uint64(l))
 353         }
 354         return n
 355 }
 356
 357 func sovGenerated(x uint64) (n int) {
 358         for {
 359                 n++
 360                 x >>= 7
 361                 if x == 0 {
 362                         break
 363                 }
 364         }
 365         return n
 366 }
 367 func sozGenerated(x uint64) (n int) {
 368         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 369 }
 370 func (this *AdmissionRequest) String() string {
 371         if this == nil {
 372                 return "nil"
 373         }
 374         s := strings.Join([]string{`&AdmissionRequest{`,
 375                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
 376                 `Kind:` + strings.Replace(strings.Replace(this.Kind.String(), "GroupVersionKind", "k8s_io_apimachinery_pkg_apis_meta_v1.GroupVersionKind", 1), `&`, ``, 1) + `,`,
 377                 `Resource:` + strings.Replace(strings.Replace(this.Resource.String(), "GroupVersionResource", "k8s_io_apimachinery_pkg_apis_meta_v1.GroupVersionResource", 1), `&`, ``, 1) + `,`,
 378                 `SubResource:` + fmt.Sprintf("%v", this.SubResource) + `,`,
 379                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 380                 `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
 381                 `Operation:` + fmt.Sprintf("%v", this.Operation) + `,`,
 382                 `UserInfo:` + strings.Replace(strings.Replace(this.UserInfo.String(), "UserInfo", "k8s_io_api_authentication_v1.UserInfo", 1), `&`, ``, 1) + `,`,
 383                 `Object:` + strings.Replace(strings.Replace(this.Object.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
 384                 `OldObject:` + strings.Replace(strings.Replace(this.OldObject.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`,
 385                 `DryRun:` + valueToStringGenerated(this.DryRun) + `,`,
 386                 `}`,
 387         }, "")
 388         return s
 389 }
 390 func (this *AdmissionResponse) String() string {
 391         if this == nil {
 392                 return "nil"
 393         }
 394         keysForAuditAnnotations := make([]string, 0, len(this.AuditAnnotations))
 395         for k := range this.AuditAnnotations {
 396                 keysForAuditAnnotations = append(keysForAuditAnnotations, k)
 397         }
 398         github_com_gogo_protobuf_sortkeys.Strings(keysForAuditAnnotations)
 399         mapStringForAuditAnnotations := "map[string]string{"
 400         for _, k := range keysForAuditAnnotations {
 401                 mapStringForAuditAnnotations += fmt.Sprintf("%v: %v,", k, this.AuditAnnotations[k])
 402         }
 403         mapStringForAuditAnnotations += "}"
 404         s := strings.Join([]string{`&AdmissionResponse{`,
 405                 `UID:` + fmt.Sprintf("%v", this.UID) + `,`,
 406                 `Allowed:` + fmt.Sprintf("%v", this.Allowed) + `,`,
 407                 `Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Status", "k8s_io_apimachinery_pkg_apis_meta_v1.Status", 1) + `,`,
 408                 `Patch:` + valueToStringGenerated(this.Patch) + `,`,
 409                 `PatchType:` + valueToStringGenerated(this.PatchType) + `,`,
 410                 `AuditAnnotations:` + mapStringForAuditAnnotations + `,`,
 411                 `}`,
 412         }, "")
 413         return s
 414 }
 415 func (this *AdmissionReview) String() string {
 416         if this == nil {
 417                 return "nil"
 418         }
 419         s := strings.Join([]string{`&AdmissionReview{`,
 420                 `Request:` + strings.Replace(fmt.Sprintf("%v", this.Request), "AdmissionRequest", "AdmissionRequest", 1) + `,`,
 421                 `Response:` + strings.Replace(fmt.Sprintf("%v", this.Response), "AdmissionResponse", "AdmissionResponse", 1) + `,`,
 422                 `}`,
 423         }, "")
 424         return s
 425 }
 426 func valueToStringGenerated(v interface{}) string {
 427         rv := reflect.ValueOf(v)
 428         if rv.IsNil() {
 429                 return "nil"
 430         }
 431         pv := reflect.Indirect(rv).Interface()
 432         return fmt.Sprintf("*%v", pv)
 433 }
 434 func (m *AdmissionRequest) Unmarshal(dAtA []byte) error {
 435         l := len(dAtA)
 436         iNdEx := 0
 437         for iNdEx < l {
 438                 preIndex := iNdEx
 439                 var wire uint64
 440                 for shift := uint(0); ; shift += 7 {
 441                         if shift >= 64 {
 442                                 return ErrIntOverflowGenerated
 443                         }
 444                         if iNdEx >= l {
 445                                 return io.ErrUnexpectedEOF
 446                         }
 447                         b := dAtA[iNdEx]
 448                         iNdEx++
 449                         wire |= (uint64(b) & 0x7F) << shift
 450                         if b < 0x80 {
 451                                 break
 452                         }
 453                 }
 454                 fieldNum := int32(wire >> 3)
 455                 wireType := int(wire & 0x7)
 456                 if wireType == 4 {
 457                         return fmt.Errorf("proto: AdmissionRequest: wiretype end group for non-group")
 458                 }
 459                 if fieldNum <= 0 {
 460                         return fmt.Errorf("proto: AdmissionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 461                 }
 462                 switch fieldNum {
 463                 case 1:
 464                         if wireType != 2 {
 465                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
 466                         }
 467                         var stringLen uint64
 468                         for shift := uint(0); ; shift += 7 {
 469                                 if shift >= 64 {
 470                                         return ErrIntOverflowGenerated
 471                                 }
 472                                 if iNdEx >= l {
 473                                         return io.ErrUnexpectedEOF
 474                                 }
 475                                 b := dAtA[iNdEx]
 476                                 iNdEx++
 477                                 stringLen |= (uint64(b) & 0x7F) << shift
 478                                 if b < 0x80 {
 479                                         break
 480                                 }
 481                         }
 482                         intStringLen := int(stringLen)
 483                         if intStringLen < 0 {
 484                                 return ErrInvalidLengthGenerated
 485                         }
 486                         postIndex := iNdEx + intStringLen
 487                         if postIndex > l {
 488                                 return io.ErrUnexpectedEOF
 489                         }
 490                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
 491                         iNdEx = postIndex
 492                 case 2:
 493                         if wireType != 2 {
 494                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
 495                         }
 496                         var msglen int
 497                         for shift := uint(0); ; shift += 7 {
 498                                 if shift >= 64 {
 499                                         return ErrIntOverflowGenerated
 500                                 }
 501                                 if iNdEx >= l {
 502                                         return io.ErrUnexpectedEOF
 503                                 }
 504                                 b := dAtA[iNdEx]
 505                                 iNdEx++
 506                                 msglen |= (int(b) & 0x7F) << shift
 507                                 if b < 0x80 {
 508                                         break
 509                                 }
 510                         }
 511                         if msglen < 0 {
 512                                 return ErrInvalidLengthGenerated
 513                         }
 514                         postIndex := iNdEx + msglen
 515                         if postIndex > l {
 516                                 return io.ErrUnexpectedEOF
 517                         }
 518                         if err := m.Kind.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 519                                 return err
 520                         }
 521                         iNdEx = postIndex
 522                 case 3:
 523                         if wireType != 2 {
 524                                 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
 525                         }
 526                         var msglen int
 527                         for shift := uint(0); ; shift += 7 {
 528                                 if shift >= 64 {
 529                                         return ErrIntOverflowGenerated
 530                                 }
 531                                 if iNdEx >= l {
 532                                         return io.ErrUnexpectedEOF
 533                                 }
 534                                 b := dAtA[iNdEx]
 535                                 iNdEx++
 536                                 msglen |= (int(b) & 0x7F) << shift
 537                                 if b < 0x80 {
 538                                         break
 539                                 }
 540                         }
 541                         if msglen < 0 {
 542                                 return ErrInvalidLengthGenerated
 543                         }
 544                         postIndex := iNdEx + msglen
 545                         if postIndex > l {
 546                                 return io.ErrUnexpectedEOF
 547                         }
 548                         if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 549                                 return err
 550                         }
 551                         iNdEx = postIndex
 552                 case 4:
 553                         if wireType != 2 {
 554                                 return fmt.Errorf("proto: wrong wireType = %d for field SubResource", wireType)
 555                         }
 556                         var stringLen uint64
 557                         for shift := uint(0); ; shift += 7 {
 558                                 if shift >= 64 {
 559                                         return ErrIntOverflowGenerated
 560                                 }
 561                                 if iNdEx >= l {
 562                                         return io.ErrUnexpectedEOF
 563                                 }
 564                                 b := dAtA[iNdEx]
 565                                 iNdEx++
 566                                 stringLen |= (uint64(b) & 0x7F) << shift
 567                                 if b < 0x80 {
 568                                         break
 569                                 }
 570                         }
 571                         intStringLen := int(stringLen)
 572                         if intStringLen < 0 {
 573                                 return ErrInvalidLengthGenerated
 574                         }
 575                         postIndex := iNdEx + intStringLen
 576                         if postIndex > l {
 577                                 return io.ErrUnexpectedEOF
 578                         }
 579                         m.SubResource = string(dAtA[iNdEx:postIndex])
 580                         iNdEx = postIndex
 581                 case 5:
 582                         if wireType != 2 {
 583                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 584                         }
 585                         var stringLen uint64
 586                         for shift := uint(0); ; shift += 7 {
 587                                 if shift >= 64 {
 588                                         return ErrIntOverflowGenerated
 589                                 }
 590                                 if iNdEx >= l {
 591                                         return io.ErrUnexpectedEOF
 592                                 }
 593                                 b := dAtA[iNdEx]
 594                                 iNdEx++
 595                                 stringLen |= (uint64(b) & 0x7F) << shift
 596                                 if b < 0x80 {
 597                                         break
 598                                 }
 599                         }
 600                         intStringLen := int(stringLen)
 601                         if intStringLen < 0 {
 602                                 return ErrInvalidLengthGenerated
 603                         }
 604                         postIndex := iNdEx + intStringLen
 605                         if postIndex > l {
 606                                 return io.ErrUnexpectedEOF
 607                         }
 608                         m.Name = string(dAtA[iNdEx:postIndex])
 609                         iNdEx = postIndex
 610                 case 6:
 611                         if wireType != 2 {
 612                                 return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
 613                         }
 614                         var stringLen uint64
 615                         for shift := uint(0); ; shift += 7 {
 616                                 if shift >= 64 {
 617                                         return ErrIntOverflowGenerated
 618                                 }
 619                                 if iNdEx >= l {
 620                                         return io.ErrUnexpectedEOF
 621                                 }
 622                                 b := dAtA[iNdEx]
 623                                 iNdEx++
 624                                 stringLen |= (uint64(b) & 0x7F) << shift
 625                                 if b < 0x80 {
 626                                         break
 627                                 }
 628                         }
 629                         intStringLen := int(stringLen)
 630                         if intStringLen < 0 {
 631                                 return ErrInvalidLengthGenerated
 632                         }
 633                         postIndex := iNdEx + intStringLen
 634                         if postIndex > l {
 635                                 return io.ErrUnexpectedEOF
 636                         }
 637                         m.Namespace = string(dAtA[iNdEx:postIndex])
 638                         iNdEx = postIndex
 639                 case 7:
 640                         if wireType != 2 {
 641                                 return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
 642                         }
 643                         var stringLen uint64
 644                         for shift := uint(0); ; shift += 7 {
 645                                 if shift >= 64 {
 646                                         return ErrIntOverflowGenerated
 647                                 }
 648                                 if iNdEx >= l {
 649                                         return io.ErrUnexpectedEOF
 650                                 }
 651                                 b := dAtA[iNdEx]
 652                                 iNdEx++
 653                                 stringLen |= (uint64(b) & 0x7F) << shift
 654                                 if b < 0x80 {
 655                                         break
 656                                 }
 657                         }
 658                         intStringLen := int(stringLen)
 659                         if intStringLen < 0 {
 660                                 return ErrInvalidLengthGenerated
 661                         }
 662                         postIndex := iNdEx + intStringLen
 663                         if postIndex > l {
 664                                 return io.ErrUnexpectedEOF
 665                         }
 666                         m.Operation = Operation(dAtA[iNdEx:postIndex])
 667                         iNdEx = postIndex
 668                 case 8:
 669                         if wireType != 2 {
 670                                 return fmt.Errorf("proto: wrong wireType = %d for field UserInfo", wireType)
 671                         }
 672                         var msglen int
 673                         for shift := uint(0); ; shift += 7 {
 674                                 if shift >= 64 {
 675                                         return ErrIntOverflowGenerated
 676                                 }
 677                                 if iNdEx >= l {
 678                                         return io.ErrUnexpectedEOF
 679                                 }
 680                                 b := dAtA[iNdEx]
 681                                 iNdEx++
 682                                 msglen |= (int(b) & 0x7F) << shift
 683                                 if b < 0x80 {
 684                                         break
 685                                 }
 686                         }
 687                         if msglen < 0 {
 688                                 return ErrInvalidLengthGenerated
 689                         }
 690                         postIndex := iNdEx + msglen
 691                         if postIndex > l {
 692                                 return io.ErrUnexpectedEOF
 693                         }
 694                         if err := m.UserInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 695                                 return err
 696                         }
 697                         iNdEx = postIndex
 698                 case 9:
 699                         if wireType != 2 {
 700                                 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
 701                         }
 702                         var msglen int
 703                         for shift := uint(0); ; shift += 7 {
 704                                 if shift >= 64 {
 705                                         return ErrIntOverflowGenerated
 706                                 }
 707                                 if iNdEx >= l {
 708                                         return io.ErrUnexpectedEOF
 709                                 }
 710                                 b := dAtA[iNdEx]
 711                                 iNdEx++
 712                                 msglen |= (int(b) & 0x7F) << shift
 713                                 if b < 0x80 {
 714                                         break
 715                                 }
 716                         }
 717                         if msglen < 0 {
 718                                 return ErrInvalidLengthGenerated
 719                         }
 720                         postIndex := iNdEx + msglen
 721                         if postIndex > l {
 722                                 return io.ErrUnexpectedEOF
 723                         }
 724                         if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 725                                 return err
 726                         }
 727                         iNdEx = postIndex
 728                 case 10:
 729                         if wireType != 2 {
 730                                 return fmt.Errorf("proto: wrong wireType = %d for field OldObject", wireType)
 731                         }
 732                         var msglen int
 733                         for shift := uint(0); ; shift += 7 {
 734                                 if shift >= 64 {
 735                                         return ErrIntOverflowGenerated
 736                                 }
 737                                 if iNdEx >= l {
 738                                         return io.ErrUnexpectedEOF
 739                                 }
 740                                 b := dAtA[iNdEx]
 741                                 iNdEx++
 742                                 msglen |= (int(b) & 0x7F) << shift
 743                                 if b < 0x80 {
 744                                         break
 745                                 }
 746                         }
 747                         if msglen < 0 {
 748                                 return ErrInvalidLengthGenerated
 749                         }
 750                         postIndex := iNdEx + msglen
 751                         if postIndex > l {
 752                                 return io.ErrUnexpectedEOF
 753                         }
 754                         if err := m.OldObject.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 755                                 return err
 756                         }
 757                         iNdEx = postIndex
 758                 case 11:
 759                         if wireType != 0 {
 760                                 return fmt.Errorf("proto: wrong wireType = %d for field DryRun", wireType)
 761                         }
 762                         var v int
 763                         for shift := uint(0); ; shift += 7 {
 764                                 if shift >= 64 {
 765                                         return ErrIntOverflowGenerated
 766                                 }
 767                                 if iNdEx >= l {
 768                                         return io.ErrUnexpectedEOF
 769                                 }
 770                                 b := dAtA[iNdEx]
 771                                 iNdEx++
 772                                 v |= (int(b) & 0x7F) << shift
 773                                 if b < 0x80 {
 774                                         break
 775                                 }
 776                         }
 777                         b := bool(v != 0)
 778                         m.DryRun = &b
 779                 default:
 780                         iNdEx = preIndex
 781                         skippy, err := skipGenerated(dAtA[iNdEx:])
 782                         if err != nil {
 783                                 return err
 784                         }
 785                         if skippy < 0 {
 786                                 return ErrInvalidLengthGenerated
 787                         }
 788                         if (iNdEx + skippy) > l {
 789                                 return io.ErrUnexpectedEOF
 790                         }
 791                         iNdEx += skippy
 792                 }
 793         }
 794
 795         if iNdEx > l {
 796                 return io.ErrUnexpectedEOF
 797         }
 798         return nil
 799 }
 800 func (m *AdmissionResponse) Unmarshal(dAtA []byte) error {
 801         l := len(dAtA)
 802         iNdEx := 0
 803         for iNdEx < l {
 804                 preIndex := iNdEx
 805                 var wire uint64
 806                 for shift := uint(0); ; shift += 7 {
 807                         if shift >= 64 {
 808                                 return ErrIntOverflowGenerated
 809                         }
 810                         if iNdEx >= l {
 811                                 return io.ErrUnexpectedEOF
 812                         }
 813                         b := dAtA[iNdEx]
 814                         iNdEx++
 815                         wire |= (uint64(b) & 0x7F) << shift
 816                         if b < 0x80 {
 817                                 break
 818                         }
 819                 }
 820                 fieldNum := int32(wire >> 3)
 821                 wireType := int(wire & 0x7)
 822                 if wireType == 4 {
 823                         return fmt.Errorf("proto: AdmissionResponse: wiretype end group for non-group")
 824                 }
 825                 if fieldNum <= 0 {
 826                         return fmt.Errorf("proto: AdmissionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 827                 }
 828                 switch fieldNum {
 829                 case 1:
 830                         if wireType != 2 {
 831                                 return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
 832                         }
 833                         var stringLen uint64
 834                         for shift := uint(0); ; shift += 7 {
 835                                 if shift >= 64 {
 836                                         return ErrIntOverflowGenerated
 837                                 }
 838                                 if iNdEx >= l {
 839                                         return io.ErrUnexpectedEOF
 840                                 }
 841                                 b := dAtA[iNdEx]
 842                                 iNdEx++
 843                                 stringLen |= (uint64(b) & 0x7F) << shift
 844                                 if b < 0x80 {
 845                                         break
 846                                 }
 847                         }
 848                         intStringLen := int(stringLen)
 849                         if intStringLen < 0 {
 850                                 return ErrInvalidLengthGenerated
 851                         }
 852                         postIndex := iNdEx + intStringLen
 853                         if postIndex > l {
 854                                 return io.ErrUnexpectedEOF
 855                         }
 856                         m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex])
 857                         iNdEx = postIndex
 858                 case 2:
 859                         if wireType != 0 {
 860                                 return fmt.Errorf("proto: wrong wireType = %d for field Allowed", wireType)
 861                         }
 862                         var v int
 863                         for shift := uint(0); ; shift += 7 {
 864                                 if shift >= 64 {
 865                                         return ErrIntOverflowGenerated
 866                                 }
 867                                 if iNdEx >= l {
 868                                         return io.ErrUnexpectedEOF
 869                                 }
 870                                 b := dAtA[iNdEx]
 871                                 iNdEx++
 872                                 v |= (int(b) & 0x7F) << shift
 873                                 if b < 0x80 {
 874                                         break
 875                                 }
 876                         }
 877                         m.Allowed = bool(v != 0)
 878                 case 3:
 879                         if wireType != 2 {
 880                                 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
 881                         }
 882                         var msglen int
 883                         for shift := uint(0); ; shift += 7 {
 884                                 if shift >= 64 {
 885                                         return ErrIntOverflowGenerated
 886                                 }
 887                                 if iNdEx >= l {
 888                                         return io.ErrUnexpectedEOF
 889                                 }
 890                                 b := dAtA[iNdEx]
 891                                 iNdEx++
 892                                 msglen |= (int(b) & 0x7F) << shift
 893                                 if b < 0x80 {
 894                                         break
 895                                 }
 896                         }
 897                         if msglen < 0 {
 898                                 return ErrInvalidLengthGenerated
 899                         }
 900                         postIndex := iNdEx + msglen
 901                         if postIndex > l {
 902                                 return io.ErrUnexpectedEOF
 903                         }
 904                         if m.Result == nil {
 905                                 m.Result = &k8s_io_apimachinery_pkg_apis_meta_v1.Status{}
 906                         }
 907                         if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 908                                 return err
 909                         }
 910                         iNdEx = postIndex
 911                 case 4:
 912                         if wireType != 2 {
 913                                 return fmt.Errorf("proto: wrong wireType = %d for field Patch", wireType)
 914                         }
 915                         var byteLen int
 916                         for shift := uint(0); ; shift += 7 {
 917                                 if shift >= 64 {
 918                                         return ErrIntOverflowGenerated
 919                                 }
 920                                 if iNdEx >= l {
 921                                         return io.ErrUnexpectedEOF
 922                                 }
 923                                 b := dAtA[iNdEx]
 924                                 iNdEx++
 925                                 byteLen |= (int(b) & 0x7F) << shift
 926                                 if b < 0x80 {
 927                                         break
 928                                 }
 929                         }
 930                         if byteLen < 0 {
 931                                 return ErrInvalidLengthGenerated
 932                         }
 933                         postIndex := iNdEx + byteLen
 934                         if postIndex > l {
 935                                 return io.ErrUnexpectedEOF
 936                         }
 937                         m.Patch = append(m.Patch[:0], dAtA[iNdEx:postIndex]...)
 938                         if m.Patch == nil {
 939                                 m.Patch = []byte{}
 940                         }
 941                         iNdEx = postIndex
 942                 case 5:
 943                         if wireType != 2 {
 944                                 return fmt.Errorf("proto: wrong wireType = %d for field PatchType", wireType)
 945                         }
 946                         var stringLen uint64
 947                         for shift := uint(0); ; shift += 7 {
 948                                 if shift >= 64 {
 949                                         return ErrIntOverflowGenerated
 950                                 }
 951                                 if iNdEx >= l {
 952                                         return io.ErrUnexpectedEOF
 953                                 }
 954                                 b := dAtA[iNdEx]
 955                                 iNdEx++
 956                                 stringLen |= (uint64(b) & 0x7F) << shift
 957                                 if b < 0x80 {
 958                                         break
 959                                 }
 960                         }
 961                         intStringLen := int(stringLen)
 962                         if intStringLen < 0 {
 963                                 return ErrInvalidLengthGenerated
 964                         }
 965                         postIndex := iNdEx + intStringLen
 966                         if postIndex > l {
 967                                 return io.ErrUnexpectedEOF
 968                         }
 969                         s := PatchType(dAtA[iNdEx:postIndex])
 970                         m.PatchType = &s
 971                         iNdEx = postIndex
 972                 case 6:
 973                         if wireType != 2 {
 974                                 return fmt.Errorf("proto: wrong wireType = %d for field AuditAnnotations", wireType)
 975                         }
 976                         var msglen int
 977                         for shift := uint(0); ; shift += 7 {
 978                                 if shift >= 64 {
 979                                         return ErrIntOverflowGenerated
 980                                 }
 981                                 if iNdEx >= l {
 982                                         return io.ErrUnexpectedEOF
 983                                 }
 984                                 b := dAtA[iNdEx]
 985                                 iNdEx++
 986                                 msglen |= (int(b) & 0x7F) << shift
 987                                 if b < 0x80 {
 988                                         break
 989                                 }
 990                         }
 991                         if msglen < 0 {
 992                                 return ErrInvalidLengthGenerated
 993                         }
 994                         postIndex := iNdEx + msglen
 995                         if postIndex > l {
 996                                 return io.ErrUnexpectedEOF
 997                         }
 998                         if m.AuditAnnotations == nil {
 999                                 m.AuditAnnotations = make(map[string]string)
1000                         }
1001                         var mapkey string
1002                         var mapvalue string
1003                         for iNdEx < postIndex {
1004                                 entryPreIndex := iNdEx
1005                                 var wire uint64
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                                         wire |= (uint64(b) & 0x7F) << shift
1016                                         if b < 0x80 {
1017                                                 break
1018                                         }
1019                                 }
1020                                 fieldNum := int32(wire >> 3)
1021                                 if fieldNum == 1 {
1022                                         var stringLenmapkey uint64
1023                                         for shift := uint(0); ; shift += 7 {
1024                                                 if shift >= 64 {
1025                                                         return ErrIntOverflowGenerated
1026                                                 }
1027                                                 if iNdEx >= l {
1028                                                         return io.ErrUnexpectedEOF
1029                                                 }
1030                                                 b := dAtA[iNdEx]
1031                                                 iNdEx++
1032                                                 stringLenmapkey |= (uint64(b) & 0x7F) << shift
1033                                                 if b < 0x80 {
1034                                                         break
1035                                                 }
1036                                         }
1037                                         intStringLenmapkey := int(stringLenmapkey)
1038                                         if intStringLenmapkey < 0 {
1039                                                 return ErrInvalidLengthGenerated
1040                                         }
1041                                         postStringIndexmapkey := iNdEx + intStringLenmapkey
1042                                         if postStringIndexmapkey > l {
1043                                                 return io.ErrUnexpectedEOF
1044                                         }
1045                                         mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1046                                         iNdEx = postStringIndexmapkey
1047                                 } else if fieldNum == 2 {
1048                                         var stringLenmapvalue uint64
1049                                         for shift := uint(0); ; shift += 7 {
1050                                                 if shift >= 64 {
1051                                                         return ErrIntOverflowGenerated
1052                                                 }
1053                                                 if iNdEx >= l {
1054                                                         return io.ErrUnexpectedEOF
1055                                                 }
1056                                                 b := dAtA[iNdEx]
1057                                                 iNdEx++
1058                                                 stringLenmapvalue |= (uint64(b) & 0x7F) << shift
1059                                                 if b < 0x80 {
1060                                                         break
1061                                                 }
1062                                         }
1063                                         intStringLenmapvalue := int(stringLenmapvalue)
1064                                         if intStringLenmapvalue < 0 {
1065                                                 return ErrInvalidLengthGenerated
1066                                         }
1067                                         postStringIndexmapvalue := iNdEx + intStringLenmapvalue
1068                                         if postStringIndexmapvalue > l {
1069                                                 return io.ErrUnexpectedEOF
1070                                         }
1071                                         mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
1072                                         iNdEx = postStringIndexmapvalue
1073                                 } else {
1074                                         iNdEx = entryPreIndex
1075                                         skippy, err := skipGenerated(dAtA[iNdEx:])
1076                                         if err != nil {
1077                                                 return err
1078                                         }
1079                                         if skippy < 0 {
1080                                                 return ErrInvalidLengthGenerated
1081                                         }
1082                                         if (iNdEx + skippy) > postIndex {
1083                                                 return io.ErrUnexpectedEOF
1084                                         }
1085                                         iNdEx += skippy
1086                                 }
1087                         }
1088                         m.AuditAnnotations[mapkey] = mapvalue
1089                         iNdEx = postIndex
1090                 default:
1091                         iNdEx = preIndex
1092                         skippy, err := skipGenerated(dAtA[iNdEx:])
1093                         if err != nil {
1094                                 return err
1095                         }
1096                         if skippy < 0 {
1097                                 return ErrInvalidLengthGenerated
1098                         }
1099                         if (iNdEx + skippy) > l {
1100                                 return io.ErrUnexpectedEOF
1101                         }
1102                         iNdEx += skippy
1103                 }
1104         }
1105
1106         if iNdEx > l {
1107                 return io.ErrUnexpectedEOF
1108         }
1109         return nil
1110 }
1111 func (m *AdmissionReview) Unmarshal(dAtA []byte) error {
1112         l := len(dAtA)
1113         iNdEx := 0
1114         for iNdEx < l {
1115                 preIndex := iNdEx
1116                 var wire uint64
1117                 for shift := uint(0); ; shift += 7 {
1118                         if shift >= 64 {
1119                                 return ErrIntOverflowGenerated
1120                         }
1121                         if iNdEx >= l {
1122                                 return io.ErrUnexpectedEOF
1123                         }
1124                         b := dAtA[iNdEx]
1125                         iNdEx++
1126                         wire |= (uint64(b) & 0x7F) << shift
1127                         if b < 0x80 {
1128                                 break
1129                         }
1130                 }
1131                 fieldNum := int32(wire >> 3)
1132                 wireType := int(wire & 0x7)
1133                 if wireType == 4 {
1134                         return fmt.Errorf("proto: AdmissionReview: wiretype end group for non-group")
1135                 }
1136                 if fieldNum <= 0 {
1137                         return fmt.Errorf("proto: AdmissionReview: illegal tag %d (wire type %d)", fieldNum, wire)
1138                 }
1139                 switch fieldNum {
1140                 case 1:
1141                         if wireType != 2 {
1142                                 return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
1143                         }
1144                         var msglen int
1145                         for shift := uint(0); ; shift += 7 {
1146                                 if shift >= 64 {
1147                                         return ErrIntOverflowGenerated
1148                                 }
1149                                 if iNdEx >= l {
1150                                         return io.ErrUnexpectedEOF
1151                                 }
1152                                 b := dAtA[iNdEx]
1153                                 iNdEx++
1154                                 msglen |= (int(b) & 0x7F) << shift
1155                                 if b < 0x80 {
1156                                         break
1157                                 }
1158                         }
1159                         if msglen < 0 {
1160                                 return ErrInvalidLengthGenerated
1161                         }
1162                         postIndex := iNdEx + msglen
1163                         if postIndex > l {
1164                                 return io.ErrUnexpectedEOF
1165                         }
1166                         if m.Request == nil {
1167                                 m.Request = &AdmissionRequest{}
1168                         }
1169                         if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1170                                 return err
1171                         }
1172                         iNdEx = postIndex
1173                 case 2:
1174                         if wireType != 2 {
1175                                 return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
1176                         }
1177                         var msglen int
1178                         for shift := uint(0); ; shift += 7 {
1179                                 if shift >= 64 {
1180                                         return ErrIntOverflowGenerated
1181                                 }
1182                                 if iNdEx >= l {
1183                                         return io.ErrUnexpectedEOF
1184                                 }
1185                                 b := dAtA[iNdEx]
1186                                 iNdEx++
1187                                 msglen |= (int(b) & 0x7F) << shift
1188                                 if b < 0x80 {
1189                                         break
1190                                 }
1191                         }
1192                         if msglen < 0 {
1193                                 return ErrInvalidLengthGenerated
1194                         }
1195                         postIndex := iNdEx + msglen
1196                         if postIndex > l {
1197                                 return io.ErrUnexpectedEOF
1198                         }
1199                         if m.Response == nil {
1200                                 m.Response = &AdmissionResponse{}
1201                         }
1202                         if err := m.Response.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1203                                 return err
1204                         }
1205                         iNdEx = postIndex
1206                 default:
1207                         iNdEx = preIndex
1208                         skippy, err := skipGenerated(dAtA[iNdEx:])
1209                         if err != nil {
1210                                 return err
1211                         }
1212                         if skippy < 0 {
1213                                 return ErrInvalidLengthGenerated
1214                         }
1215                         if (iNdEx + skippy) > l {
1216                                 return io.ErrUnexpectedEOF
1217                         }
1218                         iNdEx += skippy
1219                 }
1220         }
1221
1222         if iNdEx > l {
1223                 return io.ErrUnexpectedEOF
1224         }
1225         return nil
1226 }
1227 func skipGenerated(dAtA []byte) (n int, err error) {
1228         l := len(dAtA)
1229         iNdEx := 0
1230         for iNdEx < l {
1231                 var wire uint64
1232                 for shift := uint(0); ; shift += 7 {
1233                         if shift >= 64 {
1234                                 return 0, ErrIntOverflowGenerated
1235                         }
1236                         if iNdEx >= l {
1237                                 return 0, io.ErrUnexpectedEOF
1238                         }
1239                         b := dAtA[iNdEx]
1240                         iNdEx++
1241                         wire |= (uint64(b) & 0x7F) << shift
1242                         if b < 0x80 {
1243                                 break
1244                         }
1245                 }
1246                 wireType := int(wire & 0x7)
1247                 switch wireType {
1248                 case 0:
1249                         for shift := uint(0); ; shift += 7 {
1250                                 if shift >= 64 {
1251                                         return 0, ErrIntOverflowGenerated
1252                                 }
1253                                 if iNdEx >= l {
1254                                         return 0, io.ErrUnexpectedEOF
1255                                 }
1256                                 iNdEx++
1257                                 if dAtA[iNdEx-1] < 0x80 {
1258                                         break
1259                                 }
1260                         }
1261                         return iNdEx, nil
1262                 case 1:
1263                         iNdEx += 8
1264                         return iNdEx, nil
1265                 case 2:
1266                         var length int
1267                         for shift := uint(0); ; shift += 7 {
1268                                 if shift >= 64 {
1269                                         return 0, ErrIntOverflowGenerated
1270                                 }
1271                                 if iNdEx >= l {
1272                                         return 0, io.ErrUnexpectedEOF
1273                                 }
1274                                 b := dAtA[iNdEx]
1275                                 iNdEx++
1276                                 length |= (int(b) & 0x7F) << shift
1277                                 if b < 0x80 {
1278                                         break
1279                                 }
1280                         }
1281                         iNdEx += length
1282                         if length < 0 {
1283                                 return 0, ErrInvalidLengthGenerated
1284                         }
1285                         return iNdEx, nil
1286                 case 3:
1287                         for {
1288                                 var innerWire uint64
1289                                 var start int = iNdEx
1290                                 for shift := uint(0); ; shift += 7 {
1291                                         if shift >= 64 {
1292                                                 return 0, ErrIntOverflowGenerated
1293                                         }
1294                                         if iNdEx >= l {
1295                                                 return 0, io.ErrUnexpectedEOF
1296                                         }
1297                                         b := dAtA[iNdEx]
1298                                         iNdEx++
1299                                         innerWire |= (uint64(b) & 0x7F) << shift
1300                                         if b < 0x80 {
1301                                                 break
1302                                         }
1303                                 }
1304                                 innerWireType := int(innerWire & 0x7)
1305                                 if innerWireType == 4 {
1306                                         break
1307                                 }
1308                                 next, err := skipGenerated(dAtA[start:])
1309                                 if err != nil {
1310                                         return 0, err
1311                                 }
1312                                 iNdEx = start + next
1313                         }
1314                         return iNdEx, nil
1315                 case 4:
1316                         return iNdEx, nil
1317                 case 5:
1318                         iNdEx += 4
1319                         return iNdEx, nil
1320                 default:
1321                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1322                 }
1323         }
1324         panic("unreachable")
1325 }
1326
1327 var (
1328         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1329         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
1330 )
1331
1332 func init() {
1333         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/admission/v1beta1/generated.proto", fileDescriptorGenerated)
1334 }
1335
1336 var fileDescriptorGenerated = []byte{
1337         // 821 bytes of a gzipped FileDescriptorProto
1338         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcf, 0x6f, 0xe3, 0x44,
1339         0x14, 0x8e, 0x37, 0x69, 0x12, 0x4f, 0x2a, 0x36, 0x3b, 0x80, 0x64, 0x45, 0xc8, 0x09, 0x3d, 0xa0,
1340         0x20, 0x6d, 0xc7, 0xb4, 0x82, 0x55, 0xb5, 0xe2, 0x12, 0xd3, 0x08, 0x55, 0x48, 0xdb, 0x6a, 0x76,
1341         0x83, 0x80, 0x03, 0xd2, 0xc4, 0x9e, 0x4d, 0x4c, 0xe2, 0x19, 0xe3, 0x99, 0x49, 0xc9, 0x0d, 0x71,
1342         0xe5, 0x82, 0xc4, 0x9f, 0xc4, 0xa5, 0xc7, 0x3d, 0xee, 0x29, 0xa2, 0xe1, 0xbf, 0xe8, 0x09, 0x79,
1343         0x3c, 0x8e, 0x43, 0xba, 0x85, 0x5d, 0xb4, 0x27, 0xfb, 0xfd, 0xf8, 0xbe, 0x37, 0xf3, 0xbd, 0x37,
1344         0x0f, 0x0c, 0x67, 0x27, 0x02, 0x45, 0xdc, 0x9b, 0xa9, 0x31, 0x4d, 0x19, 0x95, 0x54, 0x78, 0x0b,
1345         0xca, 0x42, 0x9e, 0x7a, 0x26, 0x40, 0x92, 0xc8, 0x23, 0x61, 0x1c, 0x09, 0x11, 0x71, 0xe6, 0x2d,
1346         0x8e, 0xc6, 0x54, 0x92, 0x23, 0x6f, 0x42, 0x19, 0x4d, 0x89, 0xa4, 0x21, 0x4a, 0x52, 0x2e, 0x39,
1347         0xfc, 0x20, 0xcf, 0x46, 0x24, 0x89, 0xd0, 0x26, 0x1b, 0x99, 0xec, 0xce, 0xe1, 0x24, 0x92, 0x53,
1348         0x35, 0x46, 0x01, 0x8f, 0xbd, 0x09, 0x9f, 0x70, 0x4f, 0x83, 0xc6, 0xea, 0xb9, 0xb6, 0xb4, 0xa1,
1349         0xff, 0x72, 0xb2, 0xce, 0xc3, 0xed, 0xd2, 0x4a, 0x4e, 0x29, 0x93, 0x51, 0x40, 0x64, 0x5e, 0x7f,
1350         0xb7, 0x74, 0xe7, 0xd3, 0x32, 0x3b, 0x26, 0xc1, 0x34, 0x62, 0x34, 0x5d, 0x7a, 0xc9, 0x6c, 0x92,
1351         0x39, 0x84, 0x17, 0x53, 0x49, 0x5e, 0x85, 0xf2, 0xee, 0x42, 0xa5, 0x8a, 0xc9, 0x28, 0xa6, 0xb7,
1352         0x00, 0x8f, 0xfe, 0x0b, 0x20, 0x82, 0x29, 0x8d, 0xc9, 0x2e, 0xee, 0xe0, 0xf7, 0x3a, 0x68, 0x0f,
1353         0x0a, 0x45, 0x30, 0xfd, 0x51, 0x51, 0x21, 0xa1, 0x0f, 0xaa, 0x2a, 0x0a, 0x1d, 0xab, 0x67, 0xf5,
1354         0x6d, 0xff, 0x93, 0xab, 0x55, 0xb7, 0xb2, 0x5e, 0x75, 0xab, 0xa3, 0xb3, 0xd3, 0x9b, 0x55, 0xf7,
1355         0xc3, 0xbb, 0x0a, 0xc9, 0x65, 0x42, 0x05, 0x1a, 0x9d, 0x9d, 0xe2, 0x0c, 0x0c, 0xbf, 0x01, 0xb5,
1356         0x59, 0xc4, 0x42, 0xe7, 0x5e, 0xcf, 0xea, 0xb7, 0x8e, 0x1f, 0xa1, 0xb2, 0x03, 0x1b, 0x18, 0x4a,
1357         0x66, 0x93, 0xcc, 0x21, 0x50, 0x26, 0x03, 0x5a, 0x1c, 0xa1, 0x2f, 0x53, 0xae, 0x92, 0xaf, 0x69,
1358         0x9a, 0x1d, 0xe6, 0xab, 0x88, 0x85, 0xfe, 0xbe, 0x29, 0x5e, 0xcb, 0x2c, 0xac, 0x19, 0xe1, 0x14,
1359         0x34, 0x53, 0x2a, 0xb8, 0x4a, 0x03, 0xea, 0x54, 0x35, 0xfb, 0xe3, 0x37, 0x67, 0xc7, 0x86, 0xc1,
1360         0x6f, 0x9b, 0x0a, 0xcd, 0xc2, 0x83, 0x37, 0xec, 0xf0, 0x33, 0xd0, 0x12, 0x6a, 0x5c, 0x04, 0x9c,
1361         0x9a, 0xd6, 0xe3, 0x5d, 0x03, 0x68, 0x3d, 0x2d, 0x43, 0x78, 0x3b, 0x0f, 0xf6, 0x40, 0x8d, 0x91,
1362         0x98, 0x3a, 0x7b, 0x3a, 0x7f, 0x73, 0x85, 0x27, 0x24, 0xa6, 0x58, 0x47, 0xa0, 0x07, 0xec, 0xec,
1363         0x2b, 0x12, 0x12, 0x50, 0xa7, 0xae, 0xd3, 0x1e, 0x98, 0x34, 0xfb, 0x49, 0x11, 0xc0, 0x65, 0x0e,
1364         0xfc, 0x1c, 0xd8, 0x3c, 0xc9, 0x1a, 0x17, 0x71, 0xe6, 0x34, 0x34, 0xc0, 0x2d, 0x00, 0xe7, 0x45,
1365         0xe0, 0x66, 0xdb, 0xc0, 0x25, 0x00, 0x3e, 0x03, 0x4d, 0x25, 0x68, 0x7a, 0xc6, 0x9e, 0x73, 0xa7,
1366         0xa9, 0x15, 0xfb, 0x08, 0x6d, 0xbf, 0x88, 0x7f, 0x0c, 0x71, 0xa6, 0xd4, 0xc8, 0x64, 0x97, 0xea,
1367         0x14, 0x1e, 0xbc, 0x61, 0x82, 0x23, 0x50, 0xe7, 0xe3, 0x1f, 0x68, 0x20, 0x1d, 0x5b, 0x73, 0x1e,
1368         0xde, 0xd9, 0x05, 0x33, 0x83, 0x08, 0x93, 0xcb, 0xe1, 0x4f, 0x92, 0xb2, 0xac, 0x01, 0xfe, 0x3b,
1369         0x86, 0xba, 0x7e, 0xae, 0x49, 0xb0, 0x21, 0x83, 0xdf, 0x03, 0x9b, 0xcf, 0xc3, 0xdc, 0xe9, 0x80,
1370         0xff, 0xc3, 0xbc, 0x91, 0xf2, 0xbc, 0xe0, 0xc1, 0x25, 0x25, 0x3c, 0x00, 0xf5, 0x30, 0x5d, 0x62,
1371         0xc5, 0x9c, 0x56, 0xcf, 0xea, 0x37, 0x7d, 0x90, 0x9d, 0xe1, 0x54, 0x7b, 0xb0, 0x89, 0x1c, 0xfc,
1372         0x52, 0x03, 0x0f, 0xb6, 0x5e, 0x85, 0x48, 0x38, 0x13, 0xf4, 0xad, 0x3c, 0x8b, 0x8f, 0x41, 0x83,
1373         0xcc, 0xe7, 0xfc, 0x92, 0xe6, 0x2f, 0xa3, 0xe9, 0xdf, 0x37, 0x3c, 0x8d, 0x41, 0xee, 0xc6, 0x45,
1374         0x1c, 0x5e, 0x80, 0xba, 0x90, 0x44, 0x2a, 0x61, 0xa6, 0xfc, 0xe1, 0xeb, 0x4d, 0xf9, 0x53, 0x8d,
1375         0xc9, 0xaf, 0x85, 0xa9, 0x50, 0x73, 0x89, 0x0d, 0x0f, 0xec, 0x82, 0xbd, 0x84, 0xc8, 0x60, 0xaa,
1376         0x27, 0x79, 0xdf, 0xb7, 0xd7, 0xab, 0xee, 0xde, 0x45, 0xe6, 0xc0, 0xb9, 0x1f, 0x9e, 0x00, 0x5b,
1377         0xff, 0x3c, 0x5b, 0x26, 0xc5, 0xf8, 0x76, 0x32, 0x21, 0x2f, 0x0a, 0xe7, 0xcd, 0xb6, 0x81, 0xcb,
1378         0x64, 0xf8, 0xab, 0x05, 0xda, 0x44, 0x85, 0x91, 0x1c, 0x30, 0xc6, 0xa5, 0x1e, 0x24, 0xe1, 0xd4,
1379         0x7b, 0xd5, 0x7e, 0xeb, 0x78, 0x88, 0xfe, 0x6d, 0xfb, 0xa2, 0x5b, 0x3a, 0xa3, 0xc1, 0x0e, 0xcf,
1380         0x90, 0xc9, 0x74, 0xe9, 0x3b, 0x46, 0xa8, 0xf6, 0x6e, 0x18, 0xdf, 0x2a, 0xdc, 0xf9, 0x02, 0xbc,
1381         0xff, 0x4a, 0x12, 0xd8, 0x06, 0xd5, 0x19, 0x5d, 0xe6, 0x2d, 0xc4, 0xd9, 0x2f, 0x7c, 0x0f, 0xec,
1382         0x2d, 0xc8, 0x5c, 0x51, 0xdd, 0x0e, 0x1b, 0xe7, 0xc6, 0xe3, 0x7b, 0x27, 0xd6, 0xc1, 0x1f, 0x16,
1383         0xb8, 0xbf, 0x75, 0xb8, 0x45, 0x44, 0x2f, 0xe1, 0x08, 0x34, 0xd2, 0x7c, 0x49, 0x6a, 0x8e, 0xd6,
1384         0x31, 0x7a, 0xed, 0xcb, 0x69, 0x94, 0xdf, 0xca, 0x5a, 0x6d, 0x0c, 0x5c, 0x70, 0xc1, 0x6f, 0xf5,
1385         0x4a, 0xd3, 0xb7, 0x37, 0x0b, 0xd3, 0x7b, 0x43, 0xd1, 0xfc, 0x7d, 0xb3, 0xc3, 0xb4, 0x85, 0x37,
1386         0x74, 0xfe, 0xe1, 0xd5, 0xb5, 0x5b, 0x79, 0x71, 0xed, 0x56, 0x5e, 0x5e, 0xbb, 0x95, 0x9f, 0xd7,
1387         0xae, 0x75, 0xb5, 0x76, 0xad, 0x17, 0x6b, 0xd7, 0x7a, 0xb9, 0x76, 0xad, 0x3f, 0xd7, 0xae, 0xf5,
1388         0xdb, 0x5f, 0x6e, 0xe5, 0xbb, 0x86, 0x21, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xf4, 0xc2, 0x6f,
1389         0x1b, 0x71, 0x07, 0x00, 0x00,
1390 }