cmd/bpa-operator/vendor/k8s.io/apimachinery/pkg/runtime/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/apimachinery/pkg/runtime/generated.proto
  19
  20 /*
  21         Package runtime is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto
  25
  26         It has these top-level messages:
  27                 RawExtension
  28                 TypeMeta
  29                 Unknown
  30 */
  31 package runtime
  32
  33 import proto "github.com/gogo/protobuf/proto"
  34 import fmt "fmt"
  35 import math "math"
  36
  37 import strings "strings"
  38 import reflect "reflect"
  39
  40 import io "io"
  41
  42 // Reference imports to suppress errors if they are not otherwise used.
  43 var _ = proto.Marshal
  44 var _ = fmt.Errorf
  45 var _ = math.Inf
  46
  47 // This is a compile-time assertion to ensure that this generated file
  48 // is compatible with the proto package it is being compiled against.
  49 // A compilation error at this line likely means your copy of the
  50 // proto package needs to be updated.
  51 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  52
  53 func (m *RawExtension) Reset()                    { *m = RawExtension{} }
  54 func (*RawExtension) ProtoMessage()               {}
  55 func (*RawExtension) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
  56
  57 func (m *TypeMeta) Reset()                    { *m = TypeMeta{} }
  58 func (*TypeMeta) ProtoMessage()               {}
  59 func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  60
  61 func (m *Unknown) Reset()                    { *m = Unknown{} }
  62 func (*Unknown) ProtoMessage()               {}
  63 func (*Unknown) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  64
  65 func init() {
  66         proto.RegisterType((*RawExtension)(nil), "k8s.io.apimachinery.pkg.runtime.RawExtension")
  67         proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.runtime.TypeMeta")
  68         proto.RegisterType((*Unknown)(nil), "k8s.io.apimachinery.pkg.runtime.Unknown")
  69 }
  70 func (m *RawExtension) Marshal() (dAtA []byte, err error) {
  71         size := m.Size()
  72         dAtA = make([]byte, size)
  73         n, err := m.MarshalTo(dAtA)
  74         if err != nil {
  75                 return nil, err
  76         }
  77         return dAtA[:n], nil
  78 }
  79
  80 func (m *RawExtension) MarshalTo(dAtA []byte) (int, error) {
  81         var i int
  82         _ = i
  83         var l int
  84         _ = l
  85         if m.Raw != nil {
  86                 dAtA[i] = 0xa
  87                 i++
  88                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw)))
  89                 i += copy(dAtA[i:], m.Raw)
  90         }
  91         return i, nil
  92 }
  93
  94 func (m *TypeMeta) Marshal() (dAtA []byte, err error) {
  95         size := m.Size()
  96         dAtA = make([]byte, size)
  97         n, err := m.MarshalTo(dAtA)
  98         if err != nil {
  99                 return nil, err
 100         }
 101         return dAtA[:n], nil
 102 }
 103
 104 func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) {
 105         var i int
 106         _ = i
 107         var l int
 108         _ = l
 109         dAtA[i] = 0xa
 110         i++
 111         i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
 112         i += copy(dAtA[i:], m.APIVersion)
 113         dAtA[i] = 0x12
 114         i++
 115         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 116         i += copy(dAtA[i:], m.Kind)
 117         return i, nil
 118 }
 119
 120 func (m *Unknown) Marshal() (dAtA []byte, err error) {
 121         size := m.Size()
 122         dAtA = make([]byte, size)
 123         n, err := m.MarshalTo(dAtA)
 124         if err != nil {
 125                 return nil, err
 126         }
 127         return dAtA[:n], nil
 128 }
 129
 130 func (m *Unknown) MarshalTo(dAtA []byte) (int, error) {
 131         var i int
 132         _ = i
 133         var l int
 134         _ = l
 135         dAtA[i] = 0xa
 136         i++
 137         i = encodeVarintGenerated(dAtA, i, uint64(m.TypeMeta.Size()))
 138         n1, err := m.TypeMeta.MarshalTo(dAtA[i:])
 139         if err != nil {
 140                 return 0, err
 141         }
 142         i += n1
 143         if m.Raw != nil {
 144                 dAtA[i] = 0x12
 145                 i++
 146                 i = encodeVarintGenerated(dAtA, i, uint64(len(m.Raw)))
 147                 i += copy(dAtA[i:], m.Raw)
 148         }
 149         dAtA[i] = 0x1a
 150         i++
 151         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ContentEncoding)))
 152         i += copy(dAtA[i:], m.ContentEncoding)
 153         dAtA[i] = 0x22
 154         i++
 155         i = encodeVarintGenerated(dAtA, i, uint64(len(m.ContentType)))
 156         i += copy(dAtA[i:], m.ContentType)
 157         return i, nil
 158 }
 159
 160 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 161         for v >= 1<<7 {
 162                 dAtA[offset] = uint8(v&0x7f | 0x80)
 163                 v >>= 7
 164                 offset++
 165         }
 166         dAtA[offset] = uint8(v)
 167         return offset + 1
 168 }
 169 func (m *RawExtension) Size() (n int) {
 170         var l int
 171         _ = l
 172         if m.Raw != nil {
 173                 l = len(m.Raw)
 174                 n += 1 + l + sovGenerated(uint64(l))
 175         }
 176         return n
 177 }
 178
 179 func (m *TypeMeta) Size() (n int) {
 180         var l int
 181         _ = l
 182         l = len(m.APIVersion)
 183         n += 1 + l + sovGenerated(uint64(l))
 184         l = len(m.Kind)
 185         n += 1 + l + sovGenerated(uint64(l))
 186         return n
 187 }
 188
 189 func (m *Unknown) Size() (n int) {
 190         var l int
 191         _ = l
 192         l = m.TypeMeta.Size()
 193         n += 1 + l + sovGenerated(uint64(l))
 194         if m.Raw != nil {
 195                 l = len(m.Raw)
 196                 n += 1 + l + sovGenerated(uint64(l))
 197         }
 198         l = len(m.ContentEncoding)
 199         n += 1 + l + sovGenerated(uint64(l))
 200         l = len(m.ContentType)
 201         n += 1 + l + sovGenerated(uint64(l))
 202         return n
 203 }
 204
 205 func sovGenerated(x uint64) (n int) {
 206         for {
 207                 n++
 208                 x >>= 7
 209                 if x == 0 {
 210                         break
 211                 }
 212         }
 213         return n
 214 }
 215 func sozGenerated(x uint64) (n int) {
 216         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 217 }
 218 func (this *RawExtension) String() string {
 219         if this == nil {
 220                 return "nil"
 221         }
 222         s := strings.Join([]string{`&RawExtension{`,
 223                 `Raw:` + valueToStringGenerated(this.Raw) + `,`,
 224                 `}`,
 225         }, "")
 226         return s
 227 }
 228 func (this *TypeMeta) String() string {
 229         if this == nil {
 230                 return "nil"
 231         }
 232         s := strings.Join([]string{`&TypeMeta{`,
 233                 `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
 234                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
 235                 `}`,
 236         }, "")
 237         return s
 238 }
 239 func (this *Unknown) String() string {
 240         if this == nil {
 241                 return "nil"
 242         }
 243         s := strings.Join([]string{`&Unknown{`,
 244                 `TypeMeta:` + strings.Replace(strings.Replace(this.TypeMeta.String(), "TypeMeta", "TypeMeta", 1), `&`, ``, 1) + `,`,
 245                 `Raw:` + valueToStringGenerated(this.Raw) + `,`,
 246                 `ContentEncoding:` + fmt.Sprintf("%v", this.ContentEncoding) + `,`,
 247                 `ContentType:` + fmt.Sprintf("%v", this.ContentType) + `,`,
 248                 `}`,
 249         }, "")
 250         return s
 251 }
 252 func valueToStringGenerated(v interface{}) string {
 253         rv := reflect.ValueOf(v)
 254         if rv.IsNil() {
 255                 return "nil"
 256         }
 257         pv := reflect.Indirect(rv).Interface()
 258         return fmt.Sprintf("*%v", pv)
 259 }
 260 func (m *RawExtension) Unmarshal(dAtA []byte) error {
 261         l := len(dAtA)
 262         iNdEx := 0
 263         for iNdEx < l {
 264                 preIndex := iNdEx
 265                 var wire uint64
 266                 for shift := uint(0); ; shift += 7 {
 267                         if shift >= 64 {
 268                                 return ErrIntOverflowGenerated
 269                         }
 270                         if iNdEx >= l {
 271                                 return io.ErrUnexpectedEOF
 272                         }
 273                         b := dAtA[iNdEx]
 274                         iNdEx++
 275                         wire |= (uint64(b) & 0x7F) << shift
 276                         if b < 0x80 {
 277                                 break
 278                         }
 279                 }
 280                 fieldNum := int32(wire >> 3)
 281                 wireType := int(wire & 0x7)
 282                 if wireType == 4 {
 283                         return fmt.Errorf("proto: RawExtension: wiretype end group for non-group")
 284                 }
 285                 if fieldNum <= 0 {
 286                         return fmt.Errorf("proto: RawExtension: illegal tag %d (wire type %d)", fieldNum, wire)
 287                 }
 288                 switch fieldNum {
 289                 case 1:
 290                         if wireType != 2 {
 291                                 return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
 292                         }
 293                         var byteLen int
 294                         for shift := uint(0); ; shift += 7 {
 295                                 if shift >= 64 {
 296                                         return ErrIntOverflowGenerated
 297                                 }
 298                                 if iNdEx >= l {
 299                                         return io.ErrUnexpectedEOF
 300                                 }
 301                                 b := dAtA[iNdEx]
 302                                 iNdEx++
 303                                 byteLen |= (int(b) & 0x7F) << shift
 304                                 if b < 0x80 {
 305                                         break
 306                                 }
 307                         }
 308                         if byteLen < 0 {
 309                                 return ErrInvalidLengthGenerated
 310                         }
 311                         postIndex := iNdEx + byteLen
 312                         if postIndex > l {
 313                                 return io.ErrUnexpectedEOF
 314                         }
 315                         m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...)
 316                         if m.Raw == nil {
 317                                 m.Raw = []byte{}
 318                         }
 319                         iNdEx = postIndex
 320                 default:
 321                         iNdEx = preIndex
 322                         skippy, err := skipGenerated(dAtA[iNdEx:])
 323                         if err != nil {
 324                                 return err
 325                         }
 326                         if skippy < 0 {
 327                                 return ErrInvalidLengthGenerated
 328                         }
 329                         if (iNdEx + skippy) > l {
 330                                 return io.ErrUnexpectedEOF
 331                         }
 332                         iNdEx += skippy
 333                 }
 334         }
 335
 336         if iNdEx > l {
 337                 return io.ErrUnexpectedEOF
 338         }
 339         return nil
 340 }
 341 func (m *TypeMeta) Unmarshal(dAtA []byte) error {
 342         l := len(dAtA)
 343         iNdEx := 0
 344         for iNdEx < l {
 345                 preIndex := iNdEx
 346                 var wire uint64
 347                 for shift := uint(0); ; shift += 7 {
 348                         if shift >= 64 {
 349                                 return ErrIntOverflowGenerated
 350                         }
 351                         if iNdEx >= l {
 352                                 return io.ErrUnexpectedEOF
 353                         }
 354                         b := dAtA[iNdEx]
 355                         iNdEx++
 356                         wire |= (uint64(b) & 0x7F) << shift
 357                         if b < 0x80 {
 358                                 break
 359                         }
 360                 }
 361                 fieldNum := int32(wire >> 3)
 362                 wireType := int(wire & 0x7)
 363                 if wireType == 4 {
 364                         return fmt.Errorf("proto: TypeMeta: wiretype end group for non-group")
 365                 }
 366                 if fieldNum <= 0 {
 367                         return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire)
 368                 }
 369                 switch fieldNum {
 370                 case 1:
 371                         if wireType != 2 {
 372                                 return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
 373                         }
 374                         var stringLen uint64
 375                         for shift := uint(0); ; shift += 7 {
 376                                 if shift >= 64 {
 377                                         return ErrIntOverflowGenerated
 378                                 }
 379                                 if iNdEx >= l {
 380                                         return io.ErrUnexpectedEOF
 381                                 }
 382                                 b := dAtA[iNdEx]
 383                                 iNdEx++
 384                                 stringLen |= (uint64(b) & 0x7F) << shift
 385                                 if b < 0x80 {
 386                                         break
 387                                 }
 388                         }
 389                         intStringLen := int(stringLen)
 390                         if intStringLen < 0 {
 391                                 return ErrInvalidLengthGenerated
 392                         }
 393                         postIndex := iNdEx + intStringLen
 394                         if postIndex > l {
 395                                 return io.ErrUnexpectedEOF
 396                         }
 397                         m.APIVersion = string(dAtA[iNdEx:postIndex])
 398                         iNdEx = postIndex
 399                 case 2:
 400                         if wireType != 2 {
 401                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
 402                         }
 403                         var stringLen uint64
 404                         for shift := uint(0); ; shift += 7 {
 405                                 if shift >= 64 {
 406                                         return ErrIntOverflowGenerated
 407                                 }
 408                                 if iNdEx >= l {
 409                                         return io.ErrUnexpectedEOF
 410                                 }
 411                                 b := dAtA[iNdEx]
 412                                 iNdEx++
 413                                 stringLen |= (uint64(b) & 0x7F) << shift
 414                                 if b < 0x80 {
 415                                         break
 416                                 }
 417                         }
 418                         intStringLen := int(stringLen)
 419                         if intStringLen < 0 {
 420                                 return ErrInvalidLengthGenerated
 421                         }
 422                         postIndex := iNdEx + intStringLen
 423                         if postIndex > l {
 424                                 return io.ErrUnexpectedEOF
 425                         }
 426                         m.Kind = string(dAtA[iNdEx:postIndex])
 427                         iNdEx = postIndex
 428                 default:
 429                         iNdEx = preIndex
 430                         skippy, err := skipGenerated(dAtA[iNdEx:])
 431                         if err != nil {
 432                                 return err
 433                         }
 434                         if skippy < 0 {
 435                                 return ErrInvalidLengthGenerated
 436                         }
 437                         if (iNdEx + skippy) > l {
 438                                 return io.ErrUnexpectedEOF
 439                         }
 440                         iNdEx += skippy
 441                 }
 442         }
 443
 444         if iNdEx > l {
 445                 return io.ErrUnexpectedEOF
 446         }
 447         return nil
 448 }
 449 func (m *Unknown) Unmarshal(dAtA []byte) error {
 450         l := len(dAtA)
 451         iNdEx := 0
 452         for iNdEx < l {
 453                 preIndex := iNdEx
 454                 var wire uint64
 455                 for shift := uint(0); ; shift += 7 {
 456                         if shift >= 64 {
 457                                 return ErrIntOverflowGenerated
 458                         }
 459                         if iNdEx >= l {
 460                                 return io.ErrUnexpectedEOF
 461                         }
 462                         b := dAtA[iNdEx]
 463                         iNdEx++
 464                         wire |= (uint64(b) & 0x7F) << shift
 465                         if b < 0x80 {
 466                                 break
 467                         }
 468                 }
 469                 fieldNum := int32(wire >> 3)
 470                 wireType := int(wire & 0x7)
 471                 if wireType == 4 {
 472                         return fmt.Errorf("proto: Unknown: wiretype end group for non-group")
 473                 }
 474                 if fieldNum <= 0 {
 475                         return fmt.Errorf("proto: Unknown: illegal tag %d (wire type %d)", fieldNum, wire)
 476                 }
 477                 switch fieldNum {
 478                 case 1:
 479                         if wireType != 2 {
 480                                 return fmt.Errorf("proto: wrong wireType = %d for field TypeMeta", wireType)
 481                         }
 482                         var msglen int
 483                         for shift := uint(0); ; shift += 7 {
 484                                 if shift >= 64 {
 485                                         return ErrIntOverflowGenerated
 486                                 }
 487                                 if iNdEx >= l {
 488                                         return io.ErrUnexpectedEOF
 489                                 }
 490                                 b := dAtA[iNdEx]
 491                                 iNdEx++
 492                                 msglen |= (int(b) & 0x7F) << shift
 493                                 if b < 0x80 {
 494                                         break
 495                                 }
 496                         }
 497                         if msglen < 0 {
 498                                 return ErrInvalidLengthGenerated
 499                         }
 500                         postIndex := iNdEx + msglen
 501                         if postIndex > l {
 502                                 return io.ErrUnexpectedEOF
 503                         }
 504                         if err := m.TypeMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 505                                 return err
 506                         }
 507                         iNdEx = postIndex
 508                 case 2:
 509                         if wireType != 2 {
 510                                 return fmt.Errorf("proto: wrong wireType = %d for field Raw", wireType)
 511                         }
 512                         var byteLen int
 513                         for shift := uint(0); ; shift += 7 {
 514                                 if shift >= 64 {
 515                                         return ErrIntOverflowGenerated
 516                                 }
 517                                 if iNdEx >= l {
 518                                         return io.ErrUnexpectedEOF
 519                                 }
 520                                 b := dAtA[iNdEx]
 521                                 iNdEx++
 522                                 byteLen |= (int(b) & 0x7F) << shift
 523                                 if b < 0x80 {
 524                                         break
 525                                 }
 526                         }
 527                         if byteLen < 0 {
 528                                 return ErrInvalidLengthGenerated
 529                         }
 530                         postIndex := iNdEx + byteLen
 531                         if postIndex > l {
 532                                 return io.ErrUnexpectedEOF
 533                         }
 534                         m.Raw = append(m.Raw[:0], dAtA[iNdEx:postIndex]...)
 535                         if m.Raw == nil {
 536                                 m.Raw = []byte{}
 537                         }
 538                         iNdEx = postIndex
 539                 case 3:
 540                         if wireType != 2 {
 541                                 return fmt.Errorf("proto: wrong wireType = %d for field ContentEncoding", wireType)
 542                         }
 543                         var stringLen uint64
 544                         for shift := uint(0); ; shift += 7 {
 545                                 if shift >= 64 {
 546                                         return ErrIntOverflowGenerated
 547                                 }
 548                                 if iNdEx >= l {
 549                                         return io.ErrUnexpectedEOF
 550                                 }
 551                                 b := dAtA[iNdEx]
 552                                 iNdEx++
 553                                 stringLen |= (uint64(b) & 0x7F) << shift
 554                                 if b < 0x80 {
 555                                         break
 556                                 }
 557                         }
 558                         intStringLen := int(stringLen)
 559                         if intStringLen < 0 {
 560                                 return ErrInvalidLengthGenerated
 561                         }
 562                         postIndex := iNdEx + intStringLen
 563                         if postIndex > l {
 564                                 return io.ErrUnexpectedEOF
 565                         }
 566                         m.ContentEncoding = string(dAtA[iNdEx:postIndex])
 567                         iNdEx = postIndex
 568                 case 4:
 569                         if wireType != 2 {
 570                                 return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType)
 571                         }
 572                         var stringLen uint64
 573                         for shift := uint(0); ; shift += 7 {
 574                                 if shift >= 64 {
 575                                         return ErrIntOverflowGenerated
 576                                 }
 577                                 if iNdEx >= l {
 578                                         return io.ErrUnexpectedEOF
 579                                 }
 580                                 b := dAtA[iNdEx]
 581                                 iNdEx++
 582                                 stringLen |= (uint64(b) & 0x7F) << shift
 583                                 if b < 0x80 {
 584                                         break
 585                                 }
 586                         }
 587                         intStringLen := int(stringLen)
 588                         if intStringLen < 0 {
 589                                 return ErrInvalidLengthGenerated
 590                         }
 591                         postIndex := iNdEx + intStringLen
 592                         if postIndex > l {
 593                                 return io.ErrUnexpectedEOF
 594                         }
 595                         m.ContentType = string(dAtA[iNdEx:postIndex])
 596                         iNdEx = postIndex
 597                 default:
 598                         iNdEx = preIndex
 599                         skippy, err := skipGenerated(dAtA[iNdEx:])
 600                         if err != nil {
 601                                 return err
 602                         }
 603                         if skippy < 0 {
 604                                 return ErrInvalidLengthGenerated
 605                         }
 606                         if (iNdEx + skippy) > l {
 607                                 return io.ErrUnexpectedEOF
 608                         }
 609                         iNdEx += skippy
 610                 }
 611         }
 612
 613         if iNdEx > l {
 614                 return io.ErrUnexpectedEOF
 615         }
 616         return nil
 617 }
 618 func skipGenerated(dAtA []byte) (n int, err error) {
 619         l := len(dAtA)
 620         iNdEx := 0
 621         for iNdEx < l {
 622                 var wire uint64
 623                 for shift := uint(0); ; shift += 7 {
 624                         if shift >= 64 {
 625                                 return 0, ErrIntOverflowGenerated
 626                         }
 627                         if iNdEx >= l {
 628                                 return 0, io.ErrUnexpectedEOF
 629                         }
 630                         b := dAtA[iNdEx]
 631                         iNdEx++
 632                         wire |= (uint64(b) & 0x7F) << shift
 633                         if b < 0x80 {
 634                                 break
 635                         }
 636                 }
 637                 wireType := int(wire & 0x7)
 638                 switch wireType {
 639                 case 0:
 640                         for shift := uint(0); ; shift += 7 {
 641                                 if shift >= 64 {
 642                                         return 0, ErrIntOverflowGenerated
 643                                 }
 644                                 if iNdEx >= l {
 645                                         return 0, io.ErrUnexpectedEOF
 646                                 }
 647                                 iNdEx++
 648                                 if dAtA[iNdEx-1] < 0x80 {
 649                                         break
 650                                 }
 651                         }
 652                         return iNdEx, nil
 653                 case 1:
 654                         iNdEx += 8
 655                         return iNdEx, nil
 656                 case 2:
 657                         var length int
 658                         for shift := uint(0); ; shift += 7 {
 659                                 if shift >= 64 {
 660                                         return 0, ErrIntOverflowGenerated
 661                                 }
 662                                 if iNdEx >= l {
 663                                         return 0, io.ErrUnexpectedEOF
 664                                 }
 665                                 b := dAtA[iNdEx]
 666                                 iNdEx++
 667                                 length |= (int(b) & 0x7F) << shift
 668                                 if b < 0x80 {
 669                                         break
 670                                 }
 671                         }
 672                         iNdEx += length
 673                         if length < 0 {
 674                                 return 0, ErrInvalidLengthGenerated
 675                         }
 676                         return iNdEx, nil
 677                 case 3:
 678                         for {
 679                                 var innerWire uint64
 680                                 var start int = iNdEx
 681                                 for shift := uint(0); ; shift += 7 {
 682                                         if shift >= 64 {
 683                                                 return 0, ErrIntOverflowGenerated
 684                                         }
 685                                         if iNdEx >= l {
 686                                                 return 0, io.ErrUnexpectedEOF
 687                                         }
 688                                         b := dAtA[iNdEx]
 689                                         iNdEx++
 690                                         innerWire |= (uint64(b) & 0x7F) << shift
 691                                         if b < 0x80 {
 692                                                 break
 693                                         }
 694                                 }
 695                                 innerWireType := int(innerWire & 0x7)
 696                                 if innerWireType == 4 {
 697                                         break
 698                                 }
 699                                 next, err := skipGenerated(dAtA[start:])
 700                                 if err != nil {
 701                                         return 0, err
 702                                 }
 703                                 iNdEx = start + next
 704                         }
 705                         return iNdEx, nil
 706                 case 4:
 707                         return iNdEx, nil
 708                 case 5:
 709                         iNdEx += 4
 710                         return iNdEx, nil
 711                 default:
 712                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 713                 }
 714         }
 715         panic("unreachable")
 716 }
 717
 718 var (
 719         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
 720         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
 721 )
 722
 723 func init() {
 724         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/runtime/generated.proto", fileDescriptorGenerated)
 725 }
 726
 727 var fileDescriptorGenerated = []byte{
 728         // 378 bytes of a gzipped FileDescriptorProto
 729         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x8f, 0x4f, 0xab, 0x13, 0x31,
 730         0x14, 0xc5, 0x27, 0xaf, 0x85, 0x3e, 0xd3, 0xc2, 0x93, 0xb8, 0x70, 0x74, 0x91, 0x79, 0x74, 0xe5,
 731         0x5b, 0xbc, 0x04, 0x1e, 0x08, 0x6e, 0x3b, 0xa5, 0xa0, 0x88, 0x20, 0xc1, 0x3f, 0xe0, 0xca, 0x74,
 732         0x26, 0x4e, 0xc3, 0xd0, 0x9b, 0x21, 0xcd, 0x38, 0x76, 0xe7, 0x47, 0xf0, 0x63, 0x75, 0xd9, 0x65,
 733         0x57, 0xc5, 0x8e, 0x1f, 0xc2, 0xad, 0x34, 0x4d, 0x6b, 0xd5, 0x85, 0xbb, 0xe4, 0x9e, 0xf3, 0x3b,
 734         0xf7, 0x1e, 0xfc, 0xbc, 0x7c, 0xb6, 0x60, 0xda, 0xf0, 0xb2, 0x9e, 0x2a, 0x0b, 0xca, 0xa9, 0x05,
 735         0xff, 0xac, 0x20, 0x37, 0x96, 0x07, 0x41, 0x56, 0x7a, 0x2e, 0xb3, 0x99, 0x06, 0x65, 0x97, 0xbc,
 736         0x2a, 0x0b, 0x6e, 0x6b, 0x70, 0x7a, 0xae, 0x78, 0xa1, 0x40, 0x59, 0xe9, 0x54, 0xce, 0x2a, 0x6b,
 737         0x9c, 0x21, 0xc9, 0x01, 0x60, 0xe7, 0x00, 0xab, 0xca, 0x82, 0x05, 0xe0, 0xf1, 0x6d, 0xa1, 0xdd,
 738         0xac, 0x9e, 0xb2, 0xcc, 0xcc, 0x79, 0x61, 0x0a, 0xc3, 0x3d, 0x37, 0xad, 0x3f, 0xf9, 0x9f, 0xff,
 739         0xf8, 0xd7, 0x21, 0x6f, 0x78, 0x83, 0x07, 0x42, 0x36, 0x93, 0x2f, 0x4e, 0xc1, 0x42, 0x1b, 0x20,
 740         0x8f, 0x70, 0xc7, 0xca, 0x26, 0x46, 0xd7, 0xe8, 0xc9, 0x20, 0xed, 0xb5, 0xdb, 0xa4, 0x23, 0x64,
 741         0x23, 0xf6, 0xb3, 0xe1, 0x47, 0x7c, 0xf9, 0x66, 0x59, 0xa9, 0x57, 0xca, 0x49, 0x72, 0x87, 0xb1,
 742         0xac, 0xf4, 0x3b, 0x65, 0xf7, 0x90, 0x77, 0xdf, 0x4b, 0xc9, 0x6a, 0x9b, 0x44, 0xed, 0x36, 0xc1,
 743         0xa3, 0xd7, 0x2f, 0x82, 0x22, 0xce, 0x5c, 0xe4, 0x1a, 0x77, 0x4b, 0x0d, 0x79, 0x7c, 0xe1, 0xdd,
 744         0x83, 0xe0, 0xee, 0xbe, 0xd4, 0x90, 0x0b, 0xaf, 0x0c, 0x7f, 0x22, 0xdc, 0x7b, 0x0b, 0x25, 0x98,
 745         0x06, 0xc8, 0x7b, 0x7c, 0xe9, 0xc2, 0x36, 0x9f, 0xdf, 0xbf, 0xbb, 0x61, 0xff, 0xe9, 0xce, 0x8e,
 746         0xe7, 0xa5, 0xf7, 0x43, 0xf8, 0xe9, 0x60, 0x71, 0x0a, 0x3b, 0x36, 0xbc, 0xf8, 0xb7, 0x21, 0x19,
 747         0xe1, 0xab, 0xcc, 0x80, 0x53, 0xe0, 0x26, 0x90, 0x99, 0x5c, 0x43, 0x11, 0x77, 0xfc, 0xb1, 0x0f,
 748         0x43, 0xde, 0xd5, 0xf8, 0x4f, 0x59, 0xfc, 0xed, 0x27, 0x4f, 0x71, 0x3f, 0x8c, 0xf6, 0xab, 0xe3,
 749         0xae, 0xc7, 0x1f, 0x04, 0xbc, 0x3f, 0xfe, 0x2d, 0x89, 0x73, 0x5f, 0x7a, 0xbb, 0xda, 0xd1, 0x68,
 750         0xbd, 0xa3, 0xd1, 0x66, 0x47, 0xa3, 0xaf, 0x2d, 0x45, 0xab, 0x96, 0xa2, 0x75, 0x4b, 0xd1, 0xa6,
 751         0xa5, 0xe8, 0x7b, 0x4b, 0xd1, 0xb7, 0x1f, 0x34, 0xfa, 0xd0, 0x0b, 0x45, 0x7f, 0x05, 0x00, 0x00,
 752         0xff, 0xff, 0xe3, 0x33, 0x18, 0x0b, 0x50, 0x02, 0x00, 0x00,
 753 }