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