cmd/bpa-operator/vendor/k8s.io/api/admissionregistration/v1alpha1/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/admissionregistration/v1alpha1/generated.proto
  19
  20 /*
  21         Package v1alpha1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1alpha1/generated.proto
  25
  26         It has these top-level messages:
  27                 Initializer
  28                 InitializerConfiguration
  29                 InitializerConfigurationList
  30                 Rule
  31 */
  32 package v1alpha1
  33
  34 import proto "github.com/gogo/protobuf/proto"
  35 import fmt "fmt"
  36 import math "math"
  37
  38 import strings "strings"
  39 import reflect "reflect"
  40
  41 import io "io"
  42
  43 // Reference imports to suppress errors if they are not otherwise used.
  44 var _ = proto.Marshal
  45 var _ = fmt.Errorf
  46 var _ = math.Inf
  47
  48 // This is a compile-time assertion to ensure that this generated file
  49 // is compatible with the proto package it is being compiled against.
  50 // A compilation error at this line likely means your copy of the
  51 // proto package needs to be updated.
  52 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  53
  54 func (m *Initializer) Reset()                    { *m = Initializer{} }
  55 func (*Initializer) ProtoMessage()               {}
  56 func (*Initializer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  57
  58 func (m *InitializerConfiguration) Reset()      { *m = InitializerConfiguration{} }
  59 func (*InitializerConfiguration) ProtoMessage() {}
  60 func (*InitializerConfiguration) Descriptor() ([]byte, []int) {
  61         return fileDescriptorGenerated, []int{1}
  62 }
  63
  64 func (m *InitializerConfigurationList) Reset()      { *m = InitializerConfigurationList{} }
  65 func (*InitializerConfigurationList) ProtoMessage() {}
  66 func (*InitializerConfigurationList) Descriptor() ([]byte, []int) {
  67         return fileDescriptorGenerated, []int{2}
  68 }
  69
  70 func (m *Rule) Reset()                    { *m = Rule{} }
  71 func (*Rule) ProtoMessage()               {}
  72 func (*Rule) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
  73
  74 func init() {
  75         proto.RegisterType((*Initializer)(nil), "k8s.io.api.admissionregistration.v1alpha1.Initializer")
  76         proto.RegisterType((*InitializerConfiguration)(nil), "k8s.io.api.admissionregistration.v1alpha1.InitializerConfiguration")
  77         proto.RegisterType((*InitializerConfigurationList)(nil), "k8s.io.api.admissionregistration.v1alpha1.InitializerConfigurationList")
  78         proto.RegisterType((*Rule)(nil), "k8s.io.api.admissionregistration.v1alpha1.Rule")
  79 }
  80 func (m *Initializer) Marshal() (dAtA []byte, err error) {
  81         size := m.Size()
  82         dAtA = make([]byte, size)
  83         n, err := m.MarshalTo(dAtA)
  84         if err != nil {
  85                 return nil, err
  86         }
  87         return dAtA[:n], nil
  88 }
  89
  90 func (m *Initializer) MarshalTo(dAtA []byte) (int, error) {
  91         var i int
  92         _ = i
  93         var l int
  94         _ = l
  95         dAtA[i] = 0xa
  96         i++
  97         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  98         i += copy(dAtA[i:], m.Name)
  99         if len(m.Rules) > 0 {
 100                 for _, msg := range m.Rules {
 101                         dAtA[i] = 0x12
 102                         i++
 103                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 104                         n, err := msg.MarshalTo(dAtA[i:])
 105                         if err != nil {
 106                                 return 0, err
 107                         }
 108                         i += n
 109                 }
 110         }
 111         return i, nil
 112 }
 113
 114 func (m *InitializerConfiguration) Marshal() (dAtA []byte, err error) {
 115         size := m.Size()
 116         dAtA = make([]byte, size)
 117         n, err := m.MarshalTo(dAtA)
 118         if err != nil {
 119                 return nil, err
 120         }
 121         return dAtA[:n], nil
 122 }
 123
 124 func (m *InitializerConfiguration) MarshalTo(dAtA []byte) (int, error) {
 125         var i int
 126         _ = i
 127         var l int
 128         _ = l
 129         dAtA[i] = 0xa
 130         i++
 131         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 132         n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 133         if err != nil {
 134                 return 0, err
 135         }
 136         i += n1
 137         if len(m.Initializers) > 0 {
 138                 for _, msg := range m.Initializers {
 139                         dAtA[i] = 0x12
 140                         i++
 141                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 142                         n, err := msg.MarshalTo(dAtA[i:])
 143                         if err != nil {
 144                                 return 0, err
 145                         }
 146                         i += n
 147                 }
 148         }
 149         return i, nil
 150 }
 151
 152 func (m *InitializerConfigurationList) Marshal() (dAtA []byte, err error) {
 153         size := m.Size()
 154         dAtA = make([]byte, size)
 155         n, err := m.MarshalTo(dAtA)
 156         if err != nil {
 157                 return nil, err
 158         }
 159         return dAtA[:n], nil
 160 }
 161
 162 func (m *InitializerConfigurationList) MarshalTo(dAtA []byte) (int, error) {
 163         var i int
 164         _ = i
 165         var l int
 166         _ = l
 167         dAtA[i] = 0xa
 168         i++
 169         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 170         n2, err := m.ListMeta.MarshalTo(dAtA[i:])
 171         if err != nil {
 172                 return 0, err
 173         }
 174         i += n2
 175         if len(m.Items) > 0 {
 176                 for _, msg := range m.Items {
 177                         dAtA[i] = 0x12
 178                         i++
 179                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 180                         n, err := msg.MarshalTo(dAtA[i:])
 181                         if err != nil {
 182                                 return 0, err
 183                         }
 184                         i += n
 185                 }
 186         }
 187         return i, nil
 188 }
 189
 190 func (m *Rule) Marshal() (dAtA []byte, err error) {
 191         size := m.Size()
 192         dAtA = make([]byte, size)
 193         n, err := m.MarshalTo(dAtA)
 194         if err != nil {
 195                 return nil, err
 196         }
 197         return dAtA[:n], nil
 198 }
 199
 200 func (m *Rule) MarshalTo(dAtA []byte) (int, error) {
 201         var i int
 202         _ = i
 203         var l int
 204         _ = l
 205         if len(m.APIGroups) > 0 {
 206                 for _, s := range m.APIGroups {
 207                         dAtA[i] = 0xa
 208                         i++
 209                         l = len(s)
 210                         for l >= 1<<7 {
 211                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 212                                 l >>= 7
 213                                 i++
 214                         }
 215                         dAtA[i] = uint8(l)
 216                         i++
 217                         i += copy(dAtA[i:], s)
 218                 }
 219         }
 220         if len(m.APIVersions) > 0 {
 221                 for _, s := range m.APIVersions {
 222                         dAtA[i] = 0x12
 223                         i++
 224                         l = len(s)
 225                         for l >= 1<<7 {
 226                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 227                                 l >>= 7
 228                                 i++
 229                         }
 230                         dAtA[i] = uint8(l)
 231                         i++
 232                         i += copy(dAtA[i:], s)
 233                 }
 234         }
 235         if len(m.Resources) > 0 {
 236                 for _, s := range m.Resources {
 237                         dAtA[i] = 0x1a
 238                         i++
 239                         l = len(s)
 240                         for l >= 1<<7 {
 241                                 dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
 242                                 l >>= 7
 243                                 i++
 244                         }
 245                         dAtA[i] = uint8(l)
 246                         i++
 247                         i += copy(dAtA[i:], s)
 248                 }
 249         }
 250         return i, nil
 251 }
 252
 253 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 254         for v >= 1<<7 {
 255                 dAtA[offset] = uint8(v&0x7f | 0x80)
 256                 v >>= 7
 257                 offset++
 258         }
 259         dAtA[offset] = uint8(v)
 260         return offset + 1
 261 }
 262 func (m *Initializer) Size() (n int) {
 263         var l int
 264         _ = l
 265         l = len(m.Name)
 266         n += 1 + l + sovGenerated(uint64(l))
 267         if len(m.Rules) > 0 {
 268                 for _, e := range m.Rules {
 269                         l = e.Size()
 270                         n += 1 + l + sovGenerated(uint64(l))
 271                 }
 272         }
 273         return n
 274 }
 275
 276 func (m *InitializerConfiguration) Size() (n int) {
 277         var l int
 278         _ = l
 279         l = m.ObjectMeta.Size()
 280         n += 1 + l + sovGenerated(uint64(l))
 281         if len(m.Initializers) > 0 {
 282                 for _, e := range m.Initializers {
 283                         l = e.Size()
 284                         n += 1 + l + sovGenerated(uint64(l))
 285                 }
 286         }
 287         return n
 288 }
 289
 290 func (m *InitializerConfigurationList) Size() (n int) {
 291         var l int
 292         _ = l
 293         l = m.ListMeta.Size()
 294         n += 1 + l + sovGenerated(uint64(l))
 295         if len(m.Items) > 0 {
 296                 for _, e := range m.Items {
 297                         l = e.Size()
 298                         n += 1 + l + sovGenerated(uint64(l))
 299                 }
 300         }
 301         return n
 302 }
 303
 304 func (m *Rule) Size() (n int) {
 305         var l int
 306         _ = l
 307         if len(m.APIGroups) > 0 {
 308                 for _, s := range m.APIGroups {
 309                         l = len(s)
 310                         n += 1 + l + sovGenerated(uint64(l))
 311                 }
 312         }
 313         if len(m.APIVersions) > 0 {
 314                 for _, s := range m.APIVersions {
 315                         l = len(s)
 316                         n += 1 + l + sovGenerated(uint64(l))
 317                 }
 318         }
 319         if len(m.Resources) > 0 {
 320                 for _, s := range m.Resources {
 321                         l = len(s)
 322                         n += 1 + l + sovGenerated(uint64(l))
 323                 }
 324         }
 325         return n
 326 }
 327
 328 func sovGenerated(x uint64) (n int) {
 329         for {
 330                 n++
 331                 x >>= 7
 332                 if x == 0 {
 333                         break
 334                 }
 335         }
 336         return n
 337 }
 338 func sozGenerated(x uint64) (n int) {
 339         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 340 }
 341 func (this *Initializer) String() string {
 342         if this == nil {
 343                 return "nil"
 344         }
 345         s := strings.Join([]string{`&Initializer{`,
 346                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
 347                 `Rules:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Rules), "Rule", "Rule", 1), `&`, ``, 1) + `,`,
 348                 `}`,
 349         }, "")
 350         return s
 351 }
 352 func (this *InitializerConfiguration) String() string {
 353         if this == nil {
 354                 return "nil"
 355         }
 356         s := strings.Join([]string{`&InitializerConfiguration{`,
 357                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 358                 `Initializers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Initializers), "Initializer", "Initializer", 1), `&`, ``, 1) + `,`,
 359                 `}`,
 360         }, "")
 361         return s
 362 }
 363 func (this *InitializerConfigurationList) String() string {
 364         if this == nil {
 365                 return "nil"
 366         }
 367         s := strings.Join([]string{`&InitializerConfigurationList{`,
 368                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 369                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "InitializerConfiguration", "InitializerConfiguration", 1), `&`, ``, 1) + `,`,
 370                 `}`,
 371         }, "")
 372         return s
 373 }
 374 func (this *Rule) String() string {
 375         if this == nil {
 376                 return "nil"
 377         }
 378         s := strings.Join([]string{`&Rule{`,
 379                 `APIGroups:` + fmt.Sprintf("%v", this.APIGroups) + `,`,
 380                 `APIVersions:` + fmt.Sprintf("%v", this.APIVersions) + `,`,
 381                 `Resources:` + fmt.Sprintf("%v", this.Resources) + `,`,
 382                 `}`,
 383         }, "")
 384         return s
 385 }
 386 func valueToStringGenerated(v interface{}) string {
 387         rv := reflect.ValueOf(v)
 388         if rv.IsNil() {
 389                 return "nil"
 390         }
 391         pv := reflect.Indirect(rv).Interface()
 392         return fmt.Sprintf("*%v", pv)
 393 }
 394 func (m *Initializer) Unmarshal(dAtA []byte) error {
 395         l := len(dAtA)
 396         iNdEx := 0
 397         for iNdEx < l {
 398                 preIndex := iNdEx
 399                 var wire uint64
 400                 for shift := uint(0); ; shift += 7 {
 401                         if shift >= 64 {
 402                                 return ErrIntOverflowGenerated
 403                         }
 404                         if iNdEx >= l {
 405                                 return io.ErrUnexpectedEOF
 406                         }
 407                         b := dAtA[iNdEx]
 408                         iNdEx++
 409                         wire |= (uint64(b) & 0x7F) << shift
 410                         if b < 0x80 {
 411                                 break
 412                         }
 413                 }
 414                 fieldNum := int32(wire >> 3)
 415                 wireType := int(wire & 0x7)
 416                 if wireType == 4 {
 417                         return fmt.Errorf("proto: Initializer: wiretype end group for non-group")
 418                 }
 419                 if fieldNum <= 0 {
 420                         return fmt.Errorf("proto: Initializer: illegal tag %d (wire type %d)", fieldNum, wire)
 421                 }
 422                 switch fieldNum {
 423                 case 1:
 424                         if wireType != 2 {
 425                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 426                         }
 427                         var stringLen uint64
 428                         for shift := uint(0); ; shift += 7 {
 429                                 if shift >= 64 {
 430                                         return ErrIntOverflowGenerated
 431                                 }
 432                                 if iNdEx >= l {
 433                                         return io.ErrUnexpectedEOF
 434                                 }
 435                                 b := dAtA[iNdEx]
 436                                 iNdEx++
 437                                 stringLen |= (uint64(b) & 0x7F) << shift
 438                                 if b < 0x80 {
 439                                         break
 440                                 }
 441                         }
 442                         intStringLen := int(stringLen)
 443                         if intStringLen < 0 {
 444                                 return ErrInvalidLengthGenerated
 445                         }
 446                         postIndex := iNdEx + intStringLen
 447                         if postIndex > l {
 448                                 return io.ErrUnexpectedEOF
 449                         }
 450                         m.Name = string(dAtA[iNdEx:postIndex])
 451                         iNdEx = postIndex
 452                 case 2:
 453                         if wireType != 2 {
 454                                 return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
 455                         }
 456                         var msglen int
 457                         for shift := uint(0); ; shift += 7 {
 458                                 if shift >= 64 {
 459                                         return ErrIntOverflowGenerated
 460                                 }
 461                                 if iNdEx >= l {
 462                                         return io.ErrUnexpectedEOF
 463                                 }
 464                                 b := dAtA[iNdEx]
 465                                 iNdEx++
 466                                 msglen |= (int(b) & 0x7F) << shift
 467                                 if b < 0x80 {
 468                                         break
 469                                 }
 470                         }
 471                         if msglen < 0 {
 472                                 return ErrInvalidLengthGenerated
 473                         }
 474                         postIndex := iNdEx + msglen
 475                         if postIndex > l {
 476                                 return io.ErrUnexpectedEOF
 477                         }
 478                         m.Rules = append(m.Rules, Rule{})
 479                         if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 480                                 return err
 481                         }
 482                         iNdEx = postIndex
 483                 default:
 484                         iNdEx = preIndex
 485                         skippy, err := skipGenerated(dAtA[iNdEx:])
 486                         if err != nil {
 487                                 return err
 488                         }
 489                         if skippy < 0 {
 490                                 return ErrInvalidLengthGenerated
 491                         }
 492                         if (iNdEx + skippy) > l {
 493                                 return io.ErrUnexpectedEOF
 494                         }
 495                         iNdEx += skippy
 496                 }
 497         }
 498
 499         if iNdEx > l {
 500                 return io.ErrUnexpectedEOF
 501         }
 502         return nil
 503 }
 504 func (m *InitializerConfiguration) Unmarshal(dAtA []byte) error {
 505         l := len(dAtA)
 506         iNdEx := 0
 507         for iNdEx < l {
 508                 preIndex := iNdEx
 509                 var wire uint64
 510                 for shift := uint(0); ; shift += 7 {
 511                         if shift >= 64 {
 512                                 return ErrIntOverflowGenerated
 513                         }
 514                         if iNdEx >= l {
 515                                 return io.ErrUnexpectedEOF
 516                         }
 517                         b := dAtA[iNdEx]
 518                         iNdEx++
 519                         wire |= (uint64(b) & 0x7F) << shift
 520                         if b < 0x80 {
 521                                 break
 522                         }
 523                 }
 524                 fieldNum := int32(wire >> 3)
 525                 wireType := int(wire & 0x7)
 526                 if wireType == 4 {
 527                         return fmt.Errorf("proto: InitializerConfiguration: wiretype end group for non-group")
 528                 }
 529                 if fieldNum <= 0 {
 530                         return fmt.Errorf("proto: InitializerConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
 531                 }
 532                 switch fieldNum {
 533                 case 1:
 534                         if wireType != 2 {
 535                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 536                         }
 537                         var msglen int
 538                         for shift := uint(0); ; shift += 7 {
 539                                 if shift >= 64 {
 540                                         return ErrIntOverflowGenerated
 541                                 }
 542                                 if iNdEx >= l {
 543                                         return io.ErrUnexpectedEOF
 544                                 }
 545                                 b := dAtA[iNdEx]
 546                                 iNdEx++
 547                                 msglen |= (int(b) & 0x7F) << shift
 548                                 if b < 0x80 {
 549                                         break
 550                                 }
 551                         }
 552                         if msglen < 0 {
 553                                 return ErrInvalidLengthGenerated
 554                         }
 555                         postIndex := iNdEx + msglen
 556                         if postIndex > l {
 557                                 return io.ErrUnexpectedEOF
 558                         }
 559                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 560                                 return err
 561                         }
 562                         iNdEx = postIndex
 563                 case 2:
 564                         if wireType != 2 {
 565                                 return fmt.Errorf("proto: wrong wireType = %d for field Initializers", wireType)
 566                         }
 567                         var msglen int
 568                         for shift := uint(0); ; shift += 7 {
 569                                 if shift >= 64 {
 570                                         return ErrIntOverflowGenerated
 571                                 }
 572                                 if iNdEx >= l {
 573                                         return io.ErrUnexpectedEOF
 574                                 }
 575                                 b := dAtA[iNdEx]
 576                                 iNdEx++
 577                                 msglen |= (int(b) & 0x7F) << shift
 578                                 if b < 0x80 {
 579                                         break
 580                                 }
 581                         }
 582                         if msglen < 0 {
 583                                 return ErrInvalidLengthGenerated
 584                         }
 585                         postIndex := iNdEx + msglen
 586                         if postIndex > l {
 587                                 return io.ErrUnexpectedEOF
 588                         }
 589                         m.Initializers = append(m.Initializers, Initializer{})
 590                         if err := m.Initializers[len(m.Initializers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 591                                 return err
 592                         }
 593                         iNdEx = postIndex
 594                 default:
 595                         iNdEx = preIndex
 596                         skippy, err := skipGenerated(dAtA[iNdEx:])
 597                         if err != nil {
 598                                 return err
 599                         }
 600                         if skippy < 0 {
 601                                 return ErrInvalidLengthGenerated
 602                         }
 603                         if (iNdEx + skippy) > l {
 604                                 return io.ErrUnexpectedEOF
 605                         }
 606                         iNdEx += skippy
 607                 }
 608         }
 609
 610         if iNdEx > l {
 611                 return io.ErrUnexpectedEOF
 612         }
 613         return nil
 614 }
 615 func (m *InitializerConfigurationList) Unmarshal(dAtA []byte) error {
 616         l := len(dAtA)
 617         iNdEx := 0
 618         for iNdEx < l {
 619                 preIndex := iNdEx
 620                 var wire uint64
 621                 for shift := uint(0); ; shift += 7 {
 622                         if shift >= 64 {
 623                                 return ErrIntOverflowGenerated
 624                         }
 625                         if iNdEx >= l {
 626                                 return io.ErrUnexpectedEOF
 627                         }
 628                         b := dAtA[iNdEx]
 629                         iNdEx++
 630                         wire |= (uint64(b) & 0x7F) << shift
 631                         if b < 0x80 {
 632                                 break
 633                         }
 634                 }
 635                 fieldNum := int32(wire >> 3)
 636                 wireType := int(wire & 0x7)
 637                 if wireType == 4 {
 638                         return fmt.Errorf("proto: InitializerConfigurationList: wiretype end group for non-group")
 639                 }
 640                 if fieldNum <= 0 {
 641                         return fmt.Errorf("proto: InitializerConfigurationList: illegal tag %d (wire type %d)", fieldNum, wire)
 642                 }
 643                 switch fieldNum {
 644                 case 1:
 645                         if wireType != 2 {
 646                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 647                         }
 648                         var msglen int
 649                         for shift := uint(0); ; shift += 7 {
 650                                 if shift >= 64 {
 651                                         return ErrIntOverflowGenerated
 652                                 }
 653                                 if iNdEx >= l {
 654                                         return io.ErrUnexpectedEOF
 655                                 }
 656                                 b := dAtA[iNdEx]
 657                                 iNdEx++
 658                                 msglen |= (int(b) & 0x7F) << shift
 659                                 if b < 0x80 {
 660                                         break
 661                                 }
 662                         }
 663                         if msglen < 0 {
 664                                 return ErrInvalidLengthGenerated
 665                         }
 666                         postIndex := iNdEx + msglen
 667                         if postIndex > l {
 668                                 return io.ErrUnexpectedEOF
 669                         }
 670                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 671                                 return err
 672                         }
 673                         iNdEx = postIndex
 674                 case 2:
 675                         if wireType != 2 {
 676                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 677                         }
 678                         var msglen int
 679                         for shift := uint(0); ; shift += 7 {
 680                                 if shift >= 64 {
 681                                         return ErrIntOverflowGenerated
 682                                 }
 683                                 if iNdEx >= l {
 684                                         return io.ErrUnexpectedEOF
 685                                 }
 686                                 b := dAtA[iNdEx]
 687                                 iNdEx++
 688                                 msglen |= (int(b) & 0x7F) << shift
 689                                 if b < 0x80 {
 690                                         break
 691                                 }
 692                         }
 693                         if msglen < 0 {
 694                                 return ErrInvalidLengthGenerated
 695                         }
 696                         postIndex := iNdEx + msglen
 697                         if postIndex > l {
 698                                 return io.ErrUnexpectedEOF
 699                         }
 700                         m.Items = append(m.Items, InitializerConfiguration{})
 701                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 702                                 return err
 703                         }
 704                         iNdEx = postIndex
 705                 default:
 706                         iNdEx = preIndex
 707                         skippy, err := skipGenerated(dAtA[iNdEx:])
 708                         if err != nil {
 709                                 return err
 710                         }
 711                         if skippy < 0 {
 712                                 return ErrInvalidLengthGenerated
 713                         }
 714                         if (iNdEx + skippy) > l {
 715                                 return io.ErrUnexpectedEOF
 716                         }
 717                         iNdEx += skippy
 718                 }
 719         }
 720
 721         if iNdEx > l {
 722                 return io.ErrUnexpectedEOF
 723         }
 724         return nil
 725 }
 726 func (m *Rule) Unmarshal(dAtA []byte) error {
 727         l := len(dAtA)
 728         iNdEx := 0
 729         for iNdEx < l {
 730                 preIndex := iNdEx
 731                 var wire uint64
 732                 for shift := uint(0); ; shift += 7 {
 733                         if shift >= 64 {
 734                                 return ErrIntOverflowGenerated
 735                         }
 736                         if iNdEx >= l {
 737                                 return io.ErrUnexpectedEOF
 738                         }
 739                         b := dAtA[iNdEx]
 740                         iNdEx++
 741                         wire |= (uint64(b) & 0x7F) << shift
 742                         if b < 0x80 {
 743                                 break
 744                         }
 745                 }
 746                 fieldNum := int32(wire >> 3)
 747                 wireType := int(wire & 0x7)
 748                 if wireType == 4 {
 749                         return fmt.Errorf("proto: Rule: wiretype end group for non-group")
 750                 }
 751                 if fieldNum <= 0 {
 752                         return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire)
 753                 }
 754                 switch fieldNum {
 755                 case 1:
 756                         if wireType != 2 {
 757                                 return fmt.Errorf("proto: wrong wireType = %d for field APIGroups", wireType)
 758                         }
 759                         var stringLen uint64
 760                         for shift := uint(0); ; shift += 7 {
 761                                 if shift >= 64 {
 762                                         return ErrIntOverflowGenerated
 763                                 }
 764                                 if iNdEx >= l {
 765                                         return io.ErrUnexpectedEOF
 766                                 }
 767                                 b := dAtA[iNdEx]
 768                                 iNdEx++
 769                                 stringLen |= (uint64(b) & 0x7F) << shift
 770                                 if b < 0x80 {
 771                                         break
 772                                 }
 773                         }
 774                         intStringLen := int(stringLen)
 775                         if intStringLen < 0 {
 776                                 return ErrInvalidLengthGenerated
 777                         }
 778                         postIndex := iNdEx + intStringLen
 779                         if postIndex > l {
 780                                 return io.ErrUnexpectedEOF
 781                         }
 782                         m.APIGroups = append(m.APIGroups, string(dAtA[iNdEx:postIndex]))
 783                         iNdEx = postIndex
 784                 case 2:
 785                         if wireType != 2 {
 786                                 return fmt.Errorf("proto: wrong wireType = %d for field APIVersions", wireType)
 787                         }
 788                         var stringLen uint64
 789                         for shift := uint(0); ; shift += 7 {
 790                                 if shift >= 64 {
 791                                         return ErrIntOverflowGenerated
 792                                 }
 793                                 if iNdEx >= l {
 794                                         return io.ErrUnexpectedEOF
 795                                 }
 796                                 b := dAtA[iNdEx]
 797                                 iNdEx++
 798                                 stringLen |= (uint64(b) & 0x7F) << shift
 799                                 if b < 0x80 {
 800                                         break
 801                                 }
 802                         }
 803                         intStringLen := int(stringLen)
 804                         if intStringLen < 0 {
 805                                 return ErrInvalidLengthGenerated
 806                         }
 807                         postIndex := iNdEx + intStringLen
 808                         if postIndex > l {
 809                                 return io.ErrUnexpectedEOF
 810                         }
 811                         m.APIVersions = append(m.APIVersions, string(dAtA[iNdEx:postIndex]))
 812                         iNdEx = postIndex
 813                 case 3:
 814                         if wireType != 2 {
 815                                 return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
 816                         }
 817                         var stringLen uint64
 818                         for shift := uint(0); ; shift += 7 {
 819                                 if shift >= 64 {
 820                                         return ErrIntOverflowGenerated
 821                                 }
 822                                 if iNdEx >= l {
 823                                         return io.ErrUnexpectedEOF
 824                                 }
 825                                 b := dAtA[iNdEx]
 826                                 iNdEx++
 827                                 stringLen |= (uint64(b) & 0x7F) << shift
 828                                 if b < 0x80 {
 829                                         break
 830                                 }
 831                         }
 832                         intStringLen := int(stringLen)
 833                         if intStringLen < 0 {
 834                                 return ErrInvalidLengthGenerated
 835                         }
 836                         postIndex := iNdEx + intStringLen
 837                         if postIndex > l {
 838                                 return io.ErrUnexpectedEOF
 839                         }
 840                         m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))
 841                         iNdEx = postIndex
 842                 default:
 843                         iNdEx = preIndex
 844                         skippy, err := skipGenerated(dAtA[iNdEx:])
 845                         if err != nil {
 846                                 return err
 847                         }
 848                         if skippy < 0 {
 849                                 return ErrInvalidLengthGenerated
 850                         }
 851                         if (iNdEx + skippy) > l {
 852                                 return io.ErrUnexpectedEOF
 853                         }
 854                         iNdEx += skippy
 855                 }
 856         }
 857
 858         if iNdEx > l {
 859                 return io.ErrUnexpectedEOF
 860         }
 861         return nil
 862 }
 863 func skipGenerated(dAtA []byte) (n int, err error) {
 864         l := len(dAtA)
 865         iNdEx := 0
 866         for iNdEx < l {
 867                 var wire uint64
 868                 for shift := uint(0); ; shift += 7 {
 869                         if shift >= 64 {
 870                                 return 0, ErrIntOverflowGenerated
 871                         }
 872                         if iNdEx >= l {
 873                                 return 0, io.ErrUnexpectedEOF
 874                         }
 875                         b := dAtA[iNdEx]
 876                         iNdEx++
 877                         wire |= (uint64(b) & 0x7F) << shift
 878                         if b < 0x80 {
 879                                 break
 880                         }
 881                 }
 882                 wireType := int(wire & 0x7)
 883                 switch wireType {
 884                 case 0:
 885                         for shift := uint(0); ; shift += 7 {
 886                                 if shift >= 64 {
 887                                         return 0, ErrIntOverflowGenerated
 888                                 }
 889                                 if iNdEx >= l {
 890                                         return 0, io.ErrUnexpectedEOF
 891                                 }
 892                                 iNdEx++
 893                                 if dAtA[iNdEx-1] < 0x80 {
 894                                         break
 895                                 }
 896                         }
 897                         return iNdEx, nil
 898                 case 1:
 899                         iNdEx += 8
 900                         return iNdEx, nil
 901                 case 2:
 902                         var length int
 903                         for shift := uint(0); ; shift += 7 {
 904                                 if shift >= 64 {
 905                                         return 0, ErrIntOverflowGenerated
 906                                 }
 907                                 if iNdEx >= l {
 908                                         return 0, io.ErrUnexpectedEOF
 909                                 }
 910                                 b := dAtA[iNdEx]
 911                                 iNdEx++
 912                                 length |= (int(b) & 0x7F) << shift
 913                                 if b < 0x80 {
 914                                         break
 915                                 }
 916                         }
 917                         iNdEx += length
 918                         if length < 0 {
 919                                 return 0, ErrInvalidLengthGenerated
 920                         }
 921                         return iNdEx, nil
 922                 case 3:
 923                         for {
 924                                 var innerWire uint64
 925                                 var start int = iNdEx
 926                                 for shift := uint(0); ; shift += 7 {
 927                                         if shift >= 64 {
 928                                                 return 0, ErrIntOverflowGenerated
 929                                         }
 930                                         if iNdEx >= l {
 931                                                 return 0, io.ErrUnexpectedEOF
 932                                         }
 933                                         b := dAtA[iNdEx]
 934                                         iNdEx++
 935                                         innerWire |= (uint64(b) & 0x7F) << shift
 936                                         if b < 0x80 {
 937                                                 break
 938                                         }
 939                                 }
 940                                 innerWireType := int(innerWire & 0x7)
 941                                 if innerWireType == 4 {
 942                                         break
 943                                 }
 944                                 next, err := skipGenerated(dAtA[start:])
 945                                 if err != nil {
 946                                         return 0, err
 947                                 }
 948                                 iNdEx = start + next
 949                         }
 950                         return iNdEx, nil
 951                 case 4:
 952                         return iNdEx, nil
 953                 case 5:
 954                         iNdEx += 4
 955                         return iNdEx, nil
 956                 default:
 957                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 958                 }
 959         }
 960         panic("unreachable")
 961 }
 962
 963 var (
 964         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
 965         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
 966 )
 967
 968 func init() {
 969         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/admissionregistration/v1alpha1/generated.proto", fileDescriptorGenerated)
 970 }
 971
 972 var fileDescriptorGenerated = []byte{
 973         // 531 bytes of a gzipped FileDescriptorProto
 974         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x51, 0x4d, 0x8b, 0x13, 0x31,
 975         0x18, 0x6e, 0x6c, 0x0b, 0x6d, 0xda, 0x45, 0x19, 0x3c, 0x94, 0x22, 0xd3, 0xd2, 0x53, 0x45, 0x4c,
 976         0xec, 0x22, 0x8b, 0xd7, 0x9d, 0x3d, 0x48, 0xc1, 0x8f, 0x25, 0x88, 0x07, 0xf1, 0x60, 0xda, 0xbe,
 977         0x3b, 0x8d, 0xed, 0x4c, 0x86, 0x24, 0x53, 0xd0, 0x93, 0x17, 0xef, 0x82, 0x7f, 0xaa, 0xc7, 0x3d,
 978         0xee, 0xa9, 0xd8, 0x11, 0x3c, 0xfa, 0x1b, 0x24, 0x33, 0x9d, 0x9d, 0x59, 0xeb, 0xe2, 0xea, 0x2d,
 979         0xef, 0xf3, 0xe6, 0xf9, 0x4a, 0x30, 0x5b, 0x3c, 0xd1, 0x44, 0x48, 0xba, 0x88, 0x27, 0xa0, 0x42,
 980         0x30, 0xa0, 0xe9, 0x0a, 0xc2, 0x99, 0x54, 0x74, 0xb7, 0xe0, 0x91, 0xa0, 0x7c, 0x16, 0x08, 0xad,
 981         0x85, 0x0c, 0x15, 0xf8, 0x42, 0x1b, 0xc5, 0x8d, 0x90, 0x21, 0x5d, 0x8d, 0xf8, 0x32, 0x9a, 0xf3,
 982         0x11, 0xf5, 0x21, 0x04, 0xc5, 0x0d, 0xcc, 0x48, 0xa4, 0xa4, 0x91, 0xce, 0xfd, 0x8c, 0x4a, 0x78,
 983         0x24, 0xc8, 0x1f, 0xa9, 0x24, 0xa7, 0x76, 0x1f, 0xfa, 0xc2, 0xcc, 0xe3, 0x09, 0x99, 0xca, 0x80,
 984         0xfa, 0xd2, 0x97, 0x34, 0x55, 0x98, 0xc4, 0x67, 0xe9, 0x94, 0x0e, 0xe9, 0x29, 0x53, 0xee, 0x3e,
 985         0x2e, 0x42, 0x05, 0x7c, 0x3a, 0x17, 0x21, 0xa8, 0x0f, 0x34, 0x5a, 0xf8, 0x16, 0xd0, 0x34, 0x00,
 986         0xc3, 0xe9, 0x6a, 0x2f, 0x4f, 0x97, 0x5e, 0xc7, 0x52, 0x71, 0x68, 0x44, 0x00, 0x7b, 0x84, 0xa3,
 987         0xbf, 0x11, 0xf4, 0x74, 0x0e, 0x01, 0xff, 0x9d, 0x37, 0xf8, 0x8c, 0x70, 0x6b, 0x1c, 0x0a, 0x23,
 988         0xf8, 0x52, 0x7c, 0x04, 0xe5, 0xf4, 0x71, 0x2d, 0xe4, 0x01, 0x74, 0x50, 0x1f, 0x0d, 0x9b, 0x5e,
 989         0x7b, 0xbd, 0xe9, 0x55, 0x92, 0x4d, 0xaf, 0xf6, 0x82, 0x07, 0xc0, 0xd2, 0x8d, 0xf3, 0x0a, 0xd7,
 990         0x55, 0xbc, 0x04, 0xdd, 0xb9, 0xd5, 0xaf, 0x0e, 0x5b, 0x87, 0x94, 0xdc, 0xf8, 0xe9, 0x08, 0x8b,
 991         0x97, 0xe0, 0x1d, 0xec, 0x34, 0xeb, 0x76, 0xd2, 0x2c, 0x13, 0x1b, 0xfc, 0x44, 0xb8, 0x53, 0xca,
 992         0x71, 0x22, 0xc3, 0x33, 0xe1, 0xc7, 0x99, 0x80, 0xf3, 0x0e, 0x37, 0xec, 0x43, 0xcd, 0xb8, 0xe1,
 993         0x69, 0xb0, 0xd6, 0xe1, 0xa3, 0x92, 0xeb, 0x65, 0x5f, 0x12, 0x2d, 0x7c, 0x0b, 0x68, 0x62, 0x6f,
 994         0x93, 0xd5, 0x88, 0xbc, 0x9c, 0xbc, 0x87, 0xa9, 0x79, 0x0e, 0x86, 0x7b, 0xce, 0xce, 0x16, 0x17,
 995         0x18, 0xbb, 0x54, 0x75, 0x22, 0xdc, 0x16, 0x85, 0x7b, 0xde, 0xed, 0xe8, 0x1f, 0xba, 0x95, 0xc2,
 996         0x7b, 0x77, 0x77, 0x5e, 0xed, 0x12, 0xa8, 0xd9, 0x15, 0x87, 0xc1, 0x0f, 0x84, 0xef, 0x5d, 0x57,
 997         0xf8, 0x99, 0xd0, 0xc6, 0x79, 0xbb, 0x57, 0x9a, 0xdc, 0xac, 0xb4, 0x65, 0xa7, 0x95, 0xef, 0xec,
 998         0x62, 0x34, 0x72, 0xa4, 0x54, 0x78, 0x8e, 0xeb, 0xc2, 0x40, 0x90, 0x37, 0x3d, 0xf9, 0xbf, 0xa6,
 999         0x57, 0x52, 0x17, 0x3f, 0x3b, 0xb6, 0xca, 0x2c, 0x33, 0x18, 0x7c, 0x45, 0xb8, 0x66, 0xbf, 0xda,
1000         0x79, 0x80, 0x9b, 0x3c, 0x12, 0x4f, 0x95, 0x8c, 0x23, 0xdd, 0x41, 0xfd, 0xea, 0xb0, 0xe9, 0x1d,
1001         0x24, 0x9b, 0x5e, 0xf3, 0xf8, 0x74, 0x9c, 0x81, 0xac, 0xd8, 0x3b, 0x23, 0xdc, 0xe2, 0x91, 0x78,
1002         0x0d, 0xca, 0xe6, 0xc8, 0x52, 0x36, 0xbd, 0xdb, 0xc9, 0xa6, 0xd7, 0x3a, 0x3e, 0x1d, 0xe7, 0x30,
1003         0x2b, 0xdf, 0xb1, 0xfa, 0x0a, 0xb4, 0x8c, 0xd5, 0x14, 0x74, 0xa7, 0x5a, 0xe8, 0xb3, 0x1c, 0x64,
1004         0xc5, 0xde, 0x23, 0xeb, 0xad, 0x5b, 0x39, 0xdf, 0xba, 0x95, 0x8b, 0xad, 0x5b, 0xf9, 0x94, 0xb8,
1005         0x68, 0x9d, 0xb8, 0xe8, 0x3c, 0x71, 0xd1, 0x45, 0xe2, 0xa2, 0x6f, 0x89, 0x8b, 0xbe, 0x7c, 0x77,
1006         0x2b, 0x6f, 0x1a, 0x79, 0xe9, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x06, 0xa3, 0xcb, 0x75,
1007         0x04, 0x00, 0x00,
1008 }