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