mirror of
				https://github.com/optim-enterprises-bv/kubernetes.git
				synced 2025-10-31 02:08:13 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			2785 lines
		
	
	
		
			69 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			2785 lines
		
	
	
		
			69 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
| /*
 | |
| Copyright 2017 The Kubernetes Authors.
 | |
| 
 | |
| Licensed under the Apache License, Version 2.0 (the "License");
 | |
| you may not use this file except in compliance with the License.
 | |
| You may obtain a copy of the License at
 | |
| 
 | |
|     http://www.apache.org/licenses/LICENSE-2.0
 | |
| 
 | |
| Unless required by applicable law or agreed to in writing, software
 | |
| distributed under the License is distributed on an "AS IS" BASIS,
 | |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 | |
| See the License for the specific language governing permissions and
 | |
| limitations under the License.
 | |
| */
 | |
| 
 | |
| // Code generated by protoc-gen-gogo.
 | |
| // source: k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto
 | |
| // DO NOT EDIT!
 | |
| 
 | |
| /*
 | |
| 	Package v2alpha1 is a generated protocol buffer package.
 | |
| 
 | |
| 	It is generated from these files:
 | |
| 		k8s.io/kubernetes/pkg/apis/batch/v2alpha1/generated.proto
 | |
| 
 | |
| 	It has these top-level messages:
 | |
| 		CronJob
 | |
| 		CronJobList
 | |
| 		CronJobSpec
 | |
| 		CronJobStatus
 | |
| 		Job
 | |
| 		JobCondition
 | |
| 		JobList
 | |
| 		JobSpec
 | |
| 		JobStatus
 | |
| 		JobTemplate
 | |
| 		JobTemplateSpec
 | |
| */
 | |
| package v2alpha1
 | |
| 
 | |
| import proto "github.com/gogo/protobuf/proto"
 | |
| import fmt "fmt"
 | |
| import math "math"
 | |
| 
 | |
| import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 | |
| 
 | |
| import k8s_io_kubernetes_pkg_api_v1 "k8s.io/kubernetes/pkg/api/v1"
 | |
| 
 | |
| import strings "strings"
 | |
| import reflect "reflect"
 | |
| 
 | |
| import io "io"
 | |
| 
 | |
| // Reference imports to suppress errors if they are not otherwise used.
 | |
| var _ = proto.Marshal
 | |
| var _ = fmt.Errorf
 | |
| var _ = math.Inf
 | |
| 
 | |
| // This is a compile-time assertion to ensure that this generated file
 | |
| // is compatible with the proto package it is being compiled against.
 | |
| const _ = proto.GoGoProtoPackageIsVersion1
 | |
| 
 | |
| func (m *CronJob) Reset()                    { *m = CronJob{} }
 | |
| func (*CronJob) ProtoMessage()               {}
 | |
| func (*CronJob) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} }
 | |
| 
 | |
| func (m *CronJobList) Reset()                    { *m = CronJobList{} }
 | |
| func (*CronJobList) ProtoMessage()               {}
 | |
| func (*CronJobList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
 | |
| 
 | |
| func (m *CronJobSpec) Reset()                    { *m = CronJobSpec{} }
 | |
| func (*CronJobSpec) ProtoMessage()               {}
 | |
| func (*CronJobSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
 | |
| 
 | |
| func (m *CronJobStatus) Reset()                    { *m = CronJobStatus{} }
 | |
| func (*CronJobStatus) ProtoMessage()               {}
 | |
| func (*CronJobStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
 | |
| 
 | |
| func (m *Job) Reset()                    { *m = Job{} }
 | |
| func (*Job) ProtoMessage()               {}
 | |
| func (*Job) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} }
 | |
| 
 | |
| func (m *JobCondition) Reset()                    { *m = JobCondition{} }
 | |
| func (*JobCondition) ProtoMessage()               {}
 | |
| func (*JobCondition) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} }
 | |
| 
 | |
| func (m *JobList) Reset()                    { *m = JobList{} }
 | |
| func (*JobList) ProtoMessage()               {}
 | |
| func (*JobList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} }
 | |
| 
 | |
| func (m *JobSpec) Reset()                    { *m = JobSpec{} }
 | |
| func (*JobSpec) ProtoMessage()               {}
 | |
| func (*JobSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} }
 | |
| 
 | |
| func (m *JobStatus) Reset()                    { *m = JobStatus{} }
 | |
| func (*JobStatus) ProtoMessage()               {}
 | |
| func (*JobStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
 | |
| 
 | |
| func (m *JobTemplate) Reset()                    { *m = JobTemplate{} }
 | |
| func (*JobTemplate) ProtoMessage()               {}
 | |
| func (*JobTemplate) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
 | |
| 
 | |
| func (m *JobTemplateSpec) Reset()                    { *m = JobTemplateSpec{} }
 | |
| func (*JobTemplateSpec) ProtoMessage()               {}
 | |
| func (*JobTemplateSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
 | |
| 
 | |
| func init() {
 | |
| 	proto.RegisterType((*CronJob)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.CronJob")
 | |
| 	proto.RegisterType((*CronJobList)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.CronJobList")
 | |
| 	proto.RegisterType((*CronJobSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.CronJobSpec")
 | |
| 	proto.RegisterType((*CronJobStatus)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.CronJobStatus")
 | |
| 	proto.RegisterType((*Job)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.Job")
 | |
| 	proto.RegisterType((*JobCondition)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobCondition")
 | |
| 	proto.RegisterType((*JobList)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobList")
 | |
| 	proto.RegisterType((*JobSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobSpec")
 | |
| 	proto.RegisterType((*JobStatus)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobStatus")
 | |
| 	proto.RegisterType((*JobTemplate)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobTemplate")
 | |
| 	proto.RegisterType((*JobTemplateSpec)(nil), "k8s.io.kubernetes.pkg.apis.batch.v2alpha1.JobTemplateSpec")
 | |
| }
 | |
| func (m *CronJob) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *CronJob) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
 | |
| 	n1, err := m.ObjectMeta.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n1
 | |
| 	data[i] = 0x12
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
 | |
| 	n2, err := m.Spec.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n2
 | |
| 	data[i] = 0x1a
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
 | |
| 	n3, err := m.Status.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n3
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *CronJobList) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *CronJobList) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
 | |
| 	n4, err := m.ListMeta.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n4
 | |
| 	if len(m.Items) > 0 {
 | |
| 		for _, msg := range m.Items {
 | |
| 			data[i] = 0x12
 | |
| 			i++
 | |
| 			i = encodeVarintGenerated(data, i, uint64(msg.Size()))
 | |
| 			n, err := msg.MarshalTo(data[i:])
 | |
| 			if err != nil {
 | |
| 				return 0, err
 | |
| 			}
 | |
| 			i += n
 | |
| 		}
 | |
| 	}
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *CronJobSpec) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *CronJobSpec) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(len(m.Schedule)))
 | |
| 	i += copy(data[i:], m.Schedule)
 | |
| 	if m.StartingDeadlineSeconds != nil {
 | |
| 		data[i] = 0x10
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(*m.StartingDeadlineSeconds))
 | |
| 	}
 | |
| 	data[i] = 0x1a
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(len(m.ConcurrencyPolicy)))
 | |
| 	i += copy(data[i:], m.ConcurrencyPolicy)
 | |
| 	if m.Suspend != nil {
 | |
| 		data[i] = 0x20
 | |
| 		i++
 | |
| 		if *m.Suspend {
 | |
| 			data[i] = 1
 | |
| 		} else {
 | |
| 			data[i] = 0
 | |
| 		}
 | |
| 		i++
 | |
| 	}
 | |
| 	data[i] = 0x2a
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.JobTemplate.Size()))
 | |
| 	n5, err := m.JobTemplate.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n5
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *CronJobStatus) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *CronJobStatus) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	if len(m.Active) > 0 {
 | |
| 		for _, msg := range m.Active {
 | |
| 			data[i] = 0xa
 | |
| 			i++
 | |
| 			i = encodeVarintGenerated(data, i, uint64(msg.Size()))
 | |
| 			n, err := msg.MarshalTo(data[i:])
 | |
| 			if err != nil {
 | |
| 				return 0, err
 | |
| 			}
 | |
| 			i += n
 | |
| 		}
 | |
| 	}
 | |
| 	if m.LastScheduleTime != nil {
 | |
| 		data[i] = 0x22
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(m.LastScheduleTime.Size()))
 | |
| 		n6, err := m.LastScheduleTime.MarshalTo(data[i:])
 | |
| 		if err != nil {
 | |
| 			return 0, err
 | |
| 		}
 | |
| 		i += n6
 | |
| 	}
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *Job) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *Job) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
 | |
| 	n7, err := m.ObjectMeta.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n7
 | |
| 	data[i] = 0x12
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
 | |
| 	n8, err := m.Spec.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n8
 | |
| 	data[i] = 0x1a
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Status.Size()))
 | |
| 	n9, err := m.Status.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n9
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *JobCondition) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *JobCondition) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(len(m.Type)))
 | |
| 	i += copy(data[i:], m.Type)
 | |
| 	data[i] = 0x12
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(len(m.Status)))
 | |
| 	i += copy(data[i:], m.Status)
 | |
| 	data[i] = 0x1a
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.LastProbeTime.Size()))
 | |
| 	n10, err := m.LastProbeTime.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n10
 | |
| 	data[i] = 0x22
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.LastTransitionTime.Size()))
 | |
| 	n11, err := m.LastTransitionTime.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n11
 | |
| 	data[i] = 0x2a
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(len(m.Reason)))
 | |
| 	i += copy(data[i:], m.Reason)
 | |
| 	data[i] = 0x32
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(len(m.Message)))
 | |
| 	i += copy(data[i:], m.Message)
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *JobList) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *JobList) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.ListMeta.Size()))
 | |
| 	n12, err := m.ListMeta.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n12
 | |
| 	if len(m.Items) > 0 {
 | |
| 		for _, msg := range m.Items {
 | |
| 			data[i] = 0x12
 | |
| 			i++
 | |
| 			i = encodeVarintGenerated(data, i, uint64(msg.Size()))
 | |
| 			n, err := msg.MarshalTo(data[i:])
 | |
| 			if err != nil {
 | |
| 				return 0, err
 | |
| 			}
 | |
| 			i += n
 | |
| 		}
 | |
| 	}
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *JobSpec) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *JobSpec) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	if m.Parallelism != nil {
 | |
| 		data[i] = 0x8
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(*m.Parallelism))
 | |
| 	}
 | |
| 	if m.Completions != nil {
 | |
| 		data[i] = 0x10
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(*m.Completions))
 | |
| 	}
 | |
| 	if m.ActiveDeadlineSeconds != nil {
 | |
| 		data[i] = 0x18
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(*m.ActiveDeadlineSeconds))
 | |
| 	}
 | |
| 	if m.Selector != nil {
 | |
| 		data[i] = 0x22
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(m.Selector.Size()))
 | |
| 		n13, err := m.Selector.MarshalTo(data[i:])
 | |
| 		if err != nil {
 | |
| 			return 0, err
 | |
| 		}
 | |
| 		i += n13
 | |
| 	}
 | |
| 	if m.ManualSelector != nil {
 | |
| 		data[i] = 0x28
 | |
| 		i++
 | |
| 		if *m.ManualSelector {
 | |
| 			data[i] = 1
 | |
| 		} else {
 | |
| 			data[i] = 0
 | |
| 		}
 | |
| 		i++
 | |
| 	}
 | |
| 	data[i] = 0x32
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
 | |
| 	n14, err := m.Template.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n14
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *JobStatus) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *JobStatus) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	if len(m.Conditions) > 0 {
 | |
| 		for _, msg := range m.Conditions {
 | |
| 			data[i] = 0xa
 | |
| 			i++
 | |
| 			i = encodeVarintGenerated(data, i, uint64(msg.Size()))
 | |
| 			n, err := msg.MarshalTo(data[i:])
 | |
| 			if err != nil {
 | |
| 				return 0, err
 | |
| 			}
 | |
| 			i += n
 | |
| 		}
 | |
| 	}
 | |
| 	if m.StartTime != nil {
 | |
| 		data[i] = 0x12
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(m.StartTime.Size()))
 | |
| 		n15, err := m.StartTime.MarshalTo(data[i:])
 | |
| 		if err != nil {
 | |
| 			return 0, err
 | |
| 		}
 | |
| 		i += n15
 | |
| 	}
 | |
| 	if m.CompletionTime != nil {
 | |
| 		data[i] = 0x1a
 | |
| 		i++
 | |
| 		i = encodeVarintGenerated(data, i, uint64(m.CompletionTime.Size()))
 | |
| 		n16, err := m.CompletionTime.MarshalTo(data[i:])
 | |
| 		if err != nil {
 | |
| 			return 0, err
 | |
| 		}
 | |
| 		i += n16
 | |
| 	}
 | |
| 	data[i] = 0x20
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Active))
 | |
| 	data[i] = 0x28
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Succeeded))
 | |
| 	data[i] = 0x30
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Failed))
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *JobTemplate) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *JobTemplate) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
 | |
| 	n17, err := m.ObjectMeta.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n17
 | |
| 	data[i] = 0x12
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Template.Size()))
 | |
| 	n18, err := m.Template.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n18
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func (m *JobTemplateSpec) Marshal() (data []byte, err error) {
 | |
| 	size := m.Size()
 | |
| 	data = make([]byte, size)
 | |
| 	n, err := m.MarshalTo(data)
 | |
| 	if err != nil {
 | |
| 		return nil, err
 | |
| 	}
 | |
| 	return data[:n], nil
 | |
| }
 | |
| 
 | |
| func (m *JobTemplateSpec) MarshalTo(data []byte) (int, error) {
 | |
| 	var i int
 | |
| 	_ = i
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	data[i] = 0xa
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.ObjectMeta.Size()))
 | |
| 	n19, err := m.ObjectMeta.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n19
 | |
| 	data[i] = 0x12
 | |
| 	i++
 | |
| 	i = encodeVarintGenerated(data, i, uint64(m.Spec.Size()))
 | |
| 	n20, err := m.Spec.MarshalTo(data[i:])
 | |
| 	if err != nil {
 | |
| 		return 0, err
 | |
| 	}
 | |
| 	i += n20
 | |
| 	return i, nil
 | |
| }
 | |
| 
 | |
| func encodeFixed64Generated(data []byte, offset int, v uint64) int {
 | |
| 	data[offset] = uint8(v)
 | |
| 	data[offset+1] = uint8(v >> 8)
 | |
| 	data[offset+2] = uint8(v >> 16)
 | |
| 	data[offset+3] = uint8(v >> 24)
 | |
| 	data[offset+4] = uint8(v >> 32)
 | |
| 	data[offset+5] = uint8(v >> 40)
 | |
| 	data[offset+6] = uint8(v >> 48)
 | |
| 	data[offset+7] = uint8(v >> 56)
 | |
| 	return offset + 8
 | |
| }
 | |
| func encodeFixed32Generated(data []byte, offset int, v uint32) int {
 | |
| 	data[offset] = uint8(v)
 | |
| 	data[offset+1] = uint8(v >> 8)
 | |
| 	data[offset+2] = uint8(v >> 16)
 | |
| 	data[offset+3] = uint8(v >> 24)
 | |
| 	return offset + 4
 | |
| }
 | |
| func encodeVarintGenerated(data []byte, offset int, v uint64) int {
 | |
| 	for v >= 1<<7 {
 | |
| 		data[offset] = uint8(v&0x7f | 0x80)
 | |
| 		v >>= 7
 | |
| 		offset++
 | |
| 	}
 | |
| 	data[offset] = uint8(v)
 | |
| 	return offset + 1
 | |
| }
 | |
| func (m *CronJob) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = m.ObjectMeta.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.Spec.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.Status.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *CronJobList) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = m.ListMeta.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	if len(m.Items) > 0 {
 | |
| 		for _, e := range m.Items {
 | |
| 			l = e.Size()
 | |
| 			n += 1 + l + sovGenerated(uint64(l))
 | |
| 		}
 | |
| 	}
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *CronJobSpec) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = len(m.Schedule)
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	if m.StartingDeadlineSeconds != nil {
 | |
| 		n += 1 + sovGenerated(uint64(*m.StartingDeadlineSeconds))
 | |
| 	}
 | |
| 	l = len(m.ConcurrencyPolicy)
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	if m.Suspend != nil {
 | |
| 		n += 2
 | |
| 	}
 | |
| 	l = m.JobTemplate.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *CronJobStatus) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	if len(m.Active) > 0 {
 | |
| 		for _, e := range m.Active {
 | |
| 			l = e.Size()
 | |
| 			n += 1 + l + sovGenerated(uint64(l))
 | |
| 		}
 | |
| 	}
 | |
| 	if m.LastScheduleTime != nil {
 | |
| 		l = m.LastScheduleTime.Size()
 | |
| 		n += 1 + l + sovGenerated(uint64(l))
 | |
| 	}
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *Job) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = m.ObjectMeta.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.Spec.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.Status.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *JobCondition) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = len(m.Type)
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = len(m.Status)
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.LastProbeTime.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.LastTransitionTime.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = len(m.Reason)
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = len(m.Message)
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *JobList) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = m.ListMeta.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	if len(m.Items) > 0 {
 | |
| 		for _, e := range m.Items {
 | |
| 			l = e.Size()
 | |
| 			n += 1 + l + sovGenerated(uint64(l))
 | |
| 		}
 | |
| 	}
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *JobSpec) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	if m.Parallelism != nil {
 | |
| 		n += 1 + sovGenerated(uint64(*m.Parallelism))
 | |
| 	}
 | |
| 	if m.Completions != nil {
 | |
| 		n += 1 + sovGenerated(uint64(*m.Completions))
 | |
| 	}
 | |
| 	if m.ActiveDeadlineSeconds != nil {
 | |
| 		n += 1 + sovGenerated(uint64(*m.ActiveDeadlineSeconds))
 | |
| 	}
 | |
| 	if m.Selector != nil {
 | |
| 		l = m.Selector.Size()
 | |
| 		n += 1 + l + sovGenerated(uint64(l))
 | |
| 	}
 | |
| 	if m.ManualSelector != nil {
 | |
| 		n += 2
 | |
| 	}
 | |
| 	l = m.Template.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *JobStatus) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	if len(m.Conditions) > 0 {
 | |
| 		for _, e := range m.Conditions {
 | |
| 			l = e.Size()
 | |
| 			n += 1 + l + sovGenerated(uint64(l))
 | |
| 		}
 | |
| 	}
 | |
| 	if m.StartTime != nil {
 | |
| 		l = m.StartTime.Size()
 | |
| 		n += 1 + l + sovGenerated(uint64(l))
 | |
| 	}
 | |
| 	if m.CompletionTime != nil {
 | |
| 		l = m.CompletionTime.Size()
 | |
| 		n += 1 + l + sovGenerated(uint64(l))
 | |
| 	}
 | |
| 	n += 1 + sovGenerated(uint64(m.Active))
 | |
| 	n += 1 + sovGenerated(uint64(m.Succeeded))
 | |
| 	n += 1 + sovGenerated(uint64(m.Failed))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *JobTemplate) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = m.ObjectMeta.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.Template.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func (m *JobTemplateSpec) Size() (n int) {
 | |
| 	var l int
 | |
| 	_ = l
 | |
| 	l = m.ObjectMeta.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	l = m.Spec.Size()
 | |
| 	n += 1 + l + sovGenerated(uint64(l))
 | |
| 	return n
 | |
| }
 | |
| 
 | |
| func sovGenerated(x uint64) (n int) {
 | |
| 	for {
 | |
| 		n++
 | |
| 		x >>= 7
 | |
| 		if x == 0 {
 | |
| 			break
 | |
| 		}
 | |
| 	}
 | |
| 	return n
 | |
| }
 | |
| func sozGenerated(x uint64) (n int) {
 | |
| 	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 | |
| }
 | |
| func (this *CronJob) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&CronJob{`,
 | |
| 		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 | |
| 		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "CronJobSpec", "CronJobSpec", 1), `&`, ``, 1) + `,`,
 | |
| 		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "CronJobStatus", "CronJobStatus", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *CronJobList) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&CronJobList{`,
 | |
| 		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 | |
| 		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "CronJob", "CronJob", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *CronJobSpec) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&CronJobSpec{`,
 | |
| 		`Schedule:` + fmt.Sprintf("%v", this.Schedule) + `,`,
 | |
| 		`StartingDeadlineSeconds:` + valueToStringGenerated(this.StartingDeadlineSeconds) + `,`,
 | |
| 		`ConcurrencyPolicy:` + fmt.Sprintf("%v", this.ConcurrencyPolicy) + `,`,
 | |
| 		`Suspend:` + valueToStringGenerated(this.Suspend) + `,`,
 | |
| 		`JobTemplate:` + strings.Replace(strings.Replace(this.JobTemplate.String(), "JobTemplateSpec", "JobTemplateSpec", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *CronJobStatus) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&CronJobStatus{`,
 | |
| 		`Active:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Active), "ObjectReference", "k8s_io_kubernetes_pkg_api_v1.ObjectReference", 1), `&`, ``, 1) + `,`,
 | |
| 		`LastScheduleTime:` + strings.Replace(fmt.Sprintf("%v", this.LastScheduleTime), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *Job) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&Job{`,
 | |
| 		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 | |
| 		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "JobSpec", "JobSpec", 1), `&`, ``, 1) + `,`,
 | |
| 		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "JobStatus", "JobStatus", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *JobCondition) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&JobCondition{`,
 | |
| 		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
 | |
| 		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
 | |
| 		`LastProbeTime:` + strings.Replace(strings.Replace(this.LastProbeTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
 | |
| 		`LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
 | |
| 		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
 | |
| 		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *JobList) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&JobList{`,
 | |
| 		`ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
 | |
| 		`Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "Job", "Job", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *JobSpec) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&JobSpec{`,
 | |
| 		`Parallelism:` + valueToStringGenerated(this.Parallelism) + `,`,
 | |
| 		`Completions:` + valueToStringGenerated(this.Completions) + `,`,
 | |
| 		`ActiveDeadlineSeconds:` + valueToStringGenerated(this.ActiveDeadlineSeconds) + `,`,
 | |
| 		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
 | |
| 		`ManualSelector:` + valueToStringGenerated(this.ManualSelector) + `,`,
 | |
| 		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "PodTemplateSpec", "k8s_io_kubernetes_pkg_api_v1.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *JobStatus) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&JobStatus{`,
 | |
| 		`Conditions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Conditions), "JobCondition", "JobCondition", 1), `&`, ``, 1) + `,`,
 | |
| 		`StartTime:` + strings.Replace(fmt.Sprintf("%v", this.StartTime), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1) + `,`,
 | |
| 		`CompletionTime:` + strings.Replace(fmt.Sprintf("%v", this.CompletionTime), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1) + `,`,
 | |
| 		`Active:` + fmt.Sprintf("%v", this.Active) + `,`,
 | |
| 		`Succeeded:` + fmt.Sprintf("%v", this.Succeeded) + `,`,
 | |
| 		`Failed:` + fmt.Sprintf("%v", this.Failed) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *JobTemplate) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&JobTemplate{`,
 | |
| 		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 | |
| 		`Template:` + strings.Replace(strings.Replace(this.Template.String(), "JobTemplateSpec", "JobTemplateSpec", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func (this *JobTemplateSpec) String() string {
 | |
| 	if this == nil {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	s := strings.Join([]string{`&JobTemplateSpec{`,
 | |
| 		`ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
 | |
| 		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "JobSpec", "JobSpec", 1), `&`, ``, 1) + `,`,
 | |
| 		`}`,
 | |
| 	}, "")
 | |
| 	return s
 | |
| }
 | |
| func valueToStringGenerated(v interface{}) string {
 | |
| 	rv := reflect.ValueOf(v)
 | |
| 	if rv.IsNil() {
 | |
| 		return "nil"
 | |
| 	}
 | |
| 	pv := reflect.Indirect(rv).Interface()
 | |
| 	return fmt.Sprintf("*%v", pv)
 | |
| }
 | |
| func (m *CronJob) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: CronJob: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: CronJob: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 3:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *CronJobList) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: CronJobList: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: CronJobList: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Items = append(m.Items, CronJob{})
 | |
| 			if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *CronJobSpec) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: CronJobSpec: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: CronJobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Schedule", wireType)
 | |
| 			}
 | |
| 			var stringLen uint64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				stringLen |= (uint64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			intStringLen := int(stringLen)
 | |
| 			if intStringLen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + intStringLen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Schedule = string(data[iNdEx:postIndex])
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field StartingDeadlineSeconds", wireType)
 | |
| 			}
 | |
| 			var v int64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				v |= (int64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			m.StartingDeadlineSeconds = &v
 | |
| 		case 3:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ConcurrencyPolicy", wireType)
 | |
| 			}
 | |
| 			var stringLen uint64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				stringLen |= (uint64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			intStringLen := int(stringLen)
 | |
| 			if intStringLen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + intStringLen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.ConcurrencyPolicy = ConcurrencyPolicy(data[iNdEx:postIndex])
 | |
| 			iNdEx = postIndex
 | |
| 		case 4:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Suspend", wireType)
 | |
| 			}
 | |
| 			var v int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				v |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			b := bool(v != 0)
 | |
| 			m.Suspend = &b
 | |
| 		case 5:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field JobTemplate", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.JobTemplate.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *CronJobStatus) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: CronJobStatus: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: CronJobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Active = append(m.Active, k8s_io_kubernetes_pkg_api_v1.ObjectReference{})
 | |
| 			if err := m.Active[len(m.Active)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 4:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field LastScheduleTime", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if m.LastScheduleTime == nil {
 | |
| 				m.LastScheduleTime = &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
 | |
| 			}
 | |
| 			if err := m.LastScheduleTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *Job) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: Job: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: Job: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 3:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *JobCondition) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: JobCondition: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: JobCondition: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
 | |
| 			}
 | |
| 			var stringLen uint64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				stringLen |= (uint64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			intStringLen := int(stringLen)
 | |
| 			if intStringLen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + intStringLen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Type = JobConditionType(data[iNdEx:postIndex])
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 | |
| 			}
 | |
| 			var stringLen uint64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				stringLen |= (uint64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			intStringLen := int(stringLen)
 | |
| 			if intStringLen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + intStringLen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Status = k8s_io_kubernetes_pkg_api_v1.ConditionStatus(data[iNdEx:postIndex])
 | |
| 			iNdEx = postIndex
 | |
| 		case 3:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field LastProbeTime", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.LastProbeTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 4:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.LastTransitionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 5:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
 | |
| 			}
 | |
| 			var stringLen uint64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				stringLen |= (uint64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			intStringLen := int(stringLen)
 | |
| 			if intStringLen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + intStringLen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Reason = string(data[iNdEx:postIndex])
 | |
| 			iNdEx = postIndex
 | |
| 		case 6:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
 | |
| 			}
 | |
| 			var stringLen uint64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				stringLen |= (uint64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			intStringLen := int(stringLen)
 | |
| 			if intStringLen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + intStringLen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Message = string(data[iNdEx:postIndex])
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *JobList) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: JobList: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: JobList: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.ListMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Items = append(m.Items, Job{})
 | |
| 			if err := m.Items[len(m.Items)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *JobSpec) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: JobSpec: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: JobSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Parallelism", wireType)
 | |
| 			}
 | |
| 			var v int32
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				v |= (int32(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			m.Parallelism = &v
 | |
| 		case 2:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Completions", wireType)
 | |
| 			}
 | |
| 			var v int32
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				v |= (int32(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			m.Completions = &v
 | |
| 		case 3:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ActiveDeadlineSeconds", wireType)
 | |
| 			}
 | |
| 			var v int64
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				v |= (int64(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			m.ActiveDeadlineSeconds = &v
 | |
| 		case 4:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if m.Selector == nil {
 | |
| 				m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
 | |
| 			}
 | |
| 			if err := m.Selector.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 5:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ManualSelector", wireType)
 | |
| 			}
 | |
| 			var v int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				v |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			b := bool(v != 0)
 | |
| 			m.ManualSelector = &b
 | |
| 		case 6:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *JobStatus) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: JobStatus: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: JobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			m.Conditions = append(m.Conditions, JobCondition{})
 | |
| 			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if m.StartTime == nil {
 | |
| 				m.StartTime = &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
 | |
| 			}
 | |
| 			if err := m.StartTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 3:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field CompletionTime", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if m.CompletionTime == nil {
 | |
| 				m.CompletionTime = &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
 | |
| 			}
 | |
| 			if err := m.CompletionTime.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 4:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Active", wireType)
 | |
| 			}
 | |
| 			m.Active = 0
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				m.Active |= (int32(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 		case 5:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
 | |
| 			}
 | |
| 			m.Succeeded = 0
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				m.Succeeded |= (int32(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 		case 6:
 | |
| 			if wireType != 0 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
 | |
| 			}
 | |
| 			m.Failed = 0
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				m.Failed |= (int32(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *JobTemplate) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: JobTemplate: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: JobTemplate: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Template.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func (m *JobTemplateSpec) Unmarshal(data []byte) error {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		preIndex := iNdEx
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		fieldNum := int32(wire >> 3)
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		if wireType == 4 {
 | |
| 			return fmt.Errorf("proto: JobTemplateSpec: wiretype end group for non-group")
 | |
| 		}
 | |
| 		if fieldNum <= 0 {
 | |
| 			return fmt.Errorf("proto: JobTemplateSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 | |
| 		}
 | |
| 		switch fieldNum {
 | |
| 		case 1:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.ObjectMeta.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		case 2:
 | |
| 			if wireType != 2 {
 | |
| 				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 | |
| 			}
 | |
| 			var msglen int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				msglen |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			if msglen < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			postIndex := iNdEx + msglen
 | |
| 			if postIndex > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			if err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			iNdEx = postIndex
 | |
| 		default:
 | |
| 			iNdEx = preIndex
 | |
| 			skippy, err := skipGenerated(data[iNdEx:])
 | |
| 			if err != nil {
 | |
| 				return err
 | |
| 			}
 | |
| 			if skippy < 0 {
 | |
| 				return ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			if (iNdEx + skippy) > l {
 | |
| 				return io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			iNdEx += skippy
 | |
| 		}
 | |
| 	}
 | |
| 
 | |
| 	if iNdEx > l {
 | |
| 		return io.ErrUnexpectedEOF
 | |
| 	}
 | |
| 	return nil
 | |
| }
 | |
| func skipGenerated(data []byte) (n int, err error) {
 | |
| 	l := len(data)
 | |
| 	iNdEx := 0
 | |
| 	for iNdEx < l {
 | |
| 		var wire uint64
 | |
| 		for shift := uint(0); ; shift += 7 {
 | |
| 			if shift >= 64 {
 | |
| 				return 0, ErrIntOverflowGenerated
 | |
| 			}
 | |
| 			if iNdEx >= l {
 | |
| 				return 0, io.ErrUnexpectedEOF
 | |
| 			}
 | |
| 			b := data[iNdEx]
 | |
| 			iNdEx++
 | |
| 			wire |= (uint64(b) & 0x7F) << shift
 | |
| 			if b < 0x80 {
 | |
| 				break
 | |
| 			}
 | |
| 		}
 | |
| 		wireType := int(wire & 0x7)
 | |
| 		switch wireType {
 | |
| 		case 0:
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return 0, ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return 0, io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				iNdEx++
 | |
| 				if data[iNdEx-1] < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			return iNdEx, nil
 | |
| 		case 1:
 | |
| 			iNdEx += 8
 | |
| 			return iNdEx, nil
 | |
| 		case 2:
 | |
| 			var length int
 | |
| 			for shift := uint(0); ; shift += 7 {
 | |
| 				if shift >= 64 {
 | |
| 					return 0, ErrIntOverflowGenerated
 | |
| 				}
 | |
| 				if iNdEx >= l {
 | |
| 					return 0, io.ErrUnexpectedEOF
 | |
| 				}
 | |
| 				b := data[iNdEx]
 | |
| 				iNdEx++
 | |
| 				length |= (int(b) & 0x7F) << shift
 | |
| 				if b < 0x80 {
 | |
| 					break
 | |
| 				}
 | |
| 			}
 | |
| 			iNdEx += length
 | |
| 			if length < 0 {
 | |
| 				return 0, ErrInvalidLengthGenerated
 | |
| 			}
 | |
| 			return iNdEx, nil
 | |
| 		case 3:
 | |
| 			for {
 | |
| 				var innerWire uint64
 | |
| 				var start int = iNdEx
 | |
| 				for shift := uint(0); ; shift += 7 {
 | |
| 					if shift >= 64 {
 | |
| 						return 0, ErrIntOverflowGenerated
 | |
| 					}
 | |
| 					if iNdEx >= l {
 | |
| 						return 0, io.ErrUnexpectedEOF
 | |
| 					}
 | |
| 					b := data[iNdEx]
 | |
| 					iNdEx++
 | |
| 					innerWire |= (uint64(b) & 0x7F) << shift
 | |
| 					if b < 0x80 {
 | |
| 						break
 | |
| 					}
 | |
| 				}
 | |
| 				innerWireType := int(innerWire & 0x7)
 | |
| 				if innerWireType == 4 {
 | |
| 					break
 | |
| 				}
 | |
| 				next, err := skipGenerated(data[start:])
 | |
| 				if err != nil {
 | |
| 					return 0, err
 | |
| 				}
 | |
| 				iNdEx = start + next
 | |
| 			}
 | |
| 			return iNdEx, nil
 | |
| 		case 4:
 | |
| 			return iNdEx, nil
 | |
| 		case 5:
 | |
| 			iNdEx += 4
 | |
| 			return iNdEx, nil
 | |
| 		default:
 | |
| 			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 | |
| 		}
 | |
| 	}
 | |
| 	panic("unreachable")
 | |
| }
 | |
| 
 | |
| var (
 | |
| 	ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
 | |
| 	ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
 | |
| )
 | |
| 
 | |
| var fileDescriptorGenerated = []byte{
 | |
| 	// 1162 bytes of a gzipped FileDescriptorProto
 | |
| 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x56, 0x4b, 0x6f, 0x23, 0x45,
 | |
| 	0x10, 0xce, 0xd8, 0x89, 0x1f, 0xed, 0xcd, 0xab, 0x21, 0x5a, 0x13, 0x24, 0x3b, 0xb2, 0x04, 0xca,
 | |
| 	0xae, 0x76, 0x67, 0x88, 0x37, 0x5a, 0x96, 0x3d, 0x20, 0xed, 0x04, 0x21, 0x11, 0x25, 0xda, 0xa8,
 | |
| 	0x9d, 0x65, 0x11, 0x04, 0x69, 0xdb, 0xe3, 0x8a, 0x3d, 0x9b, 0x79, 0x31, 0xdd, 0xb6, 0xc8, 0x8d,
 | |
| 	0x33, 0x27, 0xee, 0xfc, 0x00, 0xfe, 0x02, 0x42, 0x1c, 0x39, 0x84, 0x5b, 0x0e, 0x1c, 0xe0, 0x62,
 | |
| 	0x91, 0xe1, 0x5f, 0xe4, 0x84, 0xa6, 0xdd, 0xf3, 0xf0, 0x2b, 0x1b, 0x07, 0x29, 0x12, 0xb7, 0xe9,
 | |
| 	0xea, 0xfa, 0xbe, 0xae, 0xae, 0xfa, 0xba, 0x6a, 0xd0, 0x47, 0x27, 0x4f, 0x98, 0x6a, 0xba, 0xda,
 | |
| 	0x49, 0xb7, 0x09, 0xbe, 0x03, 0x1c, 0x98, 0xe6, 0x9d, 0xb4, 0x35, 0xea, 0x99, 0x4c, 0x6b, 0x52,
 | |
| 	0x6e, 0x74, 0xb4, 0x5e, 0x9d, 0x5a, 0x5e, 0x87, 0x6e, 0x69, 0x6d, 0x70, 0xc0, 0xa7, 0x1c, 0x5a,
 | |
| 	0xaa, 0xe7, 0xbb, 0xdc, 0xc5, 0xf7, 0x06, 0x50, 0x35, 0x81, 0xaa, 0xde, 0x49, 0x5b, 0x0d, 0xa1,
 | |
| 	0xaa, 0x80, 0xaa, 0x11, 0x74, 0xfd, 0x61, 0xdb, 0xe4, 0x9d, 0x6e, 0x53, 0x35, 0x5c, 0x5b, 0x6b,
 | |
| 	0xbb, 0x6d, 0x57, 0x13, 0x0c, 0xcd, 0xee, 0xb1, 0x58, 0x89, 0x85, 0xf8, 0x1a, 0x30, 0xaf, 0x6f,
 | |
| 	0xcb, 0xa0, 0xa8, 0x67, 0xda, 0xd4, 0xe8, 0x98, 0x0e, 0xf8, 0xa7, 0x49, 0x58, 0x36, 0x70, 0xaa,
 | |
| 	0xf5, 0xc6, 0xe2, 0x59, 0xd7, 0xa6, 0xa1, 0xfc, 0xae, 0xc3, 0x4d, 0x1b, 0xc6, 0x00, 0x8f, 0xdf,
 | |
| 	0x04, 0x60, 0x46, 0x07, 0x6c, 0x3a, 0x86, 0x7b, 0x34, 0x0d, 0xd7, 0xe5, 0xa6, 0xa5, 0x99, 0x0e,
 | |
| 	0x67, 0xdc, 0x1f, 0x03, 0xa5, 0xee, 0xc4, 0xc0, 0xef, 0x81, 0x9f, 0x5c, 0x08, 0xbe, 0xa5, 0xb6,
 | |
| 	0x67, 0xc1, 0xa4, 0x3b, 0x3d, 0x98, 0x5a, 0x9e, 0x09, 0xde, 0xb5, 0x9f, 0x32, 0x28, 0xbf, 0xe3,
 | |
| 	0xbb, 0xce, 0xae, 0xdb, 0xc4, 0xaf, 0x50, 0x21, 0x4c, 0x54, 0x8b, 0x72, 0x5a, 0x56, 0x36, 0x94,
 | |
| 	0xcd, 0x52, 0xfd, 0x03, 0x55, 0x16, 0x2c, 0x1d, 0x77, 0x52, 0xb2, 0xd0, 0x5b, 0xed, 0x6d, 0xa9,
 | |
| 	0xcf, 0x9b, 0xaf, 0xc1, 0xe0, 0xfb, 0xc0, 0xa9, 0x8e, 0xcf, 0xfa, 0xd5, 0xb9, 0xa0, 0x5f, 0x45,
 | |
| 	0x89, 0x8d, 0xc4, 0xac, 0xf8, 0x0b, 0x34, 0xcf, 0x3c, 0x30, 0xca, 0x19, 0xc1, 0xfe, 0x58, 0xbd,
 | |
| 	0xb6, 0x1c, 0x54, 0x19, 0x63, 0xc3, 0x03, 0x43, 0xbf, 0x23, 0xcf, 0x98, 0x0f, 0x57, 0x44, 0x30,
 | |
| 	0xe2, 0x57, 0x28, 0xc7, 0x38, 0xe5, 0x5d, 0x56, 0xce, 0x0a, 0xee, 0x27, 0x37, 0xe0, 0x16, 0x78,
 | |
| 	0x7d, 0x49, 0xb2, 0xe7, 0x06, 0x6b, 0x22, 0x79, 0x6b, 0xbf, 0x29, 0xa8, 0x24, 0x3d, 0xf7, 0x4c,
 | |
| 	0xc6, 0xf1, 0xd1, 0x58, 0xb6, 0xd4, 0xeb, 0x65, 0x2b, 0x44, 0x8b, 0x5c, 0xad, 0xc8, 0x93, 0x0a,
 | |
| 	0x91, 0x25, 0x95, 0xa9, 0x97, 0x68, 0xc1, 0xe4, 0x60, 0xb3, 0x72, 0x66, 0x23, 0xbb, 0x59, 0xaa,
 | |
| 	0xd7, 0x67, 0xbf, 0x8e, 0xbe, 0x28, 0xe9, 0x17, 0x3e, 0x0b, 0x89, 0xc8, 0x80, 0xaf, 0xf6, 0x7d,
 | |
| 	0x36, 0xbe, 0x46, 0x98, 0x3e, 0xfc, 0x00, 0x15, 0x42, 0xcd, 0xb6, 0xba, 0x16, 0x88, 0x6b, 0x14,
 | |
| 	0x93, 0xb0, 0x1a, 0xd2, 0x4e, 0x62, 0x0f, 0xfc, 0x02, 0xdd, 0x65, 0x9c, 0xfa, 0xdc, 0x74, 0xda,
 | |
| 	0x9f, 0x00, 0x6d, 0x59, 0xa6, 0x03, 0x0d, 0x30, 0x5c, 0xa7, 0xc5, 0x44, 0x4d, 0xb3, 0xfa, 0xbb,
 | |
| 	0x41, 0xbf, 0x7a, 0xb7, 0x31, 0xd9, 0x85, 0x4c, 0xc3, 0xe2, 0x23, 0xb4, 0x6a, 0xb8, 0x8e, 0xd1,
 | |
| 	0xf5, 0x7d, 0x70, 0x8c, 0xd3, 0x03, 0xd7, 0x32, 0x8d, 0x53, 0x51, 0xc8, 0xa2, 0xae, 0xca, 0x68,
 | |
| 	0x56, 0x77, 0x46, 0x1d, 0x2e, 0x27, 0x19, 0xc9, 0x38, 0x11, 0x7e, 0x0f, 0xe5, 0x59, 0x97, 0x79,
 | |
| 	0xe0, 0xb4, 0xca, 0xf3, 0x1b, 0xca, 0x66, 0x41, 0x2f, 0x05, 0xfd, 0x6a, 0xbe, 0x31, 0x30, 0x91,
 | |
| 	0x68, 0x0f, 0x7f, 0x83, 0x4a, 0xaf, 0xdd, 0xe6, 0x21, 0xd8, 0x9e, 0x45, 0x39, 0x94, 0x17, 0x44,
 | |
| 	0x4d, 0x9f, 0xce, 0x90, 0xf8, 0xdd, 0x04, 0x2d, 0x74, 0xfa, 0x96, 0x0c, 0xbd, 0x94, 0xda, 0x20,
 | |
| 	0xe9, 0x33, 0x6a, 0x7f, 0x28, 0x68, 0x71, 0x48, 0x7d, 0xf8, 0x05, 0xca, 0x51, 0x83, 0x9b, 0xbd,
 | |
| 	0xb0, 0x18, 0x61, 0xe1, 0x1f, 0x4e, 0x3f, 0x3f, 0x79, 0x79, 0x04, 0x8e, 0x21, 0xbc, 0x30, 0x24,
 | |
| 	0xe2, 0x7d, 0x26, 0x48, 0x88, 0x24, 0xc3, 0x16, 0x5a, 0xb1, 0x28, 0xe3, 0x51, 0x45, 0x0f, 0x4d,
 | |
| 	0x1b, 0x44, 0x2e, 0x4a, 0xf5, 0xfb, 0xd7, 0x13, 0x6d, 0x88, 0xd0, 0xdf, 0x0e, 0xfa, 0xd5, 0x95,
 | |
| 	0xbd, 0x11, 0x1e, 0x32, 0xc6, 0x5c, 0xfb, 0x31, 0x83, 0xb2, 0xb7, 0xd3, 0x50, 0x0e, 0x87, 0x1a,
 | |
| 	0x4a, 0x7d, 0xb6, 0x62, 0x4d, 0x6d, 0x26, 0x47, 0x23, 0xcd, 0x64, 0x7b, 0x46, 0xde, 0xab, 0x1b,
 | |
| 	0xc9, 0x79, 0x16, 0xdd, 0xd9, 0x75, 0x9b, 0x3b, 0xae, 0xd3, 0x32, 0xb9, 0xe9, 0x3a, 0x78, 0x1b,
 | |
| 	0xcd, 0xf3, 0x53, 0x2f, 0x7a, 0x7e, 0x1b, 0x51, 0x40, 0x87, 0xa7, 0x1e, 0x5c, 0xf6, 0xab, 0x2b,
 | |
| 	0x69, 0xdf, 0xd0, 0x46, 0x84, 0x37, 0xfe, 0x3c, 0x0e, 0x32, 0x23, 0x70, 0x1f, 0x0f, 0x1f, 0x77,
 | |
| 	0xd9, 0xaf, 0x5e, 0x39, 0x09, 0xd4, 0x98, 0x73, 0x38, 0x3c, 0xdc, 0x46, 0x8b, 0x61, 0x41, 0x0f,
 | |
| 	0x7c, 0xb7, 0x39, 0xd0, 0x49, 0x76, 0x66, 0x9d, 0xac, 0xc9, 0x50, 0x16, 0xf7, 0xd2, 0x44, 0x64,
 | |
| 	0x98, 0x17, 0xf7, 0x10, 0x0e, 0x0d, 0x87, 0x3e, 0x75, 0xd8, 0xe0, 0x72, 0x37, 0x53, 0xe5, 0xba,
 | |
| 	0x3c, 0x0d, 0xef, 0x8d, 0xb1, 0x91, 0x09, 0x27, 0xe0, 0xf7, 0x51, 0xce, 0x07, 0xca, 0x5c, 0x47,
 | |
| 	0x3c, 0xf1, 0x62, 0x52, 0x27, 0x22, 0xac, 0x44, 0xee, 0xe2, 0x7b, 0x28, 0x6f, 0x03, 0x63, 0xb4,
 | |
| 	0x0d, 0xe5, 0x9c, 0x70, 0x5c, 0x96, 0x8e, 0xf9, 0xfd, 0x81, 0x99, 0x44, 0xfb, 0xb5, 0x5f, 0x15,
 | |
| 	0x94, 0xbf, 0x9d, 0xb9, 0xd0, 0x18, 0x9e, 0x0b, 0xea, 0x6c, 0xca, 0x9c, 0x32, 0x13, 0x7e, 0xce,
 | |
| 	0x8a, 0xf0, 0xc5, 0x3c, 0xd8, 0x42, 0x25, 0x8f, 0xfa, 0xd4, 0xb2, 0xc0, 0x32, 0x99, 0x2d, 0x6e,
 | |
| 	0xb0, 0xa0, 0x2f, 0x87, 0x5d, 0xec, 0x20, 0x31, 0x93, 0xb4, 0x4f, 0x08, 0x31, 0xdc, 0xf0, 0x77,
 | |
| 	0x24, 0x4c, 0xf1, 0x40, 0x8e, 0x12, 0xb2, 0x93, 0x98, 0x49, 0xda, 0x07, 0x3f, 0x47, 0x6b, 0x83,
 | |
| 	0xce, 0x34, 0x3a, 0x45, 0xb2, 0x62, 0x8a, 0xbc, 0x13, 0xf4, 0xab, 0x6b, 0xcf, 0x26, 0x39, 0x90,
 | |
| 	0xc9, 0x38, 0xfc, 0x35, 0x2a, 0x30, 0xb0, 0xc0, 0xe0, 0xae, 0x2f, 0x25, 0xf4, 0xe8, 0x9a, 0x59,
 | |
| 	0xa7, 0x4d, 0xb0, 0x1a, 0x12, 0xaa, 0xdf, 0x11, 0x73, 0x4f, 0xae, 0x48, 0x4c, 0x89, 0x9f, 0xa2,
 | |
| 	0x25, 0x9b, 0x3a, 0x5d, 0x1a, 0x7b, 0x0a, 0xed, 0x14, 0x74, 0x1c, 0xf4, 0xab, 0x4b, 0xfb, 0x43,
 | |
| 	0x3b, 0x64, 0xc4, 0x13, 0x7f, 0x85, 0x0a, 0x3c, 0x1a, 0x2a, 0x39, 0x11, 0xda, 0x1b, 0x9a, 0xfa,
 | |
| 	0x81, 0xdb, 0x1a, 0x9a, 0x23, 0xb1, 0x1e, 0xe2, 0x21, 0x12, 0x13, 0xd6, 0x7e, 0xc9, 0xa2, 0x62,
 | |
| 	0x32, 0x3d, 0x4e, 0x10, 0x32, 0xa2, 0x67, 0xcd, 0xe4, 0x04, 0xf9, 0x70, 0x36, 0x89, 0xc4, 0x6d,
 | |
| 	0x21, 0xe9, 0xbc, 0xb1, 0x89, 0x91, 0x14, 0x3d, 0x7e, 0x89, 0x8a, 0x62, 0x9e, 0x8b, 0x67, 0x9b,
 | |
| 	0x99, 0xf9, 0xd9, 0x2e, 0x06, 0xfd, 0x6a, 0xb1, 0x11, 0x11, 0x90, 0x84, 0x0b, 0x1f, 0xa3, 0xa5,
 | |
| 	0x44, 0x2b, 0x37, 0x6c, 0x41, 0xa2, 0x30, 0x3b, 0x43, 0x2c, 0x64, 0x84, 0x35, 0x6c, 0x04, 0x72,
 | |
| 	0xd6, 0xce, 0x0b, 0xc9, 0x4e, 0x1b, 0x9e, 0x1a, 0x2a, 0xb2, 0xae, 0x61, 0x00, 0xb4, 0xa0, 0x25,
 | |
| 	0xea, 0xbe, 0xa0, 0xaf, 0x4a, 0xd7, 0x62, 0x23, 0xda, 0x20, 0x89, 0x4f, 0x48, 0x7c, 0x4c, 0x4d,
 | |
| 	0x0b, 0x5a, 0xa2, 0xde, 0x29, 0xe2, 0x4f, 0x85, 0x95, 0xc8, 0xdd, 0xda, 0x5f, 0x0a, 0x4a, 0xff,
 | |
| 	0x1b, 0xdc, 0xc2, 0xbc, 0xec, 0xa4, 0xb4, 0x98, 0xf9, 0xcf, 0x3f, 0x38, 0x57, 0x09, 0xf3, 0x77,
 | |
| 	0x05, 0x2d, 0x8f, 0xf8, 0xff, 0x5f, 0xff, 0x07, 0xf4, 0xfb, 0x67, 0x17, 0x95, 0xb9, 0xf3, 0x8b,
 | |
| 	0xca, 0xdc, 0x9f, 0x17, 0x95, 0xb9, 0xef, 0x82, 0x8a, 0x72, 0x16, 0x54, 0x94, 0xf3, 0xa0, 0xa2,
 | |
| 	0xfc, 0x1d, 0x54, 0x94, 0x1f, 0xfe, 0xa9, 0xcc, 0x7d, 0x59, 0x88, 0x78, 0xfe, 0x0d, 0x00, 0x00,
 | |
| 	0xff, 0xff, 0xef, 0x59, 0xca, 0xdd, 0x1e, 0x0f, 0x00, 0x00,
 | |
| }
 | 
