| /* |
| Copyright 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. DO NOT EDIT. |
| // source: k8s.io/api/apps/v1beta1/generated.proto |
| |
| package v1beta1 |
| |
| import ( |
| fmt "fmt" |
| |
| io "io" |
| "sort" |
| |
| k8s_io_api_core_v1 "k8s.io/api/core/v1" |
| v11 "k8s.io/api/core/v1" |
| v1 "k8s.io/apimachinery/pkg/apis/meta/v1" |
| |
| math_bits "math/bits" |
| reflect "reflect" |
| strings "strings" |
| |
| intstr "k8s.io/apimachinery/pkg/util/intstr" |
| ) |
| |
| func (m *ControllerRevision) Reset() { *m = ControllerRevision{} } |
| |
| func (m *ControllerRevisionList) Reset() { *m = ControllerRevisionList{} } |
| |
| func (m *Deployment) Reset() { *m = Deployment{} } |
| |
| func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} } |
| |
| func (m *DeploymentList) Reset() { *m = DeploymentList{} } |
| |
| func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} } |
| |
| func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} } |
| |
| func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} } |
| |
| func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} } |
| |
| func (m *RollbackConfig) Reset() { *m = RollbackConfig{} } |
| |
| func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} } |
| |
| func (m *RollingUpdateStatefulSetStrategy) Reset() { *m = RollingUpdateStatefulSetStrategy{} } |
| |
| func (m *Scale) Reset() { *m = Scale{} } |
| |
| func (m *ScaleSpec) Reset() { *m = ScaleSpec{} } |
| |
| func (m *ScaleStatus) Reset() { *m = ScaleStatus{} } |
| |
| func (m *StatefulSet) Reset() { *m = StatefulSet{} } |
| |
| func (m *StatefulSetCondition) Reset() { *m = StatefulSetCondition{} } |
| |
| func (m *StatefulSetList) Reset() { *m = StatefulSetList{} } |
| |
| func (m *StatefulSetOrdinals) Reset() { *m = StatefulSetOrdinals{} } |
| |
| func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Reset() { |
| *m = StatefulSetPersistentVolumeClaimRetentionPolicy{} |
| } |
| |
| func (m *StatefulSetSpec) Reset() { *m = StatefulSetSpec{} } |
| |
| func (m *StatefulSetStatus) Reset() { *m = StatefulSetStatus{} } |
| |
| func (m *StatefulSetUpdateStrategy) Reset() { *m = StatefulSetUpdateStrategy{} } |
| |
| func (m *ControllerRevision) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ControllerRevision) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ControllerRevision) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Revision)) |
| i-- |
| dAtA[i] = 0x18 |
| { |
| size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| { |
| size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ControllerRevisionList) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ControllerRevisionList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ControllerRevisionList) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Items) > 0 { |
| for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| { |
| size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Deployment) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Deployment) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Deployment) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| { |
| size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| { |
| size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DeploymentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x3a |
| { |
| size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x32 |
| i -= len(m.Message) |
| copy(dAtA[i:], m.Message) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) |
| i-- |
| dAtA[i] = 0x2a |
| i -= len(m.Reason) |
| copy(dAtA[i:], m.Reason) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) |
| i-- |
| dAtA[i] = 0x22 |
| i -= len(m.Status) |
| copy(dAtA[i:], m.Status) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(m.Type) |
| copy(dAtA[i:], m.Type) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DeploymentList) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DeploymentList) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Items) > 0 { |
| for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| { |
| size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DeploymentRollback) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.RollbackTo.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| if len(m.UpdatedAnnotations) > 0 { |
| keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations)) |
| for k := range m.UpdatedAnnotations { |
| keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k)) |
| } |
| sort.Strings(keysForUpdatedAnnotations) |
| for iNdEx := len(keysForUpdatedAnnotations) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.UpdatedAnnotations[string(keysForUpdatedAnnotations[iNdEx])] |
| baseI := i |
| i -= len(v) |
| copy(dAtA[i:], v) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(v))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(keysForUpdatedAnnotations[iNdEx]) |
| copy(dAtA[i:], keysForUpdatedAnnotations[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(keysForUpdatedAnnotations[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i -= len(m.Name) |
| copy(dAtA[i:], m.Name) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.ProgressDeadlineSeconds != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds)) |
| i-- |
| dAtA[i] = 0x48 |
| } |
| if m.RollbackTo != nil { |
| { |
| size, err := m.RollbackTo.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x42 |
| } |
| i-- |
| if m.Paused { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x38 |
| if m.RevisionHistoryLimit != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) |
| i-- |
| dAtA[i] = 0x30 |
| } |
| i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) |
| i-- |
| dAtA[i] = 0x28 |
| { |
| size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| { |
| size, err := m.Template.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| if m.Selector != nil { |
| { |
| size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.Replicas != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DeploymentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.TerminatingReplicas != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.TerminatingReplicas)) |
| i-- |
| dAtA[i] = 0x48 |
| } |
| if m.CollisionCount != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) |
| i-- |
| dAtA[i] = 0x40 |
| } |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) |
| i-- |
| dAtA[i] = 0x38 |
| if len(m.Conditions) > 0 { |
| for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x32 |
| } |
| } |
| i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas)) |
| i-- |
| dAtA[i] = 0x28 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) |
| i-- |
| dAtA[i] = 0x20 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas)) |
| i-- |
| dAtA[i] = 0x18 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) |
| i-- |
| dAtA[i] = 0x10 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DeploymentStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.RollingUpdate != nil { |
| { |
| size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| i -= len(m.Type) |
| copy(dAtA[i:], m.Type) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *RollbackConfig) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RollbackConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Revision)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RollingUpdateDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.MaxSurge != nil { |
| { |
| size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.MaxUnavailable != nil { |
| { |
| size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *RollingUpdateStatefulSetStrategy) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *RollingUpdateStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RollingUpdateStatefulSetStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.MaxUnavailable != nil { |
| { |
| size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.Partition != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.Partition)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Scale) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Scale) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Scale) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| { |
| size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| { |
| size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ScaleSpec) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ScaleSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ScaleStatus) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ScaleStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i -= len(m.TargetSelector) |
| copy(dAtA[i:], m.TargetSelector) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector))) |
| i-- |
| dAtA[i] = 0x1a |
| if len(m.Selector) > 0 { |
| keysForSelector := make([]string, 0, len(m.Selector)) |
| for k := range m.Selector { |
| keysForSelector = append(keysForSelector, string(k)) |
| } |
| sort.Strings(keysForSelector) |
| for iNdEx := len(keysForSelector) - 1; iNdEx >= 0; iNdEx-- { |
| v := m.Selector[string(keysForSelector[iNdEx])] |
| baseI := i |
| i -= len(v) |
| copy(dAtA[i:], v) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(v))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(keysForSelector[iNdEx]) |
| copy(dAtA[i:], keysForSelector[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSelector[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSet) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSet) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| { |
| size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| { |
| size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetCondition) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetCondition) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i -= len(m.Message) |
| copy(dAtA[i:], m.Message) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) |
| i-- |
| dAtA[i] = 0x2a |
| i -= len(m.Reason) |
| copy(dAtA[i:], m.Reason) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) |
| i-- |
| dAtA[i] = 0x22 |
| { |
| size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| i -= len(m.Status) |
| copy(dAtA[i:], m.Status) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(m.Type) |
| copy(dAtA[i:], m.Type) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetList) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Items) > 0 { |
| for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| { |
| size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetOrdinals) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetOrdinals) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetOrdinals) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Start)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i -= len(m.WhenScaled) |
| copy(dAtA[i:], m.WhenScaled) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenScaled))) |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(m.WhenDeleted) |
| copy(dAtA[i:], m.WhenDeleted) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.WhenDeleted))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetSpec) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetSpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Ordinals != nil { |
| { |
| size, err := m.Ordinals.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x5a |
| } |
| if m.PersistentVolumeClaimRetentionPolicy != nil { |
| { |
| size, err := m.PersistentVolumeClaimRetentionPolicy.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x52 |
| } |
| i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) |
| i-- |
| dAtA[i] = 0x48 |
| if m.RevisionHistoryLimit != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) |
| i-- |
| dAtA[i] = 0x40 |
| } |
| { |
| size, err := m.UpdateStrategy.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x3a |
| i -= len(m.PodManagementPolicy) |
| copy(dAtA[i:], m.PodManagementPolicy) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.PodManagementPolicy))) |
| i-- |
| dAtA[i] = 0x32 |
| i -= len(m.ServiceName) |
| copy(dAtA[i:], m.ServiceName) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName))) |
| i-- |
| dAtA[i] = 0x2a |
| if len(m.VolumeClaimTemplates) > 0 { |
| for iNdEx := len(m.VolumeClaimTemplates) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.VolumeClaimTemplates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x22 |
| } |
| } |
| { |
| size, err := m.Template.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| if m.Selector != nil { |
| { |
| size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.Replicas != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetStatus) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetStatus) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas)) |
| i-- |
| dAtA[i] = 0x58 |
| if len(m.Conditions) > 0 { |
| for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x52 |
| } |
| } |
| if m.CollisionCount != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount)) |
| i-- |
| dAtA[i] = 0x48 |
| } |
| i -= len(m.UpdateRevision) |
| copy(dAtA[i:], m.UpdateRevision) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.UpdateRevision))) |
| i-- |
| dAtA[i] = 0x3a |
| i -= len(m.CurrentRevision) |
| copy(dAtA[i:], m.CurrentRevision) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.CurrentRevision))) |
| i-- |
| dAtA[i] = 0x32 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas)) |
| i-- |
| dAtA[i] = 0x28 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas)) |
| i-- |
| dAtA[i] = 0x20 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) |
| i-- |
| dAtA[i] = 0x18 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) |
| i-- |
| dAtA[i] = 0x10 |
| if m.ObservedGeneration != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.ObservedGeneration)) |
| i-- |
| dAtA[i] = 0x8 |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *StatefulSetUpdateStrategy) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalToSizedBuffer(dAtA[:size]) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *StatefulSetUpdateStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.RollingUpdate != nil { |
| { |
| size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| i -= len(m.Type) |
| copy(dAtA[i:], m.Type) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { |
| offset -= sovGenerated(v) |
| base := offset |
| for v >= 1<<7 { |
| dAtA[offset] = uint8(v&0x7f | 0x80) |
| v >>= 7 |
| offset++ |
| } |
| dAtA[offset] = uint8(v) |
| return base |
| } |
| func (m *ControllerRevision) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = m.ObjectMeta.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.Data.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 1 + sovGenerated(uint64(m.Revision)) |
| return n |
| } |
| |
| func (m *ControllerRevisionList) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 *Deployment) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 *DeploymentCondition) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 = len(m.Reason) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Message) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.LastUpdateTime.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.LastTransitionTime.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *DeploymentList) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 *DeploymentRollback) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.UpdatedAnnotations) > 0 { |
| for k, v := range m.UpdatedAnnotations { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) |
| } |
| } |
| l = m.RollbackTo.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *DeploymentSpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Replicas != nil { |
| n += 1 + sovGenerated(uint64(*m.Replicas)) |
| } |
| if m.Selector != nil { |
| l = m.Selector.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| l = m.Template.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.Strategy.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 1 + sovGenerated(uint64(m.MinReadySeconds)) |
| if m.RevisionHistoryLimit != nil { |
| n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) |
| } |
| n += 2 |
| if m.RollbackTo != nil { |
| l = m.RollbackTo.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.ProgressDeadlineSeconds != nil { |
| n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds)) |
| } |
| return n |
| } |
| |
| func (m *DeploymentStatus) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.ObservedGeneration)) |
| n += 1 + sovGenerated(uint64(m.Replicas)) |
| n += 1 + sovGenerated(uint64(m.UpdatedReplicas)) |
| n += 1 + sovGenerated(uint64(m.AvailableReplicas)) |
| n += 1 + sovGenerated(uint64(m.UnavailableReplicas)) |
| if len(m.Conditions) > 0 { |
| for _, e := range m.Conditions { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| n += 1 + sovGenerated(uint64(m.ReadyReplicas)) |
| if m.CollisionCount != nil { |
| n += 1 + sovGenerated(uint64(*m.CollisionCount)) |
| } |
| if m.TerminatingReplicas != nil { |
| n += 1 + sovGenerated(uint64(*m.TerminatingReplicas)) |
| } |
| return n |
| } |
| |
| func (m *DeploymentStrategy) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Type) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.RollingUpdate != nil { |
| l = m.RollingUpdate.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *RollbackConfig) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Revision)) |
| return n |
| } |
| |
| func (m *RollingUpdateDeployment) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.MaxUnavailable != nil { |
| l = m.MaxUnavailable.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.MaxSurge != nil { |
| l = m.MaxSurge.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *RollingUpdateStatefulSetStrategy) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Partition != nil { |
| n += 1 + sovGenerated(uint64(*m.Partition)) |
| } |
| if m.MaxUnavailable != nil { |
| l = m.MaxUnavailable.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *Scale) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 *ScaleSpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Replicas)) |
| return n |
| } |
| |
| func (m *ScaleStatus) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Replicas)) |
| if len(m.Selector) > 0 { |
| for k, v := range m.Selector { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) |
| } |
| } |
| l = len(m.TargetSelector) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *StatefulSet) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 *StatefulSetCondition) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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.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 *StatefulSetList) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| 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 *StatefulSetOrdinals) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Start)) |
| return n |
| } |
| |
| func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.WhenDeleted) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.WhenScaled) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *StatefulSetSpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Replicas != nil { |
| n += 1 + sovGenerated(uint64(*m.Replicas)) |
| } |
| if m.Selector != nil { |
| l = m.Selector.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| l = m.Template.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.VolumeClaimTemplates) > 0 { |
| for _, e := range m.VolumeClaimTemplates { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| l = len(m.ServiceName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.PodManagementPolicy) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.UpdateStrategy.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.RevisionHistoryLimit != nil { |
| n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) |
| } |
| n += 1 + sovGenerated(uint64(m.MinReadySeconds)) |
| if m.PersistentVolumeClaimRetentionPolicy != nil { |
| l = m.PersistentVolumeClaimRetentionPolicy.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.Ordinals != nil { |
| l = m.Ordinals.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *StatefulSetStatus) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.ObservedGeneration != nil { |
| n += 1 + sovGenerated(uint64(*m.ObservedGeneration)) |
| } |
| n += 1 + sovGenerated(uint64(m.Replicas)) |
| n += 1 + sovGenerated(uint64(m.ReadyReplicas)) |
| n += 1 + sovGenerated(uint64(m.CurrentReplicas)) |
| n += 1 + sovGenerated(uint64(m.UpdatedReplicas)) |
| l = len(m.CurrentRevision) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.UpdateRevision) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.CollisionCount != nil { |
| n += 1 + sovGenerated(uint64(*m.CollisionCount)) |
| } |
| if len(m.Conditions) > 0 { |
| for _, e := range m.Conditions { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| n += 1 + sovGenerated(uint64(m.AvailableReplicas)) |
| return n |
| } |
| |
| func (m *StatefulSetUpdateStrategy) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Type) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.RollingUpdate != nil { |
| l = m.RollingUpdate.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func sovGenerated(x uint64) (n int) { |
| return (math_bits.Len64(x|1) + 6) / 7 |
| } |
| func sozGenerated(x uint64) (n int) { |
| return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
| } |
| func (this *ControllerRevision) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ControllerRevision{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Data:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Data), "RawExtension", "runtime.RawExtension", 1), `&`, ``, 1) + `,`, |
| `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ControllerRevisionList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]ControllerRevision{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ControllerRevision", "ControllerRevision", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&ControllerRevisionList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Deployment) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Deployment{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`, |
| `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeploymentCondition) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DeploymentCondition{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `Status:` + fmt.Sprintf("%v", this.Status) + `,`, |
| `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, |
| `Message:` + fmt.Sprintf("%v", this.Message) + `,`, |
| `LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, |
| `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeploymentList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]Deployment{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Deployment", "Deployment", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&DeploymentList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeploymentRollback) String() string { |
| if this == nil { |
| return "nil" |
| } |
| keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations)) |
| for k := range this.UpdatedAnnotations { |
| keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k) |
| } |
| sort.Strings(keysForUpdatedAnnotations) |
| mapStringForUpdatedAnnotations := "map[string]string{" |
| for _, k := range keysForUpdatedAnnotations { |
| mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k]) |
| } |
| mapStringForUpdatedAnnotations += "}" |
| s := strings.Join([]string{`&DeploymentRollback{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`, |
| `RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeploymentSpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DeploymentSpec{`, |
| `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, |
| `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`, |
| `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`, |
| `Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`, |
| `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, |
| `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, |
| `Paused:` + fmt.Sprintf("%v", this.Paused) + `,`, |
| `RollbackTo:` + strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1) + `,`, |
| `ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeploymentStatus) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForConditions := "[]DeploymentCondition{" |
| for _, f := range this.Conditions { |
| repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForConditions += "}" |
| s := strings.Join([]string{`&DeploymentStatus{`, |
| `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, |
| `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, |
| `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`, |
| `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, |
| `UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`, |
| `Conditions:` + repeatedStringForConditions + `,`, |
| `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, |
| `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, |
| `TerminatingReplicas:` + valueToStringGenerated(this.TerminatingReplicas) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeploymentStrategy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DeploymentStrategy{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RollbackConfig) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RollbackConfig{`, |
| `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RollingUpdateDeployment) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RollingUpdateDeployment{`, |
| `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`, |
| `MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RollingUpdateStatefulSetStrategy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RollingUpdateStatefulSetStrategy{`, |
| `Partition:` + valueToStringGenerated(this.Partition) + `,`, |
| `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Scale) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Scale{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`, |
| `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ScaleSpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ScaleSpec{`, |
| `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ScaleStatus) String() string { |
| if this == nil { |
| return "nil" |
| } |
| keysForSelector := make([]string, 0, len(this.Selector)) |
| for k := range this.Selector { |
| keysForSelector = append(keysForSelector, k) |
| } |
| sort.Strings(keysForSelector) |
| mapStringForSelector := "map[string]string{" |
| for _, k := range keysForSelector { |
| mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k]) |
| } |
| mapStringForSelector += "}" |
| s := strings.Join([]string{`&ScaleStatus{`, |
| `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, |
| `Selector:` + mapStringForSelector + `,`, |
| `TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSet) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatefulSet{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "StatefulSetSpec", "StatefulSetSpec", 1), `&`, ``, 1) + `,`, |
| `Status:` + strings.Replace(strings.Replace(this.Status.String(), "StatefulSetStatus", "StatefulSetStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetCondition) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatefulSetCondition{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `Status:` + fmt.Sprintf("%v", this.Status) + `,`, |
| `LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`, |
| `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, |
| `Message:` + fmt.Sprintf("%v", this.Message) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]StatefulSet{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "StatefulSet", "StatefulSet", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&StatefulSetList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetOrdinals) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatefulSetOrdinals{`, |
| `Start:` + fmt.Sprintf("%v", this.Start) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetPersistentVolumeClaimRetentionPolicy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatefulSetPersistentVolumeClaimRetentionPolicy{`, |
| `WhenDeleted:` + fmt.Sprintf("%v", this.WhenDeleted) + `,`, |
| `WhenScaled:` + fmt.Sprintf("%v", this.WhenScaled) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetSpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForVolumeClaimTemplates := "[]PersistentVolumeClaim{" |
| for _, f := range this.VolumeClaimTemplates { |
| repeatedStringForVolumeClaimTemplates += fmt.Sprintf("%v", f) + "," |
| } |
| repeatedStringForVolumeClaimTemplates += "}" |
| s := strings.Join([]string{`&StatefulSetSpec{`, |
| `Replicas:` + valueToStringGenerated(this.Replicas) + `,`, |
| `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`, |
| `Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`, |
| `VolumeClaimTemplates:` + repeatedStringForVolumeClaimTemplates + `,`, |
| `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`, |
| `PodManagementPolicy:` + fmt.Sprintf("%v", this.PodManagementPolicy) + `,`, |
| `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "StatefulSetUpdateStrategy", "StatefulSetUpdateStrategy", 1), `&`, ``, 1) + `,`, |
| `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, |
| `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, |
| `PersistentVolumeClaimRetentionPolicy:` + strings.Replace(this.PersistentVolumeClaimRetentionPolicy.String(), "StatefulSetPersistentVolumeClaimRetentionPolicy", "StatefulSetPersistentVolumeClaimRetentionPolicy", 1) + `,`, |
| `Ordinals:` + strings.Replace(this.Ordinals.String(), "StatefulSetOrdinals", "StatefulSetOrdinals", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetStatus) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForConditions := "[]StatefulSetCondition{" |
| for _, f := range this.Conditions { |
| repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "StatefulSetCondition", "StatefulSetCondition", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForConditions += "}" |
| s := strings.Join([]string{`&StatefulSetStatus{`, |
| `ObservedGeneration:` + valueToStringGenerated(this.ObservedGeneration) + `,`, |
| `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, |
| `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, |
| `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`, |
| `UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`, |
| `CurrentRevision:` + fmt.Sprintf("%v", this.CurrentRevision) + `,`, |
| `UpdateRevision:` + fmt.Sprintf("%v", this.UpdateRevision) + `,`, |
| `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, |
| `Conditions:` + repeatedStringForConditions + `,`, |
| `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatefulSetUpdateStrategy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatefulSetUpdateStrategy{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateStatefulSetStrategy", "RollingUpdateStatefulSetStrategy", 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 *ControllerRevision) 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: ControllerRevision: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ControllerRevision: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 Data", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) |
| } |
| m.Revision = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Revision |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ControllerRevisionList) 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: ControllerRevisionList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ControllerRevisionList: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Items = append(m.Items, ControllerRevision{}) |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Deployment) 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: Deployment: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Deployment: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeploymentCondition) 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: DeploymentCondition: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeploymentCondition: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Type = DeploymentConditionType(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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Reason = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Message = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 7: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.LastTransitionTime.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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeploymentList) 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: DeploymentList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeploymentList: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Items = append(m.Items, Deployment{}) |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeploymentRollback) 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: DeploymentRollback: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Name", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Name = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.UpdatedAnnotations == nil { |
| m.UpdatedAnnotations = make(map[string]string) |
| } |
| var mapkey string |
| var mapvalue string |
| for iNdEx < postIndex { |
| entryPreIndex := 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) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var stringLenmapvalue uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapvalue |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapvalue := int(stringLenmapvalue) |
| if intStringLenmapvalue < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postStringIndexmapvalue := iNdEx + intStringLenmapvalue |
| if postStringIndexmapvalue < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postStringIndexmapvalue > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.UpdatedAnnotations[mapkey] = mapvalue |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.RollbackTo.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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeploymentSpec) 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: DeploymentSpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Replicas", 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.Replicas = &v |
| case 2: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Selector == nil { |
| m.Selector = &v1.LabelSelector{} |
| } |
| if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Strategy", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) |
| } |
| m.MinReadySeconds = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.MinReadySeconds |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", 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.RevisionHistoryLimit = &v |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Paused", 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 |
| } |
| } |
| m.Paused = bool(v != 0) |
| case 8: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.RollbackTo == nil { |
| m.RollbackTo = &RollbackConfig{} |
| } |
| if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", 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.ProgressDeadlineSeconds = &v |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeploymentStatus) 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: DeploymentStatus: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType) |
| } |
| m.ObservedGeneration = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ObservedGeneration |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) |
| } |
| m.Replicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Replicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType) |
| } |
| m.UpdatedReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.UpdatedReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) |
| } |
| m.AvailableReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.AvailableReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType) |
| } |
| m.UnavailableReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.UnavailableReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 6: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Conditions = append(m.Conditions, DeploymentCondition{}) |
| if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) |
| } |
| m.ReadyReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ReadyReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 8: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", 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.CollisionCount = &v |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TerminatingReplicas", 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.TerminatingReplicas = &v |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeploymentStrategy) 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: DeploymentStrategy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeploymentStrategy: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.RollingUpdate == nil { |
| m.RollingUpdate = &RollingUpdateDeployment{} |
| } |
| if err := m.RollingUpdate.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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RollbackConfig) 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: RollbackConfig: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) |
| } |
| m.Revision = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Revision |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RollingUpdateDeployment) 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: RollingUpdateDeployment: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.MaxUnavailable == nil { |
| m.MaxUnavailable = &intstr.IntOrString{} |
| } |
| if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.MaxSurge == nil { |
| m.MaxSurge = &intstr.IntOrString{} |
| } |
| if err := m.MaxSurge.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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RollingUpdateStatefulSetStrategy) 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: RollingUpdateStatefulSetStrategy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Partition", 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.Partition = &v |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.MaxUnavailable == nil { |
| m.MaxUnavailable = &intstr.IntOrString{} |
| } |
| if err := m.MaxUnavailable.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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Scale) 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: Scale: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Scale: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ScaleSpec) 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: ScaleSpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) |
| } |
| m.Replicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Replicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ScaleStatus) 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: ScaleStatus: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) |
| } |
| m.Replicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Replicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Selector == nil { |
| m.Selector = make(map[string]string) |
| } |
| var mapkey string |
| var mapvalue string |
| for iNdEx < postIndex { |
| entryPreIndex := 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) |
| if fieldNum == 1 { |
| var stringLenmapkey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapkey |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapkey := int(stringLenmapkey) |
| if intStringLenmapkey < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postStringIndexmapkey := iNdEx + intStringLenmapkey |
| if postStringIndexmapkey < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postStringIndexmapkey > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| } else if fieldNum == 2 { |
| var stringLenmapvalue uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLenmapvalue |= uint64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLenmapvalue := int(stringLenmapvalue) |
| if intStringLenmapvalue < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postStringIndexmapvalue := iNdEx + intStringLenmapvalue |
| if postStringIndexmapvalue < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postStringIndexmapvalue > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| } else { |
| iNdEx = entryPreIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > postIndex { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| m.Selector[mapkey] = mapvalue |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.TargetSelector = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSet) 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: StatefulSet: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSet: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetCondition) 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: StatefulSetCondition: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetCondition: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Type = StatefulSetConditionType(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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Reason = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetList) 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: StatefulSetList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetList: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Items = append(m.Items, StatefulSet{}) |
| 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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetOrdinals) 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: StatefulSetOrdinals: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetOrdinals: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType) |
| } |
| m.Start = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Start |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetPersistentVolumeClaimRetentionPolicy) 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: StatefulSetPersistentVolumeClaimRetentionPolicy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetPersistentVolumeClaimRetentionPolicy: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field WhenDeleted", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.WhenDeleted = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field WhenScaled", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.WhenScaled = PersistentVolumeClaimRetentionPolicyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetSpec) 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: StatefulSetSpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Replicas", 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.Replicas = &v |
| case 2: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Selector == nil { |
| m.Selector = &v1.LabelSelector{} |
| } |
| if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field VolumeClaimTemplates", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.VolumeClaimTemplates = append(m.VolumeClaimTemplates, v11.PersistentVolumeClaim{}) |
| if err := m.VolumeClaimTemplates[len(m.VolumeClaimTemplates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ServiceName = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PodManagementPolicy", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.PodManagementPolicy = PodManagementPolicyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 8: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", 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.RevisionHistoryLimit = &v |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType) |
| } |
| m.MinReadySeconds = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.MinReadySeconds |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 10: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PersistentVolumeClaimRetentionPolicy", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.PersistentVolumeClaimRetentionPolicy == nil { |
| m.PersistentVolumeClaimRetentionPolicy = &StatefulSetPersistentVolumeClaimRetentionPolicy{} |
| } |
| if err := m.PersistentVolumeClaimRetentionPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 11: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ordinals", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Ordinals == nil { |
| m.Ordinals = &StatefulSetOrdinals{} |
| } |
| if err := m.Ordinals.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) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetStatus) 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: StatefulSetStatus: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", 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.ObservedGeneration = &v |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType) |
| } |
| m.Replicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Replicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType) |
| } |
| m.ReadyReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.ReadyReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType) |
| } |
| m.CurrentReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.CurrentReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType) |
| } |
| m.UpdatedReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.UpdatedReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CurrentRevision", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.CurrentRevision = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UpdateRevision", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.UpdateRevision = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", 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.CollisionCount = &v |
| case 10: |
| 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Conditions = append(m.Conditions, StatefulSetCondition{}) |
| if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 11: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType) |
| } |
| m.AvailableReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.AvailableReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if (skippy < 0) || (iNdEx+skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatefulSetUpdateStrategy) 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: StatefulSetUpdateStrategy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatefulSetUpdateStrategy: 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Type = StatefulSetUpdateStrategyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", 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 < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.RollingUpdate == nil { |
| m.RollingUpdate = &RollingUpdateStatefulSetStrategy{} |
| } |
| if err := m.RollingUpdate.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) || (iNdEx+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 |
| depth := 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 |
| } |
| } |
| case 1: |
| iNdEx += 8 |
| 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 |
| } |
| } |
| if length < 0 { |
| return 0, ErrInvalidLengthGenerated |
| } |
| iNdEx += length |
| case 3: |
| depth++ |
| case 4: |
| if depth == 0 { |
| return 0, ErrUnexpectedEndOfGroupGenerated |
| } |
| depth-- |
| case 5: |
| iNdEx += 4 |
| default: |
| return 0, fmt.Errorf("proto: illegal wireType %d", wireType) |
| } |
| if iNdEx < 0 { |
| return 0, ErrInvalidLengthGenerated |
| } |
| if depth == 0 { |
| return iNdEx, nil |
| } |
| } |
| return 0, io.ErrUnexpectedEOF |
| } |
| |
| var ( |
| ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") |
| ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") |
| ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group") |
| ) |
