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