| /* |
| 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/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto |
| |
| package v1beta1 |
| |
| import ( |
| fmt "fmt" |
| |
| io "io" |
| |
| proto "github.com/gogo/protobuf/proto" |
| github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" |
| 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 "math" |
| math_bits "math/bits" |
| reflect "reflect" |
| strings "strings" |
| |
| intstr "k8s.io/apimachinery/pkg/util/intstr" |
| ) |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| |
| // This is a compile-time assertion to ensure that this generated file |
| // is compatible with the proto package it is being compiled against. |
| // A compilation error at this line likely means your copy of the |
| // proto package needs to be updated. |
| const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package |
| |
| func (m *AllowedCSIDriver) Reset() { *m = AllowedCSIDriver{} } |
| func (*AllowedCSIDriver) ProtoMessage() {} |
| func (*AllowedCSIDriver) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{0} |
| } |
| func (m *AllowedCSIDriver) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *AllowedCSIDriver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *AllowedCSIDriver) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllowedCSIDriver.Merge(m, src) |
| } |
| func (m *AllowedCSIDriver) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *AllowedCSIDriver) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllowedCSIDriver.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllowedCSIDriver proto.InternalMessageInfo |
| |
| func (m *AllowedFlexVolume) Reset() { *m = AllowedFlexVolume{} } |
| func (*AllowedFlexVolume) ProtoMessage() {} |
| func (*AllowedFlexVolume) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{1} |
| } |
| func (m *AllowedFlexVolume) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *AllowedFlexVolume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *AllowedFlexVolume) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllowedFlexVolume.Merge(m, src) |
| } |
| func (m *AllowedFlexVolume) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *AllowedFlexVolume) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllowedFlexVolume.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllowedFlexVolume proto.InternalMessageInfo |
| |
| func (m *AllowedHostPath) Reset() { *m = AllowedHostPath{} } |
| func (*AllowedHostPath) ProtoMessage() {} |
| func (*AllowedHostPath) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{2} |
| } |
| func (m *AllowedHostPath) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *AllowedHostPath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *AllowedHostPath) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllowedHostPath.Merge(m, src) |
| } |
| func (m *AllowedHostPath) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *AllowedHostPath) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllowedHostPath.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllowedHostPath proto.InternalMessageInfo |
| |
| func (m *DaemonSet) Reset() { *m = DaemonSet{} } |
| func (*DaemonSet) ProtoMessage() {} |
| func (*DaemonSet) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{3} |
| } |
| func (m *DaemonSet) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DaemonSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DaemonSet) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DaemonSet.Merge(m, src) |
| } |
| func (m *DaemonSet) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DaemonSet) XXX_DiscardUnknown() { |
| xxx_messageInfo_DaemonSet.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DaemonSet proto.InternalMessageInfo |
| |
| func (m *DaemonSetCondition) Reset() { *m = DaemonSetCondition{} } |
| func (*DaemonSetCondition) ProtoMessage() {} |
| func (*DaemonSetCondition) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{4} |
| } |
| func (m *DaemonSetCondition) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DaemonSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DaemonSetCondition) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DaemonSetCondition.Merge(m, src) |
| } |
| func (m *DaemonSetCondition) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DaemonSetCondition) XXX_DiscardUnknown() { |
| xxx_messageInfo_DaemonSetCondition.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DaemonSetCondition proto.InternalMessageInfo |
| |
| func (m *DaemonSetList) Reset() { *m = DaemonSetList{} } |
| func (*DaemonSetList) ProtoMessage() {} |
| func (*DaemonSetList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{5} |
| } |
| func (m *DaemonSetList) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DaemonSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DaemonSetList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DaemonSetList.Merge(m, src) |
| } |
| func (m *DaemonSetList) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DaemonSetList) XXX_DiscardUnknown() { |
| xxx_messageInfo_DaemonSetList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DaemonSetList proto.InternalMessageInfo |
| |
| func (m *DaemonSetSpec) Reset() { *m = DaemonSetSpec{} } |
| func (*DaemonSetSpec) ProtoMessage() {} |
| func (*DaemonSetSpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{6} |
| } |
| func (m *DaemonSetSpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DaemonSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DaemonSetSpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DaemonSetSpec.Merge(m, src) |
| } |
| func (m *DaemonSetSpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DaemonSetSpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_DaemonSetSpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DaemonSetSpec proto.InternalMessageInfo |
| |
| func (m *DaemonSetStatus) Reset() { *m = DaemonSetStatus{} } |
| func (*DaemonSetStatus) ProtoMessage() {} |
| func (*DaemonSetStatus) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{7} |
| } |
| func (m *DaemonSetStatus) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DaemonSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DaemonSetStatus) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DaemonSetStatus.Merge(m, src) |
| } |
| func (m *DaemonSetStatus) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DaemonSetStatus) XXX_DiscardUnknown() { |
| xxx_messageInfo_DaemonSetStatus.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DaemonSetStatus proto.InternalMessageInfo |
| |
| func (m *DaemonSetUpdateStrategy) Reset() { *m = DaemonSetUpdateStrategy{} } |
| func (*DaemonSetUpdateStrategy) ProtoMessage() {} |
| func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{8} |
| } |
| func (m *DaemonSetUpdateStrategy) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DaemonSetUpdateStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DaemonSetUpdateStrategy) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DaemonSetUpdateStrategy.Merge(m, src) |
| } |
| func (m *DaemonSetUpdateStrategy) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DaemonSetUpdateStrategy) XXX_DiscardUnknown() { |
| xxx_messageInfo_DaemonSetUpdateStrategy.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DaemonSetUpdateStrategy proto.InternalMessageInfo |
| |
| func (m *Deployment) Reset() { *m = Deployment{} } |
| func (*Deployment) ProtoMessage() {} |
| func (*Deployment) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{9} |
| } |
| func (m *Deployment) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Deployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Deployment) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Deployment.Merge(m, src) |
| } |
| func (m *Deployment) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Deployment) XXX_DiscardUnknown() { |
| xxx_messageInfo_Deployment.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Deployment proto.InternalMessageInfo |
| |
| func (m *DeploymentCondition) Reset() { *m = DeploymentCondition{} } |
| func (*DeploymentCondition) ProtoMessage() {} |
| func (*DeploymentCondition) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{10} |
| } |
| func (m *DeploymentCondition) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DeploymentCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DeploymentCondition) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DeploymentCondition.Merge(m, src) |
| } |
| func (m *DeploymentCondition) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DeploymentCondition) XXX_DiscardUnknown() { |
| xxx_messageInfo_DeploymentCondition.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DeploymentCondition proto.InternalMessageInfo |
| |
| func (m *DeploymentList) Reset() { *m = DeploymentList{} } |
| func (*DeploymentList) ProtoMessage() {} |
| func (*DeploymentList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{11} |
| } |
| func (m *DeploymentList) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DeploymentList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DeploymentList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DeploymentList.Merge(m, src) |
| } |
| func (m *DeploymentList) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DeploymentList) XXX_DiscardUnknown() { |
| xxx_messageInfo_DeploymentList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DeploymentList proto.InternalMessageInfo |
| |
| func (m *DeploymentRollback) Reset() { *m = DeploymentRollback{} } |
| func (*DeploymentRollback) ProtoMessage() {} |
| func (*DeploymentRollback) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{12} |
| } |
| func (m *DeploymentRollback) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DeploymentRollback) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DeploymentRollback) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DeploymentRollback.Merge(m, src) |
| } |
| func (m *DeploymentRollback) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DeploymentRollback) XXX_DiscardUnknown() { |
| xxx_messageInfo_DeploymentRollback.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DeploymentRollback proto.InternalMessageInfo |
| |
| func (m *DeploymentSpec) Reset() { *m = DeploymentSpec{} } |
| func (*DeploymentSpec) ProtoMessage() {} |
| func (*DeploymentSpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{13} |
| } |
| func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DeploymentSpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DeploymentSpec.Merge(m, src) |
| } |
| func (m *DeploymentSpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DeploymentSpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_DeploymentSpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo |
| |
| func (m *DeploymentStatus) Reset() { *m = DeploymentStatus{} } |
| func (*DeploymentStatus) ProtoMessage() {} |
| func (*DeploymentStatus) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{14} |
| } |
| func (m *DeploymentStatus) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DeploymentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DeploymentStatus) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DeploymentStatus.Merge(m, src) |
| } |
| func (m *DeploymentStatus) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DeploymentStatus) XXX_DiscardUnknown() { |
| xxx_messageInfo_DeploymentStatus.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DeploymentStatus proto.InternalMessageInfo |
| |
| func (m *DeploymentStrategy) Reset() { *m = DeploymentStrategy{} } |
| func (*DeploymentStrategy) ProtoMessage() {} |
| func (*DeploymentStrategy) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{15} |
| } |
| func (m *DeploymentStrategy) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *DeploymentStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *DeploymentStrategy) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_DeploymentStrategy.Merge(m, src) |
| } |
| func (m *DeploymentStrategy) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *DeploymentStrategy) XXX_DiscardUnknown() { |
| xxx_messageInfo_DeploymentStrategy.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_DeploymentStrategy proto.InternalMessageInfo |
| |
| func (m *FSGroupStrategyOptions) Reset() { *m = FSGroupStrategyOptions{} } |
| func (*FSGroupStrategyOptions) ProtoMessage() {} |
| func (*FSGroupStrategyOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{16} |
| } |
| func (m *FSGroupStrategyOptions) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *FSGroupStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *FSGroupStrategyOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_FSGroupStrategyOptions.Merge(m, src) |
| } |
| func (m *FSGroupStrategyOptions) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *FSGroupStrategyOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_FSGroupStrategyOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_FSGroupStrategyOptions proto.InternalMessageInfo |
| |
| func (m *HTTPIngressPath) Reset() { *m = HTTPIngressPath{} } |
| func (*HTTPIngressPath) ProtoMessage() {} |
| func (*HTTPIngressPath) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{17} |
| } |
| func (m *HTTPIngressPath) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *HTTPIngressPath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *HTTPIngressPath) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_HTTPIngressPath.Merge(m, src) |
| } |
| func (m *HTTPIngressPath) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *HTTPIngressPath) XXX_DiscardUnknown() { |
| xxx_messageInfo_HTTPIngressPath.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_HTTPIngressPath proto.InternalMessageInfo |
| |
| func (m *HTTPIngressRuleValue) Reset() { *m = HTTPIngressRuleValue{} } |
| func (*HTTPIngressRuleValue) ProtoMessage() {} |
| func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{18} |
| } |
| func (m *HTTPIngressRuleValue) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *HTTPIngressRuleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *HTTPIngressRuleValue) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_HTTPIngressRuleValue.Merge(m, src) |
| } |
| func (m *HTTPIngressRuleValue) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *HTTPIngressRuleValue) XXX_DiscardUnknown() { |
| xxx_messageInfo_HTTPIngressRuleValue.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_HTTPIngressRuleValue proto.InternalMessageInfo |
| |
| func (m *HostPortRange) Reset() { *m = HostPortRange{} } |
| func (*HostPortRange) ProtoMessage() {} |
| func (*HostPortRange) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{19} |
| } |
| func (m *HostPortRange) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *HostPortRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *HostPortRange) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_HostPortRange.Merge(m, src) |
| } |
| func (m *HostPortRange) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *HostPortRange) XXX_DiscardUnknown() { |
| xxx_messageInfo_HostPortRange.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_HostPortRange proto.InternalMessageInfo |
| |
| func (m *IDRange) Reset() { *m = IDRange{} } |
| func (*IDRange) ProtoMessage() {} |
| func (*IDRange) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{20} |
| } |
| func (m *IDRange) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IDRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IDRange) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IDRange.Merge(m, src) |
| } |
| func (m *IDRange) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IDRange) XXX_DiscardUnknown() { |
| xxx_messageInfo_IDRange.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IDRange proto.InternalMessageInfo |
| |
| func (m *IPBlock) Reset() { *m = IPBlock{} } |
| func (*IPBlock) ProtoMessage() {} |
| func (*IPBlock) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{21} |
| } |
| func (m *IPBlock) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IPBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IPBlock) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IPBlock.Merge(m, src) |
| } |
| func (m *IPBlock) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IPBlock) XXX_DiscardUnknown() { |
| xxx_messageInfo_IPBlock.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IPBlock proto.InternalMessageInfo |
| |
| func (m *Ingress) Reset() { *m = Ingress{} } |
| func (*Ingress) ProtoMessage() {} |
| func (*Ingress) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{22} |
| } |
| func (m *Ingress) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Ingress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Ingress) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Ingress.Merge(m, src) |
| } |
| func (m *Ingress) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Ingress) XXX_DiscardUnknown() { |
| xxx_messageInfo_Ingress.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Ingress proto.InternalMessageInfo |
| |
| func (m *IngressBackend) Reset() { *m = IngressBackend{} } |
| func (*IngressBackend) ProtoMessage() {} |
| func (*IngressBackend) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{23} |
| } |
| func (m *IngressBackend) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressBackend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressBackend) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressBackend.Merge(m, src) |
| } |
| func (m *IngressBackend) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressBackend) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressBackend.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressBackend proto.InternalMessageInfo |
| |
| func (m *IngressList) Reset() { *m = IngressList{} } |
| func (*IngressList) ProtoMessage() {} |
| func (*IngressList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{24} |
| } |
| func (m *IngressList) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressList.Merge(m, src) |
| } |
| func (m *IngressList) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressList) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressList proto.InternalMessageInfo |
| |
| func (m *IngressRule) Reset() { *m = IngressRule{} } |
| func (*IngressRule) ProtoMessage() {} |
| func (*IngressRule) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{25} |
| } |
| func (m *IngressRule) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressRule) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressRule.Merge(m, src) |
| } |
| func (m *IngressRule) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressRule) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressRule.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressRule proto.InternalMessageInfo |
| |
| func (m *IngressRuleValue) Reset() { *m = IngressRuleValue{} } |
| func (*IngressRuleValue) ProtoMessage() {} |
| func (*IngressRuleValue) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{26} |
| } |
| func (m *IngressRuleValue) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressRuleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressRuleValue) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressRuleValue.Merge(m, src) |
| } |
| func (m *IngressRuleValue) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressRuleValue) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressRuleValue.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressRuleValue proto.InternalMessageInfo |
| |
| func (m *IngressSpec) Reset() { *m = IngressSpec{} } |
| func (*IngressSpec) ProtoMessage() {} |
| func (*IngressSpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{27} |
| } |
| func (m *IngressSpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressSpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressSpec.Merge(m, src) |
| } |
| func (m *IngressSpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressSpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressSpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressSpec proto.InternalMessageInfo |
| |
| func (m *IngressStatus) Reset() { *m = IngressStatus{} } |
| func (*IngressStatus) ProtoMessage() {} |
| func (*IngressStatus) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{28} |
| } |
| func (m *IngressStatus) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressStatus) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressStatus.Merge(m, src) |
| } |
| func (m *IngressStatus) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressStatus) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressStatus.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressStatus proto.InternalMessageInfo |
| |
| func (m *IngressTLS) Reset() { *m = IngressTLS{} } |
| func (*IngressTLS) ProtoMessage() {} |
| func (*IngressTLS) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{29} |
| } |
| func (m *IngressTLS) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *IngressTLS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *IngressTLS) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_IngressTLS.Merge(m, src) |
| } |
| func (m *IngressTLS) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *IngressTLS) XXX_DiscardUnknown() { |
| xxx_messageInfo_IngressTLS.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_IngressTLS proto.InternalMessageInfo |
| |
| func (m *NetworkPolicy) Reset() { *m = NetworkPolicy{} } |
| func (*NetworkPolicy) ProtoMessage() {} |
| func (*NetworkPolicy) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{30} |
| } |
| func (m *NetworkPolicy) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicy) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicy.Merge(m, src) |
| } |
| func (m *NetworkPolicy) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicy) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicy.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicy proto.InternalMessageInfo |
| |
| func (m *NetworkPolicyEgressRule) Reset() { *m = NetworkPolicyEgressRule{} } |
| func (*NetworkPolicyEgressRule) ProtoMessage() {} |
| func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{31} |
| } |
| func (m *NetworkPolicyEgressRule) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicyEgressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicyEgressRule) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicyEgressRule.Merge(m, src) |
| } |
| func (m *NetworkPolicyEgressRule) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicyEgressRule) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicyEgressRule.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicyEgressRule proto.InternalMessageInfo |
| |
| func (m *NetworkPolicyIngressRule) Reset() { *m = NetworkPolicyIngressRule{} } |
| func (*NetworkPolicyIngressRule) ProtoMessage() {} |
| func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{32} |
| } |
| func (m *NetworkPolicyIngressRule) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicyIngressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicyIngressRule) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicyIngressRule.Merge(m, src) |
| } |
| func (m *NetworkPolicyIngressRule) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicyIngressRule) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicyIngressRule.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicyIngressRule proto.InternalMessageInfo |
| |
| func (m *NetworkPolicyList) Reset() { *m = NetworkPolicyList{} } |
| func (*NetworkPolicyList) ProtoMessage() {} |
| func (*NetworkPolicyList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{33} |
| } |
| func (m *NetworkPolicyList) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicyList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicyList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicyList.Merge(m, src) |
| } |
| func (m *NetworkPolicyList) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicyList) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicyList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicyList proto.InternalMessageInfo |
| |
| func (m *NetworkPolicyPeer) Reset() { *m = NetworkPolicyPeer{} } |
| func (*NetworkPolicyPeer) ProtoMessage() {} |
| func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{34} |
| } |
| func (m *NetworkPolicyPeer) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicyPeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicyPeer) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicyPeer.Merge(m, src) |
| } |
| func (m *NetworkPolicyPeer) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicyPeer) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicyPeer.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicyPeer proto.InternalMessageInfo |
| |
| func (m *NetworkPolicyPort) Reset() { *m = NetworkPolicyPort{} } |
| func (*NetworkPolicyPort) ProtoMessage() {} |
| func (*NetworkPolicyPort) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{35} |
| } |
| func (m *NetworkPolicyPort) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicyPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicyPort) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicyPort.Merge(m, src) |
| } |
| func (m *NetworkPolicyPort) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicyPort) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicyPort.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicyPort proto.InternalMessageInfo |
| |
| func (m *NetworkPolicySpec) Reset() { *m = NetworkPolicySpec{} } |
| func (*NetworkPolicySpec) ProtoMessage() {} |
| func (*NetworkPolicySpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{36} |
| } |
| func (m *NetworkPolicySpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *NetworkPolicySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *NetworkPolicySpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NetworkPolicySpec.Merge(m, src) |
| } |
| func (m *NetworkPolicySpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *NetworkPolicySpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_NetworkPolicySpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NetworkPolicySpec proto.InternalMessageInfo |
| |
| func (m *PodSecurityPolicy) Reset() { *m = PodSecurityPolicy{} } |
| func (*PodSecurityPolicy) ProtoMessage() {} |
| func (*PodSecurityPolicy) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{37} |
| } |
| func (m *PodSecurityPolicy) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *PodSecurityPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *PodSecurityPolicy) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_PodSecurityPolicy.Merge(m, src) |
| } |
| func (m *PodSecurityPolicy) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *PodSecurityPolicy) XXX_DiscardUnknown() { |
| xxx_messageInfo_PodSecurityPolicy.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_PodSecurityPolicy proto.InternalMessageInfo |
| |
| func (m *PodSecurityPolicyList) Reset() { *m = PodSecurityPolicyList{} } |
| func (*PodSecurityPolicyList) ProtoMessage() {} |
| func (*PodSecurityPolicyList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{38} |
| } |
| func (m *PodSecurityPolicyList) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *PodSecurityPolicyList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *PodSecurityPolicyList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_PodSecurityPolicyList.Merge(m, src) |
| } |
| func (m *PodSecurityPolicyList) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *PodSecurityPolicyList) XXX_DiscardUnknown() { |
| xxx_messageInfo_PodSecurityPolicyList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_PodSecurityPolicyList proto.InternalMessageInfo |
| |
| func (m *PodSecurityPolicySpec) Reset() { *m = PodSecurityPolicySpec{} } |
| func (*PodSecurityPolicySpec) ProtoMessage() {} |
| func (*PodSecurityPolicySpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{39} |
| } |
| func (m *PodSecurityPolicySpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *PodSecurityPolicySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *PodSecurityPolicySpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_PodSecurityPolicySpec.Merge(m, src) |
| } |
| func (m *PodSecurityPolicySpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *PodSecurityPolicySpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_PodSecurityPolicySpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_PodSecurityPolicySpec proto.InternalMessageInfo |
| |
| func (m *ReplicaSet) Reset() { *m = ReplicaSet{} } |
| func (*ReplicaSet) ProtoMessage() {} |
| func (*ReplicaSet) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{40} |
| } |
| func (m *ReplicaSet) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ReplicaSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ReplicaSet) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ReplicaSet.Merge(m, src) |
| } |
| func (m *ReplicaSet) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ReplicaSet) XXX_DiscardUnknown() { |
| xxx_messageInfo_ReplicaSet.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ReplicaSet proto.InternalMessageInfo |
| |
| func (m *ReplicaSetCondition) Reset() { *m = ReplicaSetCondition{} } |
| func (*ReplicaSetCondition) ProtoMessage() {} |
| func (*ReplicaSetCondition) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{41} |
| } |
| func (m *ReplicaSetCondition) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ReplicaSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ReplicaSetCondition) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ReplicaSetCondition.Merge(m, src) |
| } |
| func (m *ReplicaSetCondition) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ReplicaSetCondition) XXX_DiscardUnknown() { |
| xxx_messageInfo_ReplicaSetCondition.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ReplicaSetCondition proto.InternalMessageInfo |
| |
| func (m *ReplicaSetList) Reset() { *m = ReplicaSetList{} } |
| func (*ReplicaSetList) ProtoMessage() {} |
| func (*ReplicaSetList) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{42} |
| } |
| func (m *ReplicaSetList) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ReplicaSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ReplicaSetList) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ReplicaSetList.Merge(m, src) |
| } |
| func (m *ReplicaSetList) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ReplicaSetList) XXX_DiscardUnknown() { |
| xxx_messageInfo_ReplicaSetList.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ReplicaSetList proto.InternalMessageInfo |
| |
| func (m *ReplicaSetSpec) Reset() { *m = ReplicaSetSpec{} } |
| func (*ReplicaSetSpec) ProtoMessage() {} |
| func (*ReplicaSetSpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{43} |
| } |
| func (m *ReplicaSetSpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ReplicaSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ReplicaSetSpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ReplicaSetSpec.Merge(m, src) |
| } |
| func (m *ReplicaSetSpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ReplicaSetSpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_ReplicaSetSpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ReplicaSetSpec proto.InternalMessageInfo |
| |
| func (m *ReplicaSetStatus) Reset() { *m = ReplicaSetStatus{} } |
| func (*ReplicaSetStatus) ProtoMessage() {} |
| func (*ReplicaSetStatus) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{44} |
| } |
| func (m *ReplicaSetStatus) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ReplicaSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ReplicaSetStatus) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ReplicaSetStatus.Merge(m, src) |
| } |
| func (m *ReplicaSetStatus) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ReplicaSetStatus) XXX_DiscardUnknown() { |
| xxx_messageInfo_ReplicaSetStatus.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ReplicaSetStatus proto.InternalMessageInfo |
| |
| func (m *RollbackConfig) Reset() { *m = RollbackConfig{} } |
| func (*RollbackConfig) ProtoMessage() {} |
| func (*RollbackConfig) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{45} |
| } |
| func (m *RollbackConfig) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *RollbackConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *RollbackConfig) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RollbackConfig.Merge(m, src) |
| } |
| func (m *RollbackConfig) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *RollbackConfig) XXX_DiscardUnknown() { |
| xxx_messageInfo_RollbackConfig.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RollbackConfig proto.InternalMessageInfo |
| |
| func (m *RollingUpdateDaemonSet) Reset() { *m = RollingUpdateDaemonSet{} } |
| func (*RollingUpdateDaemonSet) ProtoMessage() {} |
| func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{46} |
| } |
| func (m *RollingUpdateDaemonSet) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *RollingUpdateDaemonSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *RollingUpdateDaemonSet) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RollingUpdateDaemonSet.Merge(m, src) |
| } |
| func (m *RollingUpdateDaemonSet) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *RollingUpdateDaemonSet) XXX_DiscardUnknown() { |
| xxx_messageInfo_RollingUpdateDaemonSet.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RollingUpdateDaemonSet proto.InternalMessageInfo |
| |
| func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} } |
| func (*RollingUpdateDeployment) ProtoMessage() {} |
| func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{47} |
| } |
| func (m *RollingUpdateDeployment) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *RollingUpdateDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *RollingUpdateDeployment) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RollingUpdateDeployment.Merge(m, src) |
| } |
| func (m *RollingUpdateDeployment) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *RollingUpdateDeployment) XXX_DiscardUnknown() { |
| xxx_messageInfo_RollingUpdateDeployment.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RollingUpdateDeployment proto.InternalMessageInfo |
| |
| func (m *RunAsGroupStrategyOptions) Reset() { *m = RunAsGroupStrategyOptions{} } |
| func (*RunAsGroupStrategyOptions) ProtoMessage() {} |
| func (*RunAsGroupStrategyOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{48} |
| } |
| func (m *RunAsGroupStrategyOptions) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *RunAsGroupStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *RunAsGroupStrategyOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RunAsGroupStrategyOptions.Merge(m, src) |
| } |
| func (m *RunAsGroupStrategyOptions) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *RunAsGroupStrategyOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_RunAsGroupStrategyOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RunAsGroupStrategyOptions proto.InternalMessageInfo |
| |
| func (m *RunAsUserStrategyOptions) Reset() { *m = RunAsUserStrategyOptions{} } |
| func (*RunAsUserStrategyOptions) ProtoMessage() {} |
| func (*RunAsUserStrategyOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{49} |
| } |
| func (m *RunAsUserStrategyOptions) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *RunAsUserStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *RunAsUserStrategyOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RunAsUserStrategyOptions.Merge(m, src) |
| } |
| func (m *RunAsUserStrategyOptions) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *RunAsUserStrategyOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_RunAsUserStrategyOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RunAsUserStrategyOptions proto.InternalMessageInfo |
| |
| func (m *RuntimeClassStrategyOptions) Reset() { *m = RuntimeClassStrategyOptions{} } |
| func (*RuntimeClassStrategyOptions) ProtoMessage() {} |
| func (*RuntimeClassStrategyOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{50} |
| } |
| func (m *RuntimeClassStrategyOptions) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *RuntimeClassStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *RuntimeClassStrategyOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RuntimeClassStrategyOptions.Merge(m, src) |
| } |
| func (m *RuntimeClassStrategyOptions) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *RuntimeClassStrategyOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_RuntimeClassStrategyOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RuntimeClassStrategyOptions proto.InternalMessageInfo |
| |
| func (m *SELinuxStrategyOptions) Reset() { *m = SELinuxStrategyOptions{} } |
| func (*SELinuxStrategyOptions) ProtoMessage() {} |
| func (*SELinuxStrategyOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{51} |
| } |
| func (m *SELinuxStrategyOptions) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *SELinuxStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *SELinuxStrategyOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SELinuxStrategyOptions.Merge(m, src) |
| } |
| func (m *SELinuxStrategyOptions) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *SELinuxStrategyOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_SELinuxStrategyOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SELinuxStrategyOptions proto.InternalMessageInfo |
| |
| func (m *Scale) Reset() { *m = Scale{} } |
| func (*Scale) ProtoMessage() {} |
| func (*Scale) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{52} |
| } |
| func (m *Scale) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *Scale) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *Scale) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Scale.Merge(m, src) |
| } |
| func (m *Scale) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *Scale) XXX_DiscardUnknown() { |
| xxx_messageInfo_Scale.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Scale proto.InternalMessageInfo |
| |
| func (m *ScaleSpec) Reset() { *m = ScaleSpec{} } |
| func (*ScaleSpec) ProtoMessage() {} |
| func (*ScaleSpec) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{53} |
| } |
| func (m *ScaleSpec) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ScaleSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ScaleSpec) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ScaleSpec.Merge(m, src) |
| } |
| func (m *ScaleSpec) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ScaleSpec) XXX_DiscardUnknown() { |
| xxx_messageInfo_ScaleSpec.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ScaleSpec proto.InternalMessageInfo |
| |
| func (m *ScaleStatus) Reset() { *m = ScaleStatus{} } |
| func (*ScaleStatus) ProtoMessage() {} |
| func (*ScaleStatus) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{54} |
| } |
| func (m *ScaleStatus) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *ScaleStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *ScaleStatus) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ScaleStatus.Merge(m, src) |
| } |
| func (m *ScaleStatus) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *ScaleStatus) XXX_DiscardUnknown() { |
| xxx_messageInfo_ScaleStatus.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ScaleStatus proto.InternalMessageInfo |
| |
| func (m *SupplementalGroupsStrategyOptions) Reset() { *m = SupplementalGroupsStrategyOptions{} } |
| func (*SupplementalGroupsStrategyOptions) ProtoMessage() {} |
| func (*SupplementalGroupsStrategyOptions) Descriptor() ([]byte, []int) { |
| return fileDescriptor_cdc93917efc28165, []int{55} |
| } |
| func (m *SupplementalGroupsStrategyOptions) XXX_Unmarshal(b []byte) error { |
| return m.Unmarshal(b) |
| } |
| func (m *SupplementalGroupsStrategyOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| b = b[:cap(b)] |
| n, err := m.MarshalToSizedBuffer(b) |
| if err != nil { |
| return nil, err |
| } |
| return b[:n], nil |
| } |
| func (m *SupplementalGroupsStrategyOptions) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SupplementalGroupsStrategyOptions.Merge(m, src) |
| } |
| func (m *SupplementalGroupsStrategyOptions) XXX_Size() int { |
| return m.Size() |
| } |
| func (m *SupplementalGroupsStrategyOptions) XXX_DiscardUnknown() { |
| xxx_messageInfo_SupplementalGroupsStrategyOptions.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SupplementalGroupsStrategyOptions proto.InternalMessageInfo |
| |
| func init() { |
| proto.RegisterType((*AllowedCSIDriver)(nil), "k8s.io.api.extensions.v1beta1.AllowedCSIDriver") |
| proto.RegisterType((*AllowedFlexVolume)(nil), "k8s.io.api.extensions.v1beta1.AllowedFlexVolume") |
| proto.RegisterType((*AllowedHostPath)(nil), "k8s.io.api.extensions.v1beta1.AllowedHostPath") |
| proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet") |
| proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition") |
| proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList") |
| proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec") |
| proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus") |
| proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy") |
| proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment") |
| proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition") |
| proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList") |
| proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback") |
| proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback.UpdatedAnnotationsEntry") |
| proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec") |
| proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus") |
| proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy") |
| proto.RegisterType((*FSGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.FSGroupStrategyOptions") |
| proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath") |
| proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue") |
| proto.RegisterType((*HostPortRange)(nil), "k8s.io.api.extensions.v1beta1.HostPortRange") |
| proto.RegisterType((*IDRange)(nil), "k8s.io.api.extensions.v1beta1.IDRange") |
| proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock") |
| proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress") |
| proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend") |
| proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList") |
| proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule") |
| proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue") |
| proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec") |
| proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus") |
| proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS") |
| proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy") |
| proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule") |
| proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule") |
| proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList") |
| proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer") |
| proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort") |
| proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec") |
| proto.RegisterType((*PodSecurityPolicy)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicy") |
| proto.RegisterType((*PodSecurityPolicyList)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicyList") |
| proto.RegisterType((*PodSecurityPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.PodSecurityPolicySpec") |
| proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet") |
| proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition") |
| proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList") |
| proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec") |
| proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus") |
| proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig") |
| proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet") |
| proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment") |
| proto.RegisterType((*RunAsGroupStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsGroupStrategyOptions") |
| proto.RegisterType((*RunAsUserStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RunAsUserStrategyOptions") |
| proto.RegisterType((*RuntimeClassStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.RuntimeClassStrategyOptions") |
| proto.RegisterType((*SELinuxStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SELinuxStrategyOptions") |
| proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale") |
| proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec") |
| proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus") |
| proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus.SelectorEntry") |
| proto.RegisterType((*SupplementalGroupsStrategyOptions)(nil), "k8s.io.api.extensions.v1beta1.SupplementalGroupsStrategyOptions") |
| } |
| |
| func init() { |
| proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptor_cdc93917efc28165) |
| } |
| |
| var fileDescriptor_cdc93917efc28165 = []byte{ |
| // 3743 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x4d, 0x6c, 0x1c, 0xc7, |
| 0x72, 0xd6, 0xec, 0x2e, 0xb9, 0xcb, 0xe2, 0x7f, 0x93, 0x22, 0xf7, 0x49, 0x4f, 0x5c, 0xbd, 0x31, |
| 0xa0, 0xc8, 0x8e, 0xb4, 0x6b, 0xc9, 0x92, 0x9e, 0x22, 0x21, 0xef, 0x99, 0x4b, 0x8a, 0x12, 0x5f, |
| 0xf8, 0xb3, 0xee, 0x25, 0x65, 0xc3, 0x88, 0x1d, 0x0f, 0x77, 0x9b, 0xcb, 0x11, 0x67, 0x67, 0xc6, |
| 0xd3, 0xb3, 0x34, 0x17, 0xc8, 0x21, 0x87, 0x20, 0x80, 0x81, 0x00, 0xc9, 0xc5, 0x49, 0x8e, 0x31, |
| 0x02, 0xe4, 0x94, 0x20, 0xc7, 0xe4, 0x60, 0x18, 0x09, 0xe2, 0x00, 0x42, 0xe0, 0x04, 0xbe, 0xc5, |
| 0x27, 0x22, 0xa6, 0x4f, 0x41, 0x4e, 0xb9, 0x05, 0x3a, 0x05, 0xdd, 0xd3, 0xf3, 0x3f, 0xc3, 0x1d, |
| 0xd2, 0x12, 0x11, 0x03, 0xef, 0x24, 0x6e, 0x57, 0xd5, 0x57, 0xd5, 0xdd, 0xd5, 0x55, 0xd5, 0x3d, |
| 0x25, 0x58, 0xd9, 0xbf, 0x4f, 0xab, 0xaa, 0x51, 0xdb, 0xef, 0xed, 0x10, 0x4b, 0x27, 0x36, 0xa1, |
| 0xb5, 0x03, 0xa2, 0xb7, 0x0d, 0xab, 0x26, 0x08, 0x8a, 0xa9, 0xd6, 0xc8, 0xa1, 0x4d, 0x74, 0xaa, |
| 0x1a, 0x3a, 0xad, 0x1d, 0xdc, 0xda, 0x21, 0xb6, 0x72, 0xab, 0xd6, 0x21, 0x3a, 0xb1, 0x14, 0x9b, |
| 0xb4, 0xab, 0xa6, 0x65, 0xd8, 0x06, 0xba, 0xe2, 0xb0, 0x57, 0x15, 0x53, 0xad, 0xfa, 0xec, 0x55, |
| 0xc1, 0x7e, 0xe9, 0x66, 0x47, 0xb5, 0xf7, 0x7a, 0x3b, 0xd5, 0x96, 0xd1, 0xad, 0x75, 0x8c, 0x8e, |
| 0x51, 0xe3, 0x52, 0x3b, 0xbd, 0x5d, 0xfe, 0x8b, 0xff, 0xe0, 0x7f, 0x39, 0x68, 0x97, 0xe4, 0x80, |
| 0xf2, 0x96, 0x61, 0x91, 0xda, 0x41, 0x4c, 0xe3, 0xa5, 0x3b, 0x3e, 0x4f, 0x57, 0x69, 0xed, 0xa9, |
| 0x3a, 0xb1, 0xfa, 0x35, 0x73, 0xbf, 0xc3, 0x06, 0x68, 0xad, 0x4b, 0x6c, 0x25, 0x49, 0xaa, 0x96, |
| 0x26, 0x65, 0xf5, 0x74, 0x5b, 0xed, 0x92, 0x98, 0xc0, 0xbd, 0x41, 0x02, 0xb4, 0xb5, 0x47, 0xba, |
| 0x4a, 0x4c, 0xee, 0xad, 0x34, 0xb9, 0x9e, 0xad, 0x6a, 0x35, 0x55, 0xb7, 0xa9, 0x6d, 0x45, 0x85, |
| 0xe4, 0x3b, 0x30, 0xb5, 0xa8, 0x69, 0xc6, 0x27, 0xa4, 0xbd, 0xd4, 0x5c, 0x5d, 0xb6, 0xd4, 0x03, |
| 0x62, 0xa1, 0xab, 0x50, 0xd0, 0x95, 0x2e, 0x29, 0x4b, 0x57, 0xa5, 0xeb, 0x23, 0xf5, 0xb1, 0xe7, |
| 0x47, 0x95, 0x0b, 0xc7, 0x47, 0x95, 0xc2, 0x86, 0xd2, 0x25, 0x98, 0x53, 0xe4, 0x87, 0x30, 0x2d, |
| 0xa4, 0x56, 0x34, 0x72, 0xf8, 0xd4, 0xd0, 0x7a, 0x5d, 0x82, 0xae, 0xc1, 0x70, 0x9b, 0x03, 0x08, |
| 0xc1, 0x09, 0x21, 0x38, 0xec, 0xc0, 0x62, 0x41, 0x95, 0x29, 0x4c, 0x0a, 0xe1, 0x27, 0x06, 0xb5, |
| 0x1b, 0x8a, 0xbd, 0x87, 0x6e, 0x03, 0x98, 0x8a, 0xbd, 0xd7, 0xb0, 0xc8, 0xae, 0x7a, 0x28, 0xc4, |
| 0x91, 0x10, 0x87, 0x86, 0x47, 0xc1, 0x01, 0x2e, 0x74, 0x03, 0x4a, 0x16, 0x51, 0xda, 0x9b, 0xba, |
| 0xd6, 0x2f, 0xe7, 0xae, 0x4a, 0xd7, 0x4b, 0xf5, 0x29, 0x21, 0x51, 0xc2, 0x62, 0x1c, 0x7b, 0x1c, |
| 0xf2, 0x67, 0x39, 0x18, 0x59, 0x56, 0x48, 0xd7, 0xd0, 0x9b, 0xc4, 0x46, 0x1f, 0x41, 0x89, 0x6d, |
| 0x57, 0x5b, 0xb1, 0x15, 0xae, 0x6d, 0xf4, 0xf6, 0x9b, 0x55, 0xdf, 0x9d, 0xbc, 0xd5, 0xab, 0x9a, |
| 0xfb, 0x1d, 0x36, 0x40, 0xab, 0x8c, 0xbb, 0x7a, 0x70, 0xab, 0xba, 0xb9, 0xf3, 0x8c, 0xb4, 0xec, |
| 0x75, 0x62, 0x2b, 0xbe, 0x7d, 0xfe, 0x18, 0xf6, 0x50, 0xd1, 0x06, 0x14, 0xa8, 0x49, 0x5a, 0xdc, |
| 0xb2, 0xd1, 0xdb, 0x37, 0xaa, 0x27, 0x3a, 0x6b, 0xd5, 0xb3, 0xac, 0x69, 0x92, 0x96, 0xbf, 0xe2, |
| 0xec, 0x17, 0xe6, 0x38, 0xe8, 0x29, 0x0c, 0x53, 0x5b, 0xb1, 0x7b, 0xb4, 0x9c, 0xe7, 0x88, 0xd5, |
| 0xcc, 0x88, 0x5c, 0xca, 0xdf, 0x0c, 0xe7, 0x37, 0x16, 0x68, 0xf2, 0x7f, 0xe5, 0x00, 0x79, 0xbc, |
| 0x4b, 0x86, 0xde, 0x56, 0x6d, 0xd5, 0xd0, 0xd1, 0x03, 0x28, 0xd8, 0x7d, 0xd3, 0x75, 0x81, 0x6b, |
| 0xae, 0x41, 0x5b, 0x7d, 0x93, 0xbc, 0x38, 0xaa, 0xcc, 0xc5, 0x25, 0x18, 0x05, 0x73, 0x19, 0xb4, |
| 0xe6, 0x99, 0x9a, 0xe3, 0xd2, 0x77, 0xc2, 0xaa, 0x5f, 0x1c, 0x55, 0x12, 0x0e, 0x5b, 0xd5, 0x43, |
| 0x0a, 0x1b, 0x88, 0x0e, 0x00, 0x69, 0x0a, 0xb5, 0xb7, 0x2c, 0x45, 0xa7, 0x8e, 0x26, 0xb5, 0x4b, |
| 0xc4, 0x22, 0xbc, 0x91, 0x6d, 0xd3, 0x98, 0x44, 0xfd, 0x92, 0xb0, 0x02, 0xad, 0xc5, 0xd0, 0x70, |
| 0x82, 0x06, 0xe6, 0xcd, 0x16, 0x51, 0xa8, 0xa1, 0x97, 0x0b, 0x61, 0x6f, 0xc6, 0x7c, 0x14, 0x0b, |
| 0x2a, 0x7a, 0x1d, 0x8a, 0x5d, 0x42, 0xa9, 0xd2, 0x21, 0xe5, 0x21, 0xce, 0x38, 0x29, 0x18, 0x8b, |
| 0xeb, 0xce, 0x30, 0x76, 0xe9, 0xf2, 0x17, 0x12, 0x8c, 0x7b, 0x2b, 0xb7, 0xa6, 0x52, 0x1b, 0xfd, |
| 0x6e, 0xcc, 0x0f, 0xab, 0xd9, 0xa6, 0xc4, 0xa4, 0xb9, 0x17, 0x7a, 0x3e, 0xef, 0x8e, 0x04, 0x7c, |
| 0x70, 0x1d, 0x86, 0x54, 0x9b, 0x74, 0xd9, 0x3e, 0xe4, 0xaf, 0x8f, 0xde, 0xbe, 0x9e, 0xd5, 0x65, |
| 0xea, 0xe3, 0x02, 0x74, 0x68, 0x95, 0x89, 0x63, 0x07, 0x45, 0xfe, 0xb3, 0x42, 0xc0, 0x7c, 0xe6, |
| 0x9a, 0xe8, 0x03, 0x28, 0x51, 0xa2, 0x91, 0x96, 0x6d, 0x58, 0xc2, 0xfc, 0xb7, 0x32, 0x9a, 0xaf, |
| 0xec, 0x10, 0xad, 0x29, 0x44, 0xeb, 0x63, 0xcc, 0x7e, 0xf7, 0x17, 0xf6, 0x20, 0xd1, 0x3b, 0x50, |
| 0xb2, 0x49, 0xd7, 0xd4, 0x14, 0x9b, 0x88, 0x73, 0xf4, 0x5a, 0x70, 0x0a, 0xcc, 0x73, 0x18, 0x58, |
| 0xc3, 0x68, 0x6f, 0x09, 0x36, 0x7e, 0x7c, 0xbc, 0x25, 0x71, 0x47, 0xb1, 0x07, 0x83, 0x0e, 0x60, |
| 0xa2, 0x67, 0xb6, 0x19, 0xa7, 0xcd, 0xa2, 0x60, 0xa7, 0x2f, 0x3c, 0xe9, 0x5e, 0xd6, 0xb5, 0xd9, |
| 0x0e, 0x49, 0xd7, 0xe7, 0x84, 0xae, 0x89, 0xf0, 0x38, 0x8e, 0x68, 0x41, 0x8b, 0x30, 0xd9, 0x55, |
| 0x75, 0x16, 0x97, 0xfa, 0x4d, 0xd2, 0x32, 0xf4, 0x36, 0xe5, 0x6e, 0x35, 0x54, 0x9f, 0x17, 0x00, |
| 0x93, 0xeb, 0x61, 0x32, 0x8e, 0xf2, 0xa3, 0x5f, 0x01, 0x72, 0xa7, 0xf1, 0xd8, 0x09, 0xe2, 0xaa, |
| 0xa1, 0x73, 0x9f, 0xcb, 0xfb, 0xce, 0xbd, 0x15, 0xe3, 0xc0, 0x09, 0x52, 0x68, 0x0d, 0x66, 0x2d, |
| 0x72, 0xa0, 0xb2, 0x39, 0x3e, 0x51, 0xa9, 0x6d, 0x58, 0xfd, 0x35, 0xb5, 0xab, 0xda, 0xe5, 0x61, |
| 0x6e, 0x53, 0xf9, 0xf8, 0xa8, 0x32, 0x8b, 0x13, 0xe8, 0x38, 0x51, 0x4a, 0xfe, 0xf3, 0x61, 0x98, |
| 0x8c, 0xc4, 0x1b, 0xf4, 0x14, 0xe6, 0x5a, 0x3d, 0xcb, 0x22, 0xba, 0xbd, 0xd1, 0xeb, 0xee, 0x10, |
| 0xab, 0xd9, 0xda, 0x23, 0xed, 0x9e, 0x46, 0xda, 0xdc, 0x51, 0x86, 0xea, 0x0b, 0xc2, 0xe2, 0xb9, |
| 0xa5, 0x44, 0x2e, 0x9c, 0x22, 0xcd, 0x56, 0x41, 0xe7, 0x43, 0xeb, 0x2a, 0xa5, 0x1e, 0x66, 0x8e, |
| 0x63, 0x7a, 0xab, 0xb0, 0x11, 0xe3, 0xc0, 0x09, 0x52, 0xcc, 0xc6, 0x36, 0xa1, 0xaa, 0x45, 0xda, |
| 0x51, 0x1b, 0xf3, 0x61, 0x1b, 0x97, 0x13, 0xb9, 0x70, 0x8a, 0x34, 0xba, 0x0b, 0xa3, 0x8e, 0x36, |
| 0xbe, 0x7f, 0x62, 0xa3, 0x67, 0x04, 0xd8, 0xe8, 0x86, 0x4f, 0xc2, 0x41, 0x3e, 0x36, 0x35, 0x63, |
| 0x87, 0x12, 0xeb, 0x80, 0xb4, 0xd3, 0x37, 0x78, 0x33, 0xc6, 0x81, 0x13, 0xa4, 0xd8, 0xd4, 0x1c, |
| 0x0f, 0x8c, 0x4d, 0x6d, 0x38, 0x3c, 0xb5, 0xed, 0x44, 0x2e, 0x9c, 0x22, 0xcd, 0xfc, 0xd8, 0x31, |
| 0x79, 0xf1, 0x40, 0x51, 0x35, 0x65, 0x47, 0x23, 0xe5, 0x62, 0xd8, 0x8f, 0x37, 0xc2, 0x64, 0x1c, |
| 0xe5, 0x47, 0x8f, 0x61, 0xda, 0x19, 0xda, 0xd6, 0x15, 0x0f, 0xa4, 0xc4, 0x41, 0x7e, 0x22, 0x40, |
| 0xa6, 0x37, 0xa2, 0x0c, 0x38, 0x2e, 0x83, 0x1e, 0xc0, 0x44, 0xcb, 0xd0, 0x34, 0xee, 0x8f, 0x4b, |
| 0x46, 0x4f, 0xb7, 0xcb, 0x23, 0x1c, 0x05, 0xb1, 0xf3, 0xb8, 0x14, 0xa2, 0xe0, 0x08, 0x27, 0x22, |
| 0x00, 0x2d, 0x37, 0xe1, 0xd0, 0x32, 0xf0, 0xf8, 0x78, 0x2b, 0x6b, 0x0c, 0xf0, 0x52, 0x95, 0x5f, |
| 0x03, 0x78, 0x43, 0x14, 0x07, 0x80, 0xe5, 0x7f, 0x95, 0x60, 0x3e, 0x25, 0x74, 0xa0, 0x5f, 0x86, |
| 0x52, 0xec, 0x6f, 0x46, 0x52, 0xec, 0xe5, 0x14, 0xb1, 0x40, 0x9e, 0xd5, 0x61, 0xdc, 0x62, 0xb3, |
| 0xd2, 0x3b, 0x0e, 0x8b, 0x88, 0x91, 0x77, 0x07, 0x4c, 0x03, 0x07, 0x65, 0xfc, 0x98, 0x3f, 0x7d, |
| 0x7c, 0x54, 0x19, 0x0f, 0xd1, 0x70, 0x18, 0x5e, 0xfe, 0x8b, 0x1c, 0xc0, 0x32, 0x31, 0x35, 0xa3, |
| 0xdf, 0x25, 0xfa, 0x79, 0xd4, 0x50, 0x9b, 0xa1, 0x1a, 0xea, 0xe6, 0xa0, 0xed, 0xf1, 0x4c, 0x4b, |
| 0x2d, 0xa2, 0xde, 0x8d, 0x14, 0x51, 0xb5, 0xec, 0x90, 0x27, 0x57, 0x51, 0xff, 0x91, 0x87, 0x19, |
| 0x9f, 0xd9, 0x2f, 0xa3, 0x1e, 0x86, 0xf6, 0xf8, 0x37, 0x22, 0x7b, 0x3c, 0x9f, 0x20, 0xf2, 0xca, |
| 0xea, 0xa8, 0x67, 0x30, 0xc1, 0xaa, 0x1c, 0x67, 0x2f, 0x79, 0x0d, 0x35, 0x7c, 0xea, 0x1a, 0xca, |
| 0xcb, 0x76, 0x6b, 0x21, 0x24, 0x1c, 0x41, 0x4e, 0xa9, 0xd9, 0x8a, 0x3f, 0xc6, 0x9a, 0xed, 0x4b, |
| 0x09, 0x26, 0xfc, 0x6d, 0x3a, 0x87, 0xa2, 0x6d, 0x23, 0x5c, 0xb4, 0xbd, 0x9e, 0xd9, 0x45, 0x53, |
| 0xaa, 0xb6, 0xff, 0x65, 0x05, 0xbe, 0xc7, 0xc4, 0x0e, 0xf8, 0x8e, 0xd2, 0xda, 0x1f, 0x7c, 0xc7, |
| 0x43, 0x9f, 0x49, 0x80, 0x44, 0x16, 0x58, 0xd4, 0x75, 0xc3, 0x56, 0x9c, 0x58, 0xe9, 0x98, 0xb5, |
| 0x9a, 0xd9, 0x2c, 0x57, 0x63, 0x75, 0x3b, 0x86, 0xf5, 0x48, 0xb7, 0xad, 0xbe, 0xbf, 0xc9, 0x71, |
| 0x06, 0x9c, 0x60, 0x00, 0x52, 0x00, 0x2c, 0x81, 0xb9, 0x65, 0x88, 0x83, 0x7c, 0x33, 0x43, 0xcc, |
| 0x63, 0x02, 0x4b, 0x86, 0xbe, 0xab, 0x76, 0xfc, 0xb0, 0x83, 0x3d, 0x20, 0x1c, 0x00, 0xbd, 0xf4, |
| 0x08, 0xe6, 0x53, 0xac, 0x45, 0x53, 0x90, 0xdf, 0x27, 0x7d, 0x67, 0xd9, 0x30, 0xfb, 0x13, 0xcd, |
| 0xc2, 0xd0, 0x81, 0xa2, 0xf5, 0x9c, 0xf0, 0x3b, 0x82, 0x9d, 0x1f, 0x0f, 0x72, 0xf7, 0x25, 0xf9, |
| 0x8b, 0xa1, 0xa0, 0xef, 0xf0, 0x8a, 0xf9, 0x3a, 0xbb, 0xb4, 0x9a, 0x9a, 0xda, 0x52, 0xa8, 0x28, |
| 0x84, 0xc6, 0x9c, 0x0b, 0xab, 0x33, 0x86, 0x3d, 0x6a, 0xa8, 0xb6, 0xce, 0xbd, 0xda, 0xda, 0x3a, |
| 0xff, 0x72, 0x6a, 0xeb, 0xdf, 0x83, 0x12, 0x75, 0xab, 0xea, 0x02, 0x87, 0xbc, 0x75, 0x8a, 0xf8, |
| 0x2a, 0x0a, 0x6a, 0x4f, 0x81, 0x57, 0x4a, 0x7b, 0xa0, 0x49, 0x45, 0xf4, 0xd0, 0x29, 0x8b, 0xe8, |
| 0x97, 0x5a, 0xf8, 0xb2, 0x78, 0x63, 0x2a, 0x3d, 0x4a, 0xda, 0x3c, 0xb6, 0x95, 0xfc, 0x78, 0xd3, |
| 0xe0, 0xa3, 0x58, 0x50, 0xd1, 0x07, 0x21, 0x97, 0x2d, 0x9d, 0xc5, 0x65, 0x27, 0xd2, 0xdd, 0x15, |
| 0x6d, 0xc3, 0xbc, 0x69, 0x19, 0x1d, 0x8b, 0x50, 0xba, 0x4c, 0x94, 0xb6, 0xa6, 0xea, 0xc4, 0x5d, |
| 0x1f, 0xa7, 0x22, 0xba, 0x7c, 0x7c, 0x54, 0x99, 0x6f, 0x24, 0xb3, 0xe0, 0x34, 0x59, 0xf9, 0x79, |
| 0x01, 0xa6, 0xa2, 0x19, 0x30, 0xa5, 0x48, 0x95, 0xce, 0x54, 0xa4, 0xde, 0x08, 0x1c, 0x06, 0xa7, |
| 0x82, 0x0f, 0xbc, 0xe0, 0xc4, 0x0e, 0xc4, 0x22, 0x4c, 0x8a, 0x68, 0xe0, 0x12, 0x45, 0x99, 0xee, |
| 0xed, 0xfe, 0x76, 0x98, 0x8c, 0xa3, 0xfc, 0xe8, 0x21, 0x8c, 0x5b, 0xbc, 0xee, 0x76, 0x01, 0x9c, |
| 0xda, 0xf5, 0xa2, 0x00, 0x18, 0xc7, 0x41, 0x22, 0x0e, 0xf3, 0xb2, 0xba, 0xd5, 0x2f, 0x47, 0x5d, |
| 0x80, 0x42, 0xb8, 0x6e, 0x5d, 0x8c, 0x32, 0xe0, 0xb8, 0x0c, 0x5a, 0x87, 0x99, 0x9e, 0x1e, 0x87, |
| 0x72, 0x5c, 0xf9, 0xb2, 0x80, 0x9a, 0xd9, 0x8e, 0xb3, 0xe0, 0x24, 0x39, 0xb4, 0x1b, 0x2a, 0x65, |
| 0x87, 0x79, 0x78, 0xbe, 0x9d, 0xf9, 0xe0, 0x65, 0xae, 0x65, 0x13, 0xca, 0xed, 0x52, 0xd6, 0x72, |
| 0x5b, 0xfe, 0x27, 0x29, 0x98, 0x84, 0xbc, 0x12, 0x78, 0xd0, 0x2b, 0x53, 0x4c, 0x22, 0x50, 0x1d, |
| 0x19, 0xc9, 0xd5, 0xef, 0xbd, 0x53, 0x55, 0xbf, 0x7e, 0xf2, 0x1c, 0x5c, 0xfe, 0x7e, 0x2e, 0xc1, |
| 0xdc, 0x4a, 0xf3, 0xb1, 0x65, 0xf4, 0x4c, 0xd7, 0x9c, 0x4d, 0xd3, 0x59, 0x9a, 0x9f, 0x43, 0xc1, |
| 0xea, 0x69, 0xee, 0x3c, 0x5e, 0x73, 0xe7, 0x81, 0x7b, 0x1a, 0x9b, 0xc7, 0x4c, 0x44, 0xca, 0x99, |
| 0x04, 0x13, 0x40, 0x1b, 0x30, 0x6c, 0x29, 0x7a, 0x87, 0xb8, 0x69, 0xf5, 0xda, 0x00, 0xeb, 0x57, |
| 0x97, 0x31, 0x63, 0x0f, 0x14, 0x36, 0x5c, 0x1a, 0x0b, 0x14, 0xf9, 0x9f, 0x25, 0x98, 0x7c, 0xb2, |
| 0xb5, 0xd5, 0x58, 0xd5, 0xf9, 0x89, 0xe6, 0x6f, 0xab, 0x57, 0xa1, 0x60, 0x2a, 0xf6, 0x5e, 0x34, |
| 0xd3, 0x33, 0x1a, 0xe6, 0x14, 0x74, 0x07, 0x4a, 0xec, 0x5f, 0x66, 0x17, 0x3f, 0x52, 0x23, 0x3c, |
| 0x10, 0x96, 0x1a, 0x62, 0xec, 0x45, 0xe0, 0x6f, 0xec, 0x71, 0xa2, 0xf7, 0xa0, 0xc8, 0xe2, 0x0f, |
| 0xd1, 0xdb, 0x19, 0x0b, 0x74, 0x61, 0x54, 0xdd, 0x11, 0xf2, 0x6b, 0x2e, 0x31, 0x80, 0x5d, 0x38, |
| 0x79, 0x1f, 0x66, 0x03, 0x93, 0x60, 0xab, 0xf8, 0x94, 0xe5, 0x54, 0xd4, 0x84, 0x21, 0xa6, 0x9d, |
| 0x65, 0xce, 0x7c, 0x86, 0x27, 0xd0, 0xc8, 0x42, 0xf8, 0xf5, 0x11, 0xfb, 0x45, 0xb1, 0x83, 0x25, |
| 0xaf, 0xc3, 0x38, 0x7f, 0x86, 0x36, 0x2c, 0x9b, 0x2f, 0x26, 0xba, 0x02, 0xf9, 0xae, 0xaa, 0x8b, |
| 0xec, 0x3c, 0x2a, 0x64, 0xf2, 0x2c, 0xb3, 0xb0, 0x71, 0x4e, 0x56, 0x0e, 0x45, 0xbc, 0xf2, 0xc9, |
| 0xca, 0x21, 0x66, 0xe3, 0xf2, 0x63, 0x28, 0x8a, 0x4d, 0x0a, 0x02, 0xe5, 0x4f, 0x06, 0xca, 0x27, |
| 0x00, 0x6d, 0x42, 0x71, 0xb5, 0x51, 0xd7, 0x0c, 0xa7, 0x56, 0x6b, 0xa9, 0x6d, 0x2b, 0xba, 0x83, |
| 0x4b, 0xab, 0xcb, 0x18, 0x73, 0x0a, 0x92, 0x61, 0x98, 0x1c, 0xb6, 0x88, 0x69, 0x73, 0x3f, 0x1a, |
| 0xa9, 0x03, 0xf3, 0x8d, 0x47, 0x7c, 0x04, 0x0b, 0x8a, 0xfc, 0x27, 0x39, 0x28, 0x8a, 0xe5, 0x38, |
| 0x87, 0xbb, 0xdb, 0x5a, 0xe8, 0xee, 0xf6, 0x46, 0x36, 0xd7, 0x48, 0xbd, 0xb8, 0x6d, 0x45, 0x2e, |
| 0x6e, 0x37, 0x32, 0xe2, 0x9d, 0x7c, 0x6b, 0xfb, 0x34, 0x07, 0x13, 0x61, 0xa7, 0x44, 0x77, 0x61, |
| 0x94, 0xa5, 0x29, 0xb5, 0x45, 0x36, 0xfc, 0xea, 0xd8, 0x7b, 0xba, 0x69, 0xfa, 0x24, 0x1c, 0xe4, |
| 0x43, 0x1d, 0x4f, 0x8c, 0xf9, 0x91, 0x98, 0x74, 0xfa, 0x92, 0xf6, 0x6c, 0x55, 0xab, 0x3a, 0x1f, |
| 0x64, 0xaa, 0xab, 0xba, 0xbd, 0x69, 0x35, 0x6d, 0x4b, 0xd5, 0x3b, 0x31, 0x45, 0xdc, 0x29, 0x83, |
| 0xc8, 0xe8, 0x5d, 0x96, 0x32, 0xa9, 0xd1, 0xb3, 0x5a, 0x24, 0xa9, 0xf4, 0x75, 0xcb, 0x36, 0x76, |
| 0x40, 0xdb, 0x6b, 0x46, 0x4b, 0xd1, 0x9c, 0xcd, 0xc1, 0x64, 0x97, 0x58, 0x44, 0x6f, 0x11, 0xb7, |
| 0xdc, 0x74, 0x20, 0xb0, 0x07, 0x26, 0xff, 0x83, 0x04, 0xa3, 0x62, 0x2d, 0xce, 0xe1, 0x92, 0xf3, |
| 0x3b, 0xe1, 0x4b, 0xce, 0xb5, 0x8c, 0x91, 0x23, 0xf9, 0x86, 0xf3, 0xd7, 0xbe, 0xe9, 0x2c, 0x56, |
| 0xb0, 0xe3, 0xb2, 0x67, 0x50, 0x3b, 0x7a, 0x5c, 0xd8, 0x29, 0xc7, 0x9c, 0x82, 0x7a, 0x30, 0xa5, |
| 0x46, 0x82, 0x8b, 0xd8, 0xb3, 0x5a, 0x36, 0x4b, 0x3c, 0xb1, 0x7a, 0x59, 0xc0, 0x4f, 0x45, 0x29, |
| 0x38, 0xa6, 0x42, 0x26, 0x10, 0xe3, 0x42, 0xef, 0x40, 0x61, 0xcf, 0xb6, 0xcd, 0x84, 0xe7, 0xf3, |
| 0x01, 0x21, 0xcd, 0x37, 0xa1, 0xc4, 0x67, 0xb7, 0xb5, 0xd5, 0xc0, 0x1c, 0x4a, 0xfe, 0xc7, 0x9c, |
| 0xb7, 0x1e, 0xfc, 0xce, 0xf1, 0xb6, 0x37, 0xdb, 0x25, 0x4d, 0xa1, 0x94, 0x3b, 0xb6, 0x73, 0x3f, |
| 0x9e, 0x0d, 0x18, 0xee, 0xd1, 0x70, 0x8c, 0x1b, 0x6d, 0xf9, 0xa1, 0x5e, 0x3a, 0x4b, 0xa8, 0x1f, |
| 0x4d, 0x0a, 0xf3, 0xe8, 0x09, 0xe4, 0x6d, 0x2d, 0xeb, 0x3d, 0x57, 0x20, 0x6e, 0xad, 0x35, 0xfd, |
| 0x58, 0xb9, 0xb5, 0xd6, 0xc4, 0x0c, 0x02, 0x6d, 0xc2, 0x10, 0x4b, 0xa7, 0x2c, 0x3a, 0xe4, 0xb3, |
| 0x47, 0x1b, 0xb6, 0x82, 0xbe, 0x4b, 0xb1, 0x5f, 0x14, 0x3b, 0x38, 0xf2, 0xc7, 0x30, 0x1e, 0x0a, |
| 0x21, 0xe8, 0x23, 0x18, 0xd3, 0x0c, 0xa5, 0x5d, 0x57, 0x34, 0x45, 0x6f, 0x11, 0xf7, 0x6b, 0xc7, |
| 0xb5, 0xa4, 0xb3, 0xb7, 0x16, 0xe0, 0x13, 0x01, 0x68, 0x56, 0x28, 0x19, 0x0b, 0xd2, 0x70, 0x08, |
| 0x51, 0x56, 0x00, 0xfc, 0x39, 0xa2, 0x0a, 0x0c, 0x31, 0x4f, 0x75, 0x52, 0xdd, 0x48, 0x7d, 0x84, |
| 0x59, 0xc8, 0x1c, 0x98, 0x62, 0x67, 0x1c, 0xdd, 0x06, 0xa0, 0xa4, 0x65, 0x11, 0x9b, 0x6f, 0x67, |
| 0x2e, 0xfc, 0xc5, 0xb4, 0xe9, 0x51, 0x70, 0x80, 0x4b, 0xfe, 0x17, 0x09, 0xc6, 0x37, 0x88, 0xfd, |
| 0x89, 0x61, 0xed, 0x37, 0x0c, 0x4d, 0x6d, 0xf5, 0xcf, 0x21, 0x0f, 0xe0, 0x50, 0x1e, 0x78, 0x73, |
| 0xc0, 0xce, 0x84, 0xac, 0x4b, 0xcb, 0x06, 0xf2, 0x97, 0x12, 0xcc, 0x87, 0x38, 0x1f, 0xf9, 0x87, |
| 0x7f, 0x1b, 0x86, 0x4c, 0xc3, 0xb2, 0xdd, 0x1a, 0xe1, 0x54, 0x0a, 0x59, 0x84, 0x0d, 0x54, 0x09, |
| 0x0c, 0x06, 0x3b, 0x68, 0x68, 0x0d, 0x72, 0xb6, 0x21, 0x5c, 0xf5, 0x74, 0x98, 0x84, 0x58, 0x75, |
| 0x10, 0x98, 0xb9, 0x2d, 0x03, 0xe7, 0x6c, 0x83, 0x6d, 0x44, 0x39, 0xc4, 0x15, 0x0c, 0x5f, 0xaf, |
| 0x68, 0x06, 0x18, 0x0a, 0xbb, 0x96, 0xd1, 0x3d, 0xf3, 0x1c, 0xbc, 0x8d, 0x58, 0xb1, 0x8c, 0x2e, |
| 0xe6, 0x58, 0xf2, 0x57, 0x12, 0x4c, 0x87, 0x38, 0xcf, 0x21, 0x75, 0xbc, 0x13, 0x4e, 0x1d, 0x37, |
| 0x4e, 0x33, 0x91, 0x94, 0x04, 0xf2, 0x55, 0x2e, 0x32, 0x0d, 0x36, 0x61, 0xb4, 0x0b, 0xa3, 0xa6, |
| 0xd1, 0x6e, 0xbe, 0x84, 0xef, 0x9b, 0x93, 0x2c, 0xa5, 0x37, 0x7c, 0x2c, 0x1c, 0x04, 0x46, 0x87, |
| 0x30, 0xad, 0x2b, 0x5d, 0x42, 0x4d, 0xa5, 0x45, 0x9a, 0x2f, 0xe1, 0xc5, 0xe7, 0x22, 0xff, 0x80, |
| 0x12, 0x45, 0xc4, 0x71, 0x25, 0x68, 0x1d, 0x8a, 0xaa, 0xc9, 0x4b, 0x4c, 0x51, 0x4b, 0x0c, 0xcc, |
| 0xc3, 0x4e, 0x41, 0xea, 0xc4, 0x73, 0xf1, 0x03, 0xbb, 0x18, 0xf2, 0xdf, 0x44, 0xbd, 0x81, 0x57, |
| 0x2c, 0x8f, 0xa1, 0xc4, 0x3b, 0x4d, 0x5a, 0x86, 0xe6, 0x7e, 0xea, 0xe0, 0x97, 0x0b, 0x31, 0xf6, |
| 0xe2, 0xa8, 0x72, 0x39, 0xe1, 0x15, 0xdb, 0x25, 0x63, 0x4f, 0x18, 0x6d, 0x40, 0xc1, 0xfc, 0x21, |
| 0xc5, 0x15, 0x4f, 0x93, 0xbc, 0xa2, 0xe2, 0x38, 0xf2, 0x1f, 0xe6, 0x23, 0xe6, 0xf2, 0x64, 0xf9, |
| 0xec, 0xa5, 0xed, 0xba, 0x57, 0xcc, 0xa5, 0xee, 0xfc, 0x0e, 0x14, 0x45, 0xaa, 0x15, 0xce, 0xfc, |
| 0xf3, 0xd3, 0x38, 0x73, 0x30, 0x8b, 0x79, 0x77, 0x29, 0x77, 0xd0, 0x05, 0x46, 0x1f, 0xc2, 0x30, |
| 0x71, 0x54, 0x38, 0xb9, 0xf1, 0xde, 0x69, 0x54, 0xf8, 0x71, 0xd5, 0xaf, 0xa1, 0xc5, 0x98, 0x40, |
| 0x45, 0xbf, 0x64, 0xeb, 0xc5, 0x78, 0x59, 0xc9, 0x49, 0xcb, 0x05, 0x9e, 0xae, 0xae, 0x38, 0xd3, |
| 0xf6, 0x86, 0x5f, 0x1c, 0x55, 0xc0, 0xff, 0x89, 0x83, 0x12, 0xf2, 0xbf, 0x49, 0x30, 0xcd, 0x57, |
| 0xa8, 0xd5, 0xb3, 0x54, 0xbb, 0x7f, 0x6e, 0x89, 0xe9, 0x69, 0x28, 0x31, 0xdd, 0x19, 0xb0, 0x2c, |
| 0x31, 0x0b, 0x53, 0x93, 0xd3, 0xd7, 0x12, 0x5c, 0x8c, 0x71, 0x9f, 0x43, 0x5c, 0xdc, 0x0e, 0xc7, |
| 0xc5, 0x37, 0x4f, 0x3b, 0xa1, 0x94, 0xd8, 0xf8, 0x3f, 0xd3, 0x09, 0xd3, 0xe1, 0x27, 0xe5, 0x36, |
| 0x80, 0x69, 0xa9, 0x07, 0xaa, 0x46, 0x3a, 0xe2, 0xab, 0x7e, 0x29, 0xd0, 0xb3, 0xe5, 0x51, 0x70, |
| 0x80, 0x0b, 0x51, 0x98, 0x6b, 0x93, 0x5d, 0xa5, 0xa7, 0xd9, 0x8b, 0xed, 0xf6, 0x92, 0x62, 0x2a, |
| 0x3b, 0xaa, 0xa6, 0xda, 0xaa, 0x78, 0xff, 0x18, 0xa9, 0x3f, 0x74, 0xbe, 0xb6, 0x27, 0x71, 0xbc, |
| 0x38, 0xaa, 0x5c, 0x49, 0xfa, 0xdc, 0xe5, 0xb2, 0xf4, 0x71, 0x0a, 0x34, 0xea, 0x43, 0xd9, 0x22, |
| 0x1f, 0xf7, 0x54, 0x8b, 0xb4, 0x97, 0x2d, 0xc3, 0x0c, 0xa9, 0xcd, 0x73, 0xb5, 0xbf, 0x7d, 0x7c, |
| 0x54, 0x29, 0xe3, 0x14, 0x9e, 0xc1, 0x8a, 0x53, 0xe1, 0xd1, 0x33, 0x98, 0x51, 0x44, 0x77, 0x5d, |
| 0x50, 0xab, 0x73, 0x4a, 0xee, 0x1f, 0x1f, 0x55, 0x66, 0x16, 0xe3, 0xe4, 0xc1, 0x0a, 0x93, 0x40, |
| 0x51, 0x0d, 0x8a, 0x07, 0xbc, 0x11, 0x8f, 0x96, 0x87, 0x38, 0x3e, 0x4b, 0x04, 0x45, 0xa7, 0x37, |
| 0x8f, 0x61, 0x0e, 0xaf, 0x34, 0xf9, 0xe9, 0x73, 0xb9, 0xd8, 0x5d, 0x97, 0xd5, 0x92, 0xe2, 0xc4, |
| 0xf3, 0x27, 0xf0, 0x92, 0x1f, 0xb5, 0x9e, 0xf8, 0x24, 0x1c, 0xe4, 0x43, 0x1f, 0xc0, 0xc8, 0x9e, |
| 0x78, 0x30, 0xa1, 0xe5, 0x62, 0xa6, 0x24, 0x1c, 0x7a, 0x60, 0xa9, 0x4f, 0x0b, 0x15, 0x23, 0xee, |
| 0x30, 0xc5, 0x3e, 0x22, 0x7a, 0x1d, 0x8a, 0xfc, 0xc7, 0xea, 0x32, 0x7f, 0x5f, 0x2c, 0xf9, 0xb1, |
| 0xed, 0x89, 0x33, 0x8c, 0x5d, 0xba, 0xcb, 0xba, 0xda, 0x58, 0xe2, 0xef, 0xdc, 0x11, 0xd6, 0xd5, |
| 0xc6, 0x12, 0x76, 0xe9, 0xe8, 0x23, 0x28, 0x52, 0xb2, 0xa6, 0xea, 0xbd, 0xc3, 0x32, 0x64, 0xfa, |
| 0x4a, 0xde, 0x7c, 0xc4, 0xb9, 0x23, 0x2f, 0x7d, 0xbe, 0x06, 0x41, 0xc7, 0x2e, 0x2c, 0xda, 0x83, |
| 0x11, 0xab, 0xa7, 0x2f, 0xd2, 0x6d, 0x4a, 0xac, 0xf2, 0x28, 0xd7, 0x31, 0x28, 0x9c, 0x63, 0x97, |
| 0x3f, 0xaa, 0xc5, 0x5b, 0x21, 0x8f, 0x03, 0xfb, 0xe0, 0x68, 0x0f, 0x80, 0xff, 0xe0, 0x8f, 0x8a, |
| 0xe5, 0x39, 0xae, 0xea, 0x7e, 0x16, 0x55, 0x49, 0x6f, 0x97, 0xe2, 0xc3, 0x82, 0x47, 0xc6, 0x01, |
| 0x6c, 0xf4, 0xc7, 0x12, 0x20, 0xda, 0x33, 0x4d, 0x8d, 0x74, 0x89, 0x6e, 0x2b, 0x1a, 0x1f, 0xa5, |
| 0xe5, 0x31, 0xae, 0xf2, 0xed, 0x41, 0x2b, 0x18, 0x13, 0x8c, 0xaa, 0xf6, 0xbe, 0x17, 0xc4, 0x59, |
| 0x71, 0x82, 0x5e, 0xb6, 0x89, 0xbb, 0x62, 0xd6, 0xe3, 0x99, 0x36, 0x31, 0xf9, 0xb9, 0xd6, 0xdf, |
| 0x44, 0x41, 0xc7, 0x2e, 0x2c, 0x7a, 0x0a, 0x73, 0x6e, 0xc7, 0x28, 0x36, 0x0c, 0x7b, 0x45, 0xd5, |
| 0x08, 0xed, 0x53, 0x9b, 0x74, 0xcb, 0x13, 0xdc, 0xc1, 0xbc, 0xb6, 0x19, 0x9c, 0xc8, 0x85, 0x53, |
| 0xa4, 0x51, 0x17, 0x2a, 0x6e, 0x70, 0x62, 0x27, 0xd7, 0x8b, 0x8e, 0x8f, 0x68, 0x4b, 0xd1, 0x9c, |
| 0x4f, 0x28, 0x93, 0x5c, 0xc1, 0x6b, 0xc7, 0x47, 0x95, 0xca, 0xf2, 0xc9, 0xac, 0x78, 0x10, 0x16, |
| 0x7a, 0x0f, 0xca, 0x4a, 0x9a, 0x9e, 0x29, 0xae, 0xe7, 0xa7, 0x2c, 0xe2, 0xa5, 0x2a, 0x48, 0x95, |
| 0x46, 0x36, 0x4c, 0x29, 0xe1, 0xde, 0x5d, 0x5a, 0x9e, 0xce, 0xf4, 0x1a, 0x1b, 0x69, 0xf9, 0xf5, |
| 0x1f, 0x4e, 0x22, 0x04, 0x8a, 0x63, 0x1a, 0xd0, 0xef, 0x03, 0x52, 0xa2, 0xed, 0xc6, 0xb4, 0x8c, |
| 0x32, 0x25, 0xba, 0x58, 0x9f, 0xb2, 0xef, 0x76, 0x31, 0x12, 0xc5, 0x09, 0x7a, 0x58, 0x81, 0xae, |
| 0x44, 0x5a, 0xa4, 0x69, 0x79, 0x9e, 0x2b, 0xaf, 0x65, 0x53, 0xee, 0xc9, 0x05, 0xbe, 0x14, 0x45, |
| 0x11, 0x71, 0x5c, 0x09, 0x5a, 0x83, 0x59, 0x31, 0xb8, 0xad, 0x53, 0x65, 0x97, 0x34, 0xfb, 0xb4, |
| 0x65, 0x6b, 0xb4, 0x3c, 0xc3, 0xe3, 0x3b, 0xff, 0x5a, 0xb9, 0x98, 0x40, 0xc7, 0x89, 0x52, 0xe8, |
| 0x6d, 0x98, 0xda, 0x35, 0xac, 0x1d, 0xb5, 0xdd, 0x26, 0xba, 0x8b, 0x34, 0xcb, 0x91, 0xf8, 0x3b, |
| 0xd0, 0x4a, 0x84, 0x86, 0x63, 0xdc, 0x88, 0xc2, 0x45, 0x81, 0xdc, 0xb0, 0x8c, 0xd6, 0xba, 0xd1, |
| 0xd3, 0x6d, 0xa7, 0xec, 0xbb, 0xe8, 0xa5, 0xd1, 0x8b, 0x8b, 0x49, 0x0c, 0x2f, 0x8e, 0x2a, 0x57, |
| 0x93, 0xab, 0x7c, 0x9f, 0x09, 0x27, 0x63, 0x23, 0x13, 0xc6, 0x44, 0xe3, 0x3b, 0x7f, 0x90, 0x2a, |
| 0x97, 0xf9, 0xd1, 0x7f, 0x30, 0x38, 0xe0, 0x79, 0x22, 0xd1, 0xf3, 0x3f, 0x75, 0x7c, 0x54, 0x19, |
| 0x0b, 0x32, 0xe0, 0x90, 0x06, 0xde, 0xe8, 0x24, 0x3e, 0xaf, 0x9d, 0x4f, 0xb3, 0xf8, 0xe9, 0x1a, |
| 0x9d, 0x7c, 0xd3, 0x5e, 0x5a, 0xa3, 0x53, 0x00, 0xf2, 0xe4, 0x27, 0xf3, 0xff, 0xce, 0xc1, 0x8c, |
| 0xcf, 0x9c, 0xb9, 0xd1, 0x29, 0x41, 0xe4, 0xd7, 0x0d, 0xe3, 0xd9, 0x9a, 0x8f, 0xfc, 0xa5, 0xfb, |
| 0xff, 0xd7, 0x7c, 0xe4, 0xdb, 0x96, 0x72, 0x7b, 0xf8, 0xbb, 0x5c, 0x70, 0x02, 0xa7, 0xec, 0x80, |
| 0x79, 0x09, 0x3d, 0xd3, 0x3f, 0xba, 0x26, 0x1a, 0xf9, 0xeb, 0x3c, 0x4c, 0x45, 0x4f, 0x63, 0xa8, |
| 0x51, 0x42, 0x1a, 0xd8, 0x28, 0xd1, 0x80, 0xd9, 0xdd, 0x9e, 0xa6, 0xf5, 0xf9, 0x1c, 0x02, 0xdd, |
| 0x12, 0xce, 0x27, 0xcb, 0x9f, 0x0a, 0xc9, 0xd9, 0x95, 0x04, 0x1e, 0x9c, 0x28, 0x19, 0xef, 0x9b, |
| 0x28, 0xfc, 0xd0, 0xbe, 0x89, 0xa1, 0x33, 0xf4, 0x4d, 0x24, 0xb7, 0x9e, 0xe4, 0xcf, 0xd4, 0x7a, |
| 0x72, 0x96, 0xa6, 0x89, 0x84, 0x20, 0x36, 0xb0, 0x01, 0xf8, 0x17, 0x30, 0x11, 0x6e, 0xe4, 0x71, |
| 0xf6, 0xd2, 0xe9, 0x25, 0x12, 0x9f, 0x86, 0x03, 0x7b, 0xe9, 0x8c, 0x63, 0x8f, 0x43, 0xfe, 0x23, |
| 0x09, 0xe6, 0x92, 0x1b, 0x76, 0x91, 0x06, 0x13, 0x5d, 0xe5, 0x30, 0xd8, 0x44, 0x2d, 0x9d, 0xf1, |
| 0x65, 0x8c, 0x77, 0x70, 0xac, 0x87, 0xb0, 0x70, 0x04, 0x5b, 0xfe, 0x5e, 0x82, 0xf9, 0x94, 0xde, |
| 0x89, 0xf3, 0xb5, 0x04, 0xbd, 0x0f, 0xa5, 0xae, 0x72, 0xd8, 0xec, 0x59, 0x1d, 0x72, 0xe6, 0xb7, |
| 0x40, 0x7e, 0xa0, 0xd7, 0x05, 0x0a, 0xf6, 0xf0, 0xe4, 0xbf, 0x92, 0xe0, 0x27, 0xa9, 0x57, 0x25, |
| 0x74, 0x2f, 0xd4, 0xe6, 0x21, 0x47, 0xda, 0x3c, 0x50, 0x5c, 0xf0, 0x15, 0x75, 0x79, 0x7c, 0x2e, |
| 0x41, 0x39, 0xed, 0xee, 0x88, 0xee, 0x86, 0x8c, 0xfc, 0x59, 0xc4, 0xc8, 0xe9, 0x98, 0xdc, 0x2b, |
| 0xb2, 0xf1, 0xdf, 0x25, 0xb8, 0x7c, 0x42, 0x0d, 0xe6, 0x5d, 0x51, 0x48, 0x3b, 0xc8, 0xc5, 0x9f, |
| 0xad, 0xc5, 0x37, 0x2f, 0xff, 0x8a, 0x92, 0xc0, 0x83, 0x53, 0xa5, 0xd1, 0x36, 0xcc, 0x8b, 0xfb, |
| 0x51, 0x94, 0x26, 0xca, 0x0b, 0xde, 0x0d, 0xb7, 0x9c, 0xcc, 0x82, 0xd3, 0x64, 0xe5, 0xbf, 0x95, |
| 0x60, 0x2e, 0xf9, 0x51, 0x00, 0xbd, 0x15, 0x5a, 0xf2, 0x4a, 0x64, 0xc9, 0x27, 0x23, 0x52, 0x62, |
| 0xc1, 0x3f, 0x84, 0x09, 0xf1, 0x74, 0x20, 0x60, 0x84, 0x33, 0xcb, 0x49, 0x19, 0x44, 0x40, 0xb8, |
| 0x05, 0x2c, 0x3f, 0x26, 0xe1, 0x31, 0x1c, 0x41, 0x93, 0x3f, 0xcd, 0xc1, 0x50, 0xb3, 0xa5, 0x68, |
| 0xe4, 0x1c, 0xea, 0xd7, 0x5f, 0x85, 0xea, 0xd7, 0x41, 0xff, 0xcf, 0x8c, 0x5b, 0x95, 0x5a, 0xba, |
| 0xe2, 0x48, 0xe9, 0xfa, 0x46, 0x26, 0xb4, 0x93, 0xab, 0xd6, 0xdf, 0x82, 0x11, 0x4f, 0xe9, 0xe9, |
| 0x92, 0xa9, 0xfc, 0x97, 0x39, 0x18, 0x0d, 0xa8, 0x38, 0x65, 0x2a, 0xde, 0x0d, 0xd5, 0x1f, 0xf9, |
| 0x0c, 0x0f, 0x35, 0x01, 0x5d, 0x55, 0xb7, 0xe2, 0x70, 0xfa, 0xa4, 0xfd, 0xce, 0xd8, 0x78, 0x21, |
| 0xf2, 0x0b, 0x98, 0xb0, 0x15, 0xab, 0x43, 0x6c, 0xef, 0xc3, 0x85, 0xd3, 0xc7, 0xe5, 0x35, 0xec, |
| 0x6f, 0x85, 0xa8, 0x38, 0xc2, 0x7d, 0xe9, 0x21, 0x8c, 0x87, 0x94, 0x9d, 0xaa, 0xcd, 0xf9, 0xef, |
| 0x25, 0xf8, 0xd9, 0xc0, 0xc7, 0x1e, 0x54, 0x0f, 0x1d, 0x92, 0x6a, 0xe4, 0x90, 0x2c, 0xa4, 0x03, |
| 0xbc, 0xba, 0x76, 0xb9, 0xfa, 0xcd, 0xe7, 0xdf, 0x2d, 0x5c, 0xf8, 0xe6, 0xbb, 0x85, 0x0b, 0xdf, |
| 0x7e, 0xb7, 0x70, 0xe1, 0x0f, 0x8e, 0x17, 0xa4, 0xe7, 0xc7, 0x0b, 0xd2, 0x37, 0xc7, 0x0b, 0xd2, |
| 0xb7, 0xc7, 0x0b, 0xd2, 0x7f, 0x1e, 0x2f, 0x48, 0x7f, 0xfa, 0xfd, 0xc2, 0x85, 0xf7, 0x8b, 0x02, |
| 0xee, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x98, 0xf4, 0xad, 0x8a, 0xba, 0x3e, 0x00, 0x00, |
| } |
| |
| func (m *AllowedCSIDriver) 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 *AllowedCSIDriver) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *AllowedCSIDriver) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| 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 *AllowedFlexVolume) 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 *AllowedFlexVolume) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *AllowedFlexVolume) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i -= len(m.Driver) |
| copy(dAtA[i:], m.Driver) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Driver))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *AllowedHostPath) 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 *AllowedHostPath) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *AllowedHostPath) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i-- |
| if m.ReadOnly { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x10 |
| i -= len(m.PathPrefix) |
| copy(dAtA[i:], m.PathPrefix) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.PathPrefix))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DaemonSet) 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 *DaemonSet) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DaemonSet) 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 *DaemonSetCondition) 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 *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DaemonSetCondition) 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 *DaemonSetList) 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 *DaemonSetList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DaemonSetList) 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 *DaemonSetSpec) 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 *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DaemonSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.RevisionHistoryLimit != nil { |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit)) |
| i-- |
| dAtA[i] = 0x30 |
| } |
| i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration)) |
| i-- |
| dAtA[i] = 0x28 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) |
| i-- |
| dAtA[i] = 0x20 |
| { |
| size, err := m.UpdateStrategy.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| { |
| size, err := m.Template.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| 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] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DaemonSetStatus) 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 *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DaemonSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| 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 = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable)) |
| i-- |
| dAtA[i] = 0x40 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable)) |
| i-- |
| dAtA[i] = 0x38 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled)) |
| i-- |
| dAtA[i] = 0x30 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) |
| i-- |
| dAtA[i] = 0x28 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady)) |
| i-- |
| dAtA[i] = 0x20 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled)) |
| i-- |
| dAtA[i] = 0x18 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled)) |
| i-- |
| dAtA[i] = 0x10 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *DaemonSetUpdateStrategy) 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 *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *DaemonSetUpdateStrategy) 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 *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)) |
| } |
| github_com_gogo_protobuf_sortkeys.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.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 *FSGroupStrategyOptions) 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 *FSGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *FSGroupStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Ranges) > 0 { |
| for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i -= len(m.Rule) |
| copy(dAtA[i:], m.Rule) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *HTTPIngressPath) 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 *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *HTTPIngressPath) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.PathType != nil { |
| i -= len(*m.PathType) |
| copy(dAtA[i:], *m.PathType) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PathType))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| { |
| size, err := m.Backend.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(m.Path) |
| copy(dAtA[i:], m.Path) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *HTTPIngressRuleValue) 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 *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *HTTPIngressRuleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Paths) > 0 { |
| for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Paths[iNdEx].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 *HostPortRange) 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 *HostPortRange) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *HostPortRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Max)) |
| i-- |
| dAtA[i] = 0x10 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Min)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *IDRange) 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 *IDRange) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IDRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Max)) |
| i-- |
| dAtA[i] = 0x10 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Min)) |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *IPBlock) 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 *IPBlock) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IPBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Except) > 0 { |
| for iNdEx := len(m.Except) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Except[iNdEx]) |
| copy(dAtA[i:], m.Except[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Except[iNdEx]))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i -= len(m.CIDR) |
| copy(dAtA[i:], m.CIDR) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *Ingress) 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 *Ingress) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *Ingress) 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 *IngressBackend) 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 *IngressBackend) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressBackend) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Resource != nil { |
| { |
| size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| { |
| size, err := m.ServicePort.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(m.ServiceName) |
| copy(dAtA[i:], m.ServiceName) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *IngressList) 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 *IngressList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressList) 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 *IngressRule) 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 *IngressRule) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.IngressRuleValue.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| i -= len(m.Host) |
| copy(dAtA[i:], m.Host) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *IngressRuleValue) 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 *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressRuleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.HTTP != nil { |
| { |
| size, err := m.HTTP.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 *IngressSpec) 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 *IngressSpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.IngressClassName != nil { |
| i -= len(*m.IngressClassName) |
| copy(dAtA[i:], *m.IngressClassName) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(*m.IngressClassName))) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| if len(m.Rules) > 0 { |
| for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| } |
| if len(m.TLS) > 0 { |
| for iNdEx := len(m.TLS) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.TLS[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if m.Backend != nil { |
| { |
| size, err := m.Backend.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 *IngressStatus) 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 *IngressStatus) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| size, err := m.LoadBalancer.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 *IngressTLS) 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 *IngressTLS) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *IngressTLS) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i -= len(m.SecretName) |
| copy(dAtA[i:], m.SecretName) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName))) |
| i-- |
| dAtA[i] = 0x12 |
| if len(m.Hosts) > 0 { |
| for iNdEx := len(m.Hosts) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Hosts[iNdEx]) |
| copy(dAtA[i:], m.Hosts[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hosts[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *NetworkPolicy) 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 *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| 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 *NetworkPolicyEgressRule) 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 *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicyEgressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.To) > 0 { |
| for iNdEx := len(m.To) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.To[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if len(m.Ports) > 0 { |
| for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ports[iNdEx].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 *NetworkPolicyIngressRule) 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 *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicyIngressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.From) > 0 { |
| for iNdEx := len(m.From) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.From[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| if len(m.Ports) > 0 { |
| for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ports[iNdEx].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 *NetworkPolicyList) 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 *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicyList) 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 *NetworkPolicyPeer) 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 *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicyPeer) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.IPBlock != nil { |
| { |
| size, err := m.IPBlock.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| if m.NamespaceSelector != nil { |
| { |
| size, err := m.NamespaceSelector.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.PodSelector != nil { |
| { |
| size, err := m.PodSelector.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 *NetworkPolicyPort) 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 *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicyPort) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.Port != nil { |
| { |
| size, err := m.Port.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if m.Protocol != nil { |
| i -= len(*m.Protocol) |
| copy(dAtA[i:], *m.Protocol) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *NetworkPolicySpec) 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 *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *NetworkPolicySpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.PolicyTypes) > 0 { |
| for iNdEx := len(m.PolicyTypes) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.PolicyTypes[iNdEx]) |
| copy(dAtA[i:], m.PolicyTypes[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.PolicyTypes[iNdEx]))) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| } |
| if len(m.Egress) > 0 { |
| for iNdEx := len(m.Egress) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Egress[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1a |
| } |
| } |
| if len(m.Ingress) > 0 { |
| for iNdEx := len(m.Ingress) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ingress[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.PodSelector.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 *PodSecurityPolicy) 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 *PodSecurityPolicy) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *PodSecurityPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| { |
| 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 *PodSecurityPolicyList) 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 *PodSecurityPolicyList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *PodSecurityPolicyList) 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 *PodSecurityPolicySpec) 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 *PodSecurityPolicySpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *PodSecurityPolicySpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.RuntimeClass != nil { |
| { |
| size, err := m.RuntimeClass.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xc2 |
| } |
| if len(m.AllowedCSIDrivers) > 0 { |
| for iNdEx := len(m.AllowedCSIDrivers) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.AllowedCSIDrivers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xba |
| } |
| } |
| if m.RunAsGroup != nil { |
| { |
| size, err := m.RunAsGroup.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xb2 |
| } |
| if len(m.AllowedProcMountTypes) > 0 { |
| for iNdEx := len(m.AllowedProcMountTypes) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.AllowedProcMountTypes[iNdEx]) |
| copy(dAtA[i:], m.AllowedProcMountTypes[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.AllowedProcMountTypes[iNdEx]))) |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xaa |
| } |
| } |
| if len(m.ForbiddenSysctls) > 0 { |
| for iNdEx := len(m.ForbiddenSysctls) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.ForbiddenSysctls[iNdEx]) |
| copy(dAtA[i:], m.ForbiddenSysctls[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ForbiddenSysctls[iNdEx]))) |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0xa2 |
| } |
| } |
| if len(m.AllowedUnsafeSysctls) > 0 { |
| for iNdEx := len(m.AllowedUnsafeSysctls) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.AllowedUnsafeSysctls[iNdEx]) |
| copy(dAtA[i:], m.AllowedUnsafeSysctls[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.AllowedUnsafeSysctls[iNdEx]))) |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0x9a |
| } |
| } |
| if len(m.AllowedFlexVolumes) > 0 { |
| for iNdEx := len(m.AllowedFlexVolumes) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.AllowedFlexVolumes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0x92 |
| } |
| } |
| if len(m.AllowedHostPaths) > 0 { |
| for iNdEx := len(m.AllowedHostPaths) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.AllowedHostPaths[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0x8a |
| } |
| } |
| if m.AllowPrivilegeEscalation != nil { |
| i-- |
| if *m.AllowPrivilegeEscalation { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x1 |
| i-- |
| dAtA[i] = 0x80 |
| } |
| if m.DefaultAllowPrivilegeEscalation != nil { |
| i-- |
| if *m.DefaultAllowPrivilegeEscalation { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x78 |
| } |
| i-- |
| if m.ReadOnlyRootFilesystem { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x70 |
| { |
| size, err := m.FSGroup.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x6a |
| { |
| size, err := m.SupplementalGroups.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x62 |
| { |
| size, err := m.RunAsUser.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x5a |
| { |
| size, err := m.SELinux.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x52 |
| i-- |
| if m.HostIPC { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x48 |
| i-- |
| if m.HostPID { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x40 |
| if len(m.HostPorts) > 0 { |
| for iNdEx := len(m.HostPorts) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.HostPorts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x3a |
| } |
| } |
| i-- |
| if m.HostNetwork { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x30 |
| if len(m.Volumes) > 0 { |
| for iNdEx := len(m.Volumes) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.Volumes[iNdEx]) |
| copy(dAtA[i:], m.Volumes[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Volumes[iNdEx]))) |
| i-- |
| dAtA[i] = 0x2a |
| } |
| } |
| if len(m.AllowedCapabilities) > 0 { |
| for iNdEx := len(m.AllowedCapabilities) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.AllowedCapabilities[iNdEx]) |
| copy(dAtA[i:], m.AllowedCapabilities[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.AllowedCapabilities[iNdEx]))) |
| i-- |
| dAtA[i] = 0x22 |
| } |
| } |
| if len(m.RequiredDropCapabilities) > 0 { |
| for iNdEx := len(m.RequiredDropCapabilities) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.RequiredDropCapabilities[iNdEx]) |
| copy(dAtA[i:], m.RequiredDropCapabilities[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.RequiredDropCapabilities[iNdEx]))) |
| i-- |
| dAtA[i] = 0x1a |
| } |
| } |
| if len(m.DefaultAddCapabilities) > 0 { |
| for iNdEx := len(m.DefaultAddCapabilities) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.DefaultAddCapabilities[iNdEx]) |
| copy(dAtA[i:], m.DefaultAddCapabilities[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.DefaultAddCapabilities[iNdEx]))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i-- |
| if m.Privileged { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i-- |
| dAtA[i] = 0x8 |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *ReplicaSet) 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 *ReplicaSet) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ReplicaSet) 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 *ReplicaSetCondition) 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 *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ReplicaSetCondition) 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 *ReplicaSetList) 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 *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ReplicaSetList) 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 *ReplicaSetSpec) 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 *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ReplicaSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds)) |
| i-- |
| dAtA[i] = 0x20 |
| { |
| 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 *ReplicaSetStatus) 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 *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *ReplicaSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| 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.AvailableReplicas)) |
| i-- |
| dAtA[i] = 0x28 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas)) |
| i-- |
| dAtA[i] = 0x20 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration)) |
| i-- |
| dAtA[i] = 0x18 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas)) |
| i-- |
| dAtA[i] = 0x10 |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas)) |
| i-- |
| dAtA[i] = 0x8 |
| 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 *RollingUpdateDaemonSet) 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 *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RollingUpdateDaemonSet) 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] = 0xa |
| } |
| 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 *RunAsGroupStrategyOptions) 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 *RunAsGroupStrategyOptions) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RunAsGroupStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Ranges) > 0 { |
| for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i -= len(m.Rule) |
| copy(dAtA[i:], m.Rule) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *RunAsUserStrategyOptions) 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 *RunAsUserStrategyOptions) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RunAsUserStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Ranges) > 0 { |
| for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i -= len(m.Rule) |
| copy(dAtA[i:], m.Rule) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) |
| i-- |
| dAtA[i] = 0xa |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *RuntimeClassStrategyOptions) 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 *RuntimeClassStrategyOptions) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *RuntimeClassStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.DefaultRuntimeClassName != nil { |
| i -= len(*m.DefaultRuntimeClassName) |
| copy(dAtA[i:], *m.DefaultRuntimeClassName) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(*m.DefaultRuntimeClassName))) |
| i-- |
| dAtA[i] = 0x12 |
| } |
| if len(m.AllowedRuntimeClassNames) > 0 { |
| for iNdEx := len(m.AllowedRuntimeClassNames) - 1; iNdEx >= 0; iNdEx-- { |
| i -= len(m.AllowedRuntimeClassNames[iNdEx]) |
| copy(dAtA[i:], m.AllowedRuntimeClassNames[iNdEx]) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.AllowedRuntimeClassNames[iNdEx]))) |
| i-- |
| dAtA[i] = 0xa |
| } |
| } |
| return len(dAtA) - i, nil |
| } |
| |
| func (m *SELinuxStrategyOptions) 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 *SELinuxStrategyOptions) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *SELinuxStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if m.SELinuxOptions != nil { |
| { |
| size, err := m.SELinuxOptions.MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| i -= len(m.Rule) |
| copy(dAtA[i:], m.Rule) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) |
| i-- |
| dAtA[i] = 0xa |
| 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)) |
| } |
| github_com_gogo_protobuf_sortkeys.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 *SupplementalGroupsStrategyOptions) 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 *SupplementalGroupsStrategyOptions) MarshalTo(dAtA []byte) (int, error) { |
| size := m.Size() |
| return m.MarshalToSizedBuffer(dAtA[:size]) |
| } |
| |
| func (m *SupplementalGroupsStrategyOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) { |
| i := len(dAtA) |
| _ = i |
| var l int |
| _ = l |
| if len(m.Ranges) > 0 { |
| for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { |
| { |
| size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) |
| if err != nil { |
| return 0, err |
| } |
| i -= size |
| i = encodeVarintGenerated(dAtA, i, uint64(size)) |
| } |
| i-- |
| dAtA[i] = 0x12 |
| } |
| } |
| i -= len(m.Rule) |
| copy(dAtA[i:], m.Rule) |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Rule))) |
| 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 *AllowedCSIDriver) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *AllowedFlexVolume) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Driver) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *AllowedHostPath) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.PathPrefix) |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 2 |
| return n |
| } |
| |
| func (m *DaemonSet) 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 *DaemonSetCondition) 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 *DaemonSetList) 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 *DaemonSetSpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| 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.UpdateStrategy.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 1 + sovGenerated(uint64(m.MinReadySeconds)) |
| n += 1 + sovGenerated(uint64(m.TemplateGeneration)) |
| if m.RevisionHistoryLimit != nil { |
| n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit)) |
| } |
| return n |
| } |
| |
| func (m *DaemonSetStatus) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled)) |
| n += 1 + sovGenerated(uint64(m.NumberMisscheduled)) |
| n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled)) |
| n += 1 + sovGenerated(uint64(m.NumberReady)) |
| n += 1 + sovGenerated(uint64(m.ObservedGeneration)) |
| n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled)) |
| n += 1 + sovGenerated(uint64(m.NumberAvailable)) |
| n += 1 + sovGenerated(uint64(m.NumberUnavailable)) |
| 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)) |
| } |
| } |
| return n |
| } |
| |
| func (m *DaemonSetUpdateStrategy) 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 *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)) |
| } |
| 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 *FSGroupStrategyOptions) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Rule) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Ranges) > 0 { |
| for _, e := range m.Ranges { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *HTTPIngressPath) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Path) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.Backend.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.PathType != nil { |
| l = len(*m.PathType) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *HTTPIngressRuleValue) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Paths) > 0 { |
| for _, e := range m.Paths { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *HostPortRange) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Min)) |
| n += 1 + sovGenerated(uint64(m.Max)) |
| return n |
| } |
| |
| func (m *IDRange) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Min)) |
| n += 1 + sovGenerated(uint64(m.Max)) |
| return n |
| } |
| |
| func (m *IPBlock) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.CIDR) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Except) > 0 { |
| for _, s := range m.Except { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *Ingress) 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 *IngressBackend) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.ServiceName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.ServicePort.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.Resource != nil { |
| l = m.Resource.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *IngressList) 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 *IngressRule) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Host) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.IngressRuleValue.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *IngressRuleValue) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.HTTP != nil { |
| l = m.HTTP.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *IngressSpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Backend != nil { |
| l = m.Backend.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if len(m.TLS) > 0 { |
| for _, e := range m.TLS { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.Rules) > 0 { |
| for _, e := range m.Rules { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if m.IngressClassName != nil { |
| l = len(*m.IngressClassName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *IngressStatus) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = m.LoadBalancer.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *IngressTLS) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Hosts) > 0 { |
| for _, s := range m.Hosts { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| l = len(m.SecretName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *NetworkPolicy) 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)) |
| return n |
| } |
| |
| func (m *NetworkPolicyEgressRule) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Ports) > 0 { |
| for _, e := range m.Ports { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.To) > 0 { |
| for _, e := range m.To { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *NetworkPolicyIngressRule) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.Ports) > 0 { |
| for _, e := range m.Ports { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.From) > 0 { |
| for _, e := range m.From { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *NetworkPolicyList) 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 *NetworkPolicyPeer) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.PodSelector != nil { |
| l = m.PodSelector.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.NamespaceSelector != nil { |
| l = m.NamespaceSelector.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.IPBlock != nil { |
| l = m.IPBlock.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *NetworkPolicyPort) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if m.Protocol != nil { |
| l = len(*m.Protocol) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.Port != nil { |
| l = m.Port.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *NetworkPolicySpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = m.PodSelector.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Ingress) > 0 { |
| for _, e := range m.Ingress { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.Egress) > 0 { |
| for _, e := range m.Egress { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.PolicyTypes) > 0 { |
| for _, s := range m.PolicyTypes { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *PodSecurityPolicy) 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)) |
| return n |
| } |
| |
| func (m *PodSecurityPolicyList) 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 *PodSecurityPolicySpec) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 2 |
| if len(m.DefaultAddCapabilities) > 0 { |
| for _, s := range m.DefaultAddCapabilities { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.RequiredDropCapabilities) > 0 { |
| for _, s := range m.RequiredDropCapabilities { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.AllowedCapabilities) > 0 { |
| for _, s := range m.AllowedCapabilities { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.Volumes) > 0 { |
| for _, s := range m.Volumes { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| n += 2 |
| if len(m.HostPorts) > 0 { |
| for _, e := range m.HostPorts { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| n += 2 |
| n += 2 |
| l = m.SELinux.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.RunAsUser.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.SupplementalGroups.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.FSGroup.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 2 |
| if m.DefaultAllowPrivilegeEscalation != nil { |
| n += 2 |
| } |
| if m.AllowPrivilegeEscalation != nil { |
| n += 3 |
| } |
| if len(m.AllowedHostPaths) > 0 { |
| for _, e := range m.AllowedHostPaths { |
| l = e.Size() |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.AllowedFlexVolumes) > 0 { |
| for _, e := range m.AllowedFlexVolumes { |
| l = e.Size() |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.AllowedUnsafeSysctls) > 0 { |
| for _, s := range m.AllowedUnsafeSysctls { |
| l = len(s) |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.ForbiddenSysctls) > 0 { |
| for _, s := range m.ForbiddenSysctls { |
| l = len(s) |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.AllowedProcMountTypes) > 0 { |
| for _, s := range m.AllowedProcMountTypes { |
| l = len(s) |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if m.RunAsGroup != nil { |
| l = m.RunAsGroup.Size() |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| if len(m.AllowedCSIDrivers) > 0 { |
| for _, e := range m.AllowedCSIDrivers { |
| l = e.Size() |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if m.RuntimeClass != nil { |
| l = m.RuntimeClass.Size() |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *ReplicaSet) 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 *ReplicaSetCondition) 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 *ReplicaSetList) 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 *ReplicaSetSpec) 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)) |
| n += 1 + sovGenerated(uint64(m.MinReadySeconds)) |
| return n |
| } |
| |
| func (m *ReplicaSetStatus) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Replicas)) |
| n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas)) |
| n += 1 + sovGenerated(uint64(m.ObservedGeneration)) |
| n += 1 + sovGenerated(uint64(m.ReadyReplicas)) |
| n += 1 + sovGenerated(uint64(m.AvailableReplicas)) |
| if len(m.Conditions) > 0 { |
| for _, e := range m.Conditions { |
| l = e.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 *RollingUpdateDaemonSet) 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)) |
| } |
| 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 *RunAsGroupStrategyOptions) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Rule) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Ranges) > 0 { |
| for _, e := range m.Ranges { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *RunAsUserStrategyOptions) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Rule) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Ranges) > 0 { |
| for _, e := range m.Ranges { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *RuntimeClassStrategyOptions) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| if len(m.AllowedRuntimeClassNames) > 0 { |
| for _, s := range m.AllowedRuntimeClassNames { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if m.DefaultRuntimeClassName != nil { |
| l = len(*m.DefaultRuntimeClassName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *SELinuxStrategyOptions) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Rule) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.SELinuxOptions != nil { |
| l = m.SELinuxOptions.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 *SupplementalGroupsStrategyOptions) Size() (n int) { |
| if m == nil { |
| return 0 |
| } |
| var l int |
| _ = l |
| l = len(m.Rule) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Ranges) > 0 { |
| for _, e := range m.Ranges { |
| l = e.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 *AllowedCSIDriver) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&AllowedCSIDriver{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *AllowedFlexVolume) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&AllowedFlexVolume{`, |
| `Driver:` + fmt.Sprintf("%v", this.Driver) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *AllowedHostPath) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&AllowedHostPath{`, |
| `PathPrefix:` + fmt.Sprintf("%v", this.PathPrefix) + `,`, |
| `ReadOnly:` + fmt.Sprintf("%v", this.ReadOnly) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DaemonSet) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DaemonSet{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`, |
| `Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DaemonSetCondition) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DaemonSetCondition{`, |
| `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 *DaemonSetList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]DaemonSet{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&DaemonSetList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DaemonSetSpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DaemonSetSpec{`, |
| `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) + `,`, |
| `UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`, |
| `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, |
| `TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`, |
| `RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DaemonSetStatus) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForConditions := "[]DaemonSetCondition{" |
| for _, f := range this.Conditions { |
| repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForConditions += "}" |
| s := strings.Join([]string{`&DaemonSetStatus{`, |
| `CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`, |
| `NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`, |
| `DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`, |
| `NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`, |
| `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, |
| `UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`, |
| `NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`, |
| `NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`, |
| `CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`, |
| `Conditions:` + repeatedStringForConditions + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DaemonSetUpdateStrategy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DaemonSetUpdateStrategy{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`, |
| `}`, |
| }, "") |
| 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) |
| } |
| github_com_gogo_protobuf_sortkeys.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) + `,`, |
| `}`, |
| }, "") |
| 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 *FSGroupStrategyOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForRanges := "[]IDRange{" |
| for _, f := range this.Ranges { |
| repeatedStringForRanges += strings.Replace(strings.Replace(f.String(), "IDRange", "IDRange", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForRanges += "}" |
| s := strings.Join([]string{`&FSGroupStrategyOptions{`, |
| `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, |
| `Ranges:` + repeatedStringForRanges + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *HTTPIngressPath) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&HTTPIngressPath{`, |
| `Path:` + fmt.Sprintf("%v", this.Path) + `,`, |
| `Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`, |
| `PathType:` + valueToStringGenerated(this.PathType) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *HTTPIngressRuleValue) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForPaths := "[]HTTPIngressPath{" |
| for _, f := range this.Paths { |
| repeatedStringForPaths += strings.Replace(strings.Replace(f.String(), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForPaths += "}" |
| s := strings.Join([]string{`&HTTPIngressRuleValue{`, |
| `Paths:` + repeatedStringForPaths + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *HostPortRange) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&HostPortRange{`, |
| `Min:` + fmt.Sprintf("%v", this.Min) + `,`, |
| `Max:` + fmt.Sprintf("%v", this.Max) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IDRange) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IDRange{`, |
| `Min:` + fmt.Sprintf("%v", this.Min) + `,`, |
| `Max:` + fmt.Sprintf("%v", this.Max) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IPBlock) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IPBlock{`, |
| `CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`, |
| `Except:` + fmt.Sprintf("%v", this.Except) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Ingress) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Ingress{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`, |
| `Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressBackend) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IngressBackend{`, |
| `ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`, |
| `ServicePort:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServicePort), "IntOrString", "intstr.IntOrString", 1), `&`, ``, 1) + `,`, |
| `Resource:` + strings.Replace(fmt.Sprintf("%v", this.Resource), "TypedLocalObjectReference", "v11.TypedLocalObjectReference", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]Ingress{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Ingress", "Ingress", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&IngressList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressRule) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IngressRule{`, |
| `Host:` + fmt.Sprintf("%v", this.Host) + `,`, |
| `IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressRuleValue) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IngressRuleValue{`, |
| `HTTP:` + strings.Replace(this.HTTP.String(), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressSpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForTLS := "[]IngressTLS{" |
| for _, f := range this.TLS { |
| repeatedStringForTLS += strings.Replace(strings.Replace(f.String(), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForTLS += "}" |
| repeatedStringForRules := "[]IngressRule{" |
| for _, f := range this.Rules { |
| repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "IngressRule", "IngressRule", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForRules += "}" |
| s := strings.Join([]string{`&IngressSpec{`, |
| `Backend:` + strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1) + `,`, |
| `TLS:` + repeatedStringForTLS + `,`, |
| `Rules:` + repeatedStringForRules + `,`, |
| `IngressClassName:` + valueToStringGenerated(this.IngressClassName) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressStatus) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IngressStatus{`, |
| `LoadBalancer:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LoadBalancer), "LoadBalancerStatus", "v11.LoadBalancerStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *IngressTLS) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&IngressTLS{`, |
| `Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`, |
| `SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&NetworkPolicy{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicyEgressRule) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForPorts := "[]NetworkPolicyPort{" |
| for _, f := range this.Ports { |
| repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForPorts += "}" |
| repeatedStringForTo := "[]NetworkPolicyPeer{" |
| for _, f := range this.To { |
| repeatedStringForTo += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForTo += "}" |
| s := strings.Join([]string{`&NetworkPolicyEgressRule{`, |
| `Ports:` + repeatedStringForPorts + `,`, |
| `To:` + repeatedStringForTo + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicyIngressRule) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForPorts := "[]NetworkPolicyPort{" |
| for _, f := range this.Ports { |
| repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForPorts += "}" |
| repeatedStringForFrom := "[]NetworkPolicyPeer{" |
| for _, f := range this.From { |
| repeatedStringForFrom += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForFrom += "}" |
| s := strings.Join([]string{`&NetworkPolicyIngressRule{`, |
| `Ports:` + repeatedStringForPorts + `,`, |
| `From:` + repeatedStringForFrom + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicyList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]NetworkPolicy{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&NetworkPolicyList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicyPeer) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&NetworkPolicyPeer{`, |
| `PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`, |
| `NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`, |
| `IPBlock:` + strings.Replace(this.IPBlock.String(), "IPBlock", "IPBlock", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicyPort) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&NetworkPolicyPort{`, |
| `Protocol:` + valueToStringGenerated(this.Protocol) + `,`, |
| `Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "intstr.IntOrString", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *NetworkPolicySpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForIngress := "[]NetworkPolicyIngressRule{" |
| for _, f := range this.Ingress { |
| repeatedStringForIngress += strings.Replace(strings.Replace(f.String(), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForIngress += "}" |
| repeatedStringForEgress := "[]NetworkPolicyEgressRule{" |
| for _, f := range this.Egress { |
| repeatedStringForEgress += strings.Replace(strings.Replace(f.String(), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForEgress += "}" |
| s := strings.Join([]string{`&NetworkPolicySpec{`, |
| `PodSelector:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "v1.LabelSelector", 1), `&`, ``, 1) + `,`, |
| `Ingress:` + repeatedStringForIngress + `,`, |
| `Egress:` + repeatedStringForEgress + `,`, |
| `PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *PodSecurityPolicy) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&PodSecurityPolicy{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodSecurityPolicySpec", "PodSecurityPolicySpec", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *PodSecurityPolicyList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]PodSecurityPolicy{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "PodSecurityPolicy", "PodSecurityPolicy", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&PodSecurityPolicyList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *PodSecurityPolicySpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForHostPorts := "[]HostPortRange{" |
| for _, f := range this.HostPorts { |
| repeatedStringForHostPorts += strings.Replace(strings.Replace(f.String(), "HostPortRange", "HostPortRange", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForHostPorts += "}" |
| repeatedStringForAllowedHostPaths := "[]AllowedHostPath{" |
| for _, f := range this.AllowedHostPaths { |
| repeatedStringForAllowedHostPaths += strings.Replace(strings.Replace(f.String(), "AllowedHostPath", "AllowedHostPath", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForAllowedHostPaths += "}" |
| repeatedStringForAllowedFlexVolumes := "[]AllowedFlexVolume{" |
| for _, f := range this.AllowedFlexVolumes { |
| repeatedStringForAllowedFlexVolumes += strings.Replace(strings.Replace(f.String(), "AllowedFlexVolume", "AllowedFlexVolume", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForAllowedFlexVolumes += "}" |
| repeatedStringForAllowedCSIDrivers := "[]AllowedCSIDriver{" |
| for _, f := range this.AllowedCSIDrivers { |
| repeatedStringForAllowedCSIDrivers += strings.Replace(strings.Replace(f.String(), "AllowedCSIDriver", "AllowedCSIDriver", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForAllowedCSIDrivers += "}" |
| s := strings.Join([]string{`&PodSecurityPolicySpec{`, |
| `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`, |
| `DefaultAddCapabilities:` + fmt.Sprintf("%v", this.DefaultAddCapabilities) + `,`, |
| `RequiredDropCapabilities:` + fmt.Sprintf("%v", this.RequiredDropCapabilities) + `,`, |
| `AllowedCapabilities:` + fmt.Sprintf("%v", this.AllowedCapabilities) + `,`, |
| `Volumes:` + fmt.Sprintf("%v", this.Volumes) + `,`, |
| `HostNetwork:` + fmt.Sprintf("%v", this.HostNetwork) + `,`, |
| `HostPorts:` + repeatedStringForHostPorts + `,`, |
| `HostPID:` + fmt.Sprintf("%v", this.HostPID) + `,`, |
| `HostIPC:` + fmt.Sprintf("%v", this.HostIPC) + `,`, |
| `SELinux:` + strings.Replace(strings.Replace(this.SELinux.String(), "SELinuxStrategyOptions", "SELinuxStrategyOptions", 1), `&`, ``, 1) + `,`, |
| `RunAsUser:` + strings.Replace(strings.Replace(this.RunAsUser.String(), "RunAsUserStrategyOptions", "RunAsUserStrategyOptions", 1), `&`, ``, 1) + `,`, |
| `SupplementalGroups:` + strings.Replace(strings.Replace(this.SupplementalGroups.String(), "SupplementalGroupsStrategyOptions", "SupplementalGroupsStrategyOptions", 1), `&`, ``, 1) + `,`, |
| `FSGroup:` + strings.Replace(strings.Replace(this.FSGroup.String(), "FSGroupStrategyOptions", "FSGroupStrategyOptions", 1), `&`, ``, 1) + `,`, |
| `ReadOnlyRootFilesystem:` + fmt.Sprintf("%v", this.ReadOnlyRootFilesystem) + `,`, |
| `DefaultAllowPrivilegeEscalation:` + valueToStringGenerated(this.DefaultAllowPrivilegeEscalation) + `,`, |
| `AllowPrivilegeEscalation:` + valueToStringGenerated(this.AllowPrivilegeEscalation) + `,`, |
| `AllowedHostPaths:` + repeatedStringForAllowedHostPaths + `,`, |
| `AllowedFlexVolumes:` + repeatedStringForAllowedFlexVolumes + `,`, |
| `AllowedUnsafeSysctls:` + fmt.Sprintf("%v", this.AllowedUnsafeSysctls) + `,`, |
| `ForbiddenSysctls:` + fmt.Sprintf("%v", this.ForbiddenSysctls) + `,`, |
| `AllowedProcMountTypes:` + fmt.Sprintf("%v", this.AllowedProcMountTypes) + `,`, |
| `RunAsGroup:` + strings.Replace(this.RunAsGroup.String(), "RunAsGroupStrategyOptions", "RunAsGroupStrategyOptions", 1) + `,`, |
| `AllowedCSIDrivers:` + repeatedStringForAllowedCSIDrivers + `,`, |
| `RuntimeClass:` + strings.Replace(this.RuntimeClass.String(), "RuntimeClassStrategyOptions", "RuntimeClassStrategyOptions", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ReplicaSet) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ReplicaSet{`, |
| `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`, |
| `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`, |
| `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ReplicaSetCondition) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ReplicaSetCondition{`, |
| `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 *ReplicaSetList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForItems := "[]ReplicaSet{" |
| for _, f := range this.Items { |
| repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForItems += "}" |
| s := strings.Join([]string{`&ReplicaSetList{`, |
| `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + repeatedStringForItems + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ReplicaSetSpec) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ReplicaSetSpec{`, |
| `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) + `,`, |
| `MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ReplicaSetStatus) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForConditions := "[]ReplicaSetCondition{" |
| for _, f := range this.Conditions { |
| repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForConditions += "}" |
| s := strings.Join([]string{`&ReplicaSetStatus{`, |
| `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`, |
| `FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`, |
| `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`, |
| `ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`, |
| `AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`, |
| `Conditions:` + repeatedStringForConditions + `,`, |
| `}`, |
| }, "") |
| 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 *RollingUpdateDaemonSet) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RollingUpdateDaemonSet{`, |
| `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`, |
| `}`, |
| }, "") |
| 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 *RunAsGroupStrategyOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForRanges := "[]IDRange{" |
| for _, f := range this.Ranges { |
| repeatedStringForRanges += strings.Replace(strings.Replace(f.String(), "IDRange", "IDRange", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForRanges += "}" |
| s := strings.Join([]string{`&RunAsGroupStrategyOptions{`, |
| `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, |
| `Ranges:` + repeatedStringForRanges + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RunAsUserStrategyOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForRanges := "[]IDRange{" |
| for _, f := range this.Ranges { |
| repeatedStringForRanges += strings.Replace(strings.Replace(f.String(), "IDRange", "IDRange", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForRanges += "}" |
| s := strings.Join([]string{`&RunAsUserStrategyOptions{`, |
| `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, |
| `Ranges:` + repeatedStringForRanges + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RuntimeClassStrategyOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RuntimeClassStrategyOptions{`, |
| `AllowedRuntimeClassNames:` + fmt.Sprintf("%v", this.AllowedRuntimeClassNames) + `,`, |
| `DefaultRuntimeClassName:` + valueToStringGenerated(this.DefaultRuntimeClassName) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *SELinuxStrategyOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&SELinuxStrategyOptions{`, |
| `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, |
| `SELinuxOptions:` + strings.Replace(fmt.Sprintf("%v", this.SELinuxOptions), "SELinuxOptions", "v11.SELinuxOptions", 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) |
| } |
| github_com_gogo_protobuf_sortkeys.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 *SupplementalGroupsStrategyOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| repeatedStringForRanges := "[]IDRange{" |
| for _, f := range this.Ranges { |
| repeatedStringForRanges += strings.Replace(strings.Replace(f.String(), "IDRange", "IDRange", 1), `&`, ``, 1) + "," |
| } |
| repeatedStringForRanges += "}" |
| s := strings.Join([]string{`&SupplementalGroupsStrategyOptions{`, |
| `Rule:` + fmt.Sprintf("%v", this.Rule) + `,`, |
| `Ranges:` + repeatedStringForRanges + `,`, |
| `}`, |
| }, "") |
| 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 *AllowedCSIDriver) 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: AllowedCSIDriver: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: AllowedCSIDriver: 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 |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *AllowedFlexVolume) 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: AllowedFlexVolume: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: AllowedFlexVolume: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Driver", 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.Driver = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *AllowedHostPath) 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: AllowedHostPath: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: AllowedHostPath: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", 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.PathPrefix = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", 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.ReadOnly = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DaemonSet) 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: DaemonSet: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DaemonSet: 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DaemonSetCondition) 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: DaemonSetCondition: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DaemonSetCondition: 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 = DaemonSetConditionType(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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DaemonSetList) 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: DaemonSetList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DaemonSetList: 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, DaemonSet{}) |
| if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DaemonSetSpec) 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: DaemonSetSpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| 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 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| 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 4: |
| 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 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType) |
| } |
| m.TemplateGeneration = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.TemplateGeneration |= int64(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 |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DaemonSetStatus) 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: DaemonSetStatus: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType) |
| } |
| m.CurrentNumberScheduled = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.CurrentNumberScheduled |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType) |
| } |
| m.NumberMisscheduled = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.NumberMisscheduled |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType) |
| } |
| m.DesiredNumberScheduled = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.DesiredNumberScheduled |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 4: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType) |
| } |
| m.NumberReady = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.NumberReady |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 5: |
| 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 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType) |
| } |
| m.UpdatedNumberScheduled = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.UpdatedNumberScheduled |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType) |
| } |
| m.NumberAvailable = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.NumberAvailable |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 8: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType) |
| } |
| m.NumberUnavailable = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.NumberUnavailable |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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, DaemonSetCondition{}) |
| if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DaemonSetUpdateStrategy) 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: DaemonSetUpdateStrategy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DaemonSetUpdateStrategy: 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 = DaemonSetUpdateStrategyType(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 = &RollingUpdateDaemonSet{} |
| } |
| 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *FSGroupStrategyOptions) 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: FSGroupStrategyOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: FSGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rule", 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.Rule = FSGroupStrategyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ranges", 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.Ranges = append(m.Ranges, IDRange{}) |
| if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *HTTPIngressPath) 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: HTTPIngressPath: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Path", 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.Path = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Backend", 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.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PathType", 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 |
| } |
| s := PathType(dAtA[iNdEx:postIndex]) |
| m.PathType = &s |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *HTTPIngressRuleValue) 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: HTTPIngressRuleValue: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Paths", 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.Paths = append(m.Paths, HTTPIngressPath{}) |
| if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *HostPortRange) 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: HostPortRange: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: HostPortRange: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType) |
| } |
| m.Min = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Min |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) |
| } |
| m.Max = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Max |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IDRange) 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: IDRange: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IDRange: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Min", wireType) |
| } |
| m.Min = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Min |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Max", wireType) |
| } |
| m.Max = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Max |= int64(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IPBlock) 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: IPBlock: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CIDR", 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.CIDR = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Except", 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.Except = append(m.Except, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Ingress) 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: Ingress: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Ingress: 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressBackend) 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: IngressBackend: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| 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 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", 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.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Resource", 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.Resource == nil { |
| m.Resource = &v11.TypedLocalObjectReference{} |
| } |
| if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressList) 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: IngressList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressList: 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, Ingress{}) |
| if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressRule) 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: IngressRule: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Host", 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.Host = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", 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.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressRuleValue) 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: IngressRuleValue: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HTTP", 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.HTTP == nil { |
| m.HTTP = &HTTPIngressRuleValue{} |
| } |
| if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressSpec) 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: IngressSpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Backend", 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.Backend == nil { |
| m.Backend = &IngressBackend{} |
| } |
| if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TLS", 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.TLS = append(m.TLS, IngressTLS{}) |
| if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rules", 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.Rules = append(m.Rules, IngressRule{}) |
| if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IngressClassName", 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 |
| } |
| s := string(dAtA[iNdEx:postIndex]) |
| m.IngressClassName = &s |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressStatus) 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: IngressStatus: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", 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.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *IngressTLS) 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: IngressTLS: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Hosts", 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.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SecretName", 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.SecretName = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicy) 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: NetworkPolicy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicy: 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 |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicyEgressRule) 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: NetworkPolicyEgressRule: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ports", 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.Ports = append(m.Ports, NetworkPolicyPort{}) |
| if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field To", 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.To = append(m.To, NetworkPolicyPeer{}) |
| if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicyIngressRule) 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: NetworkPolicyIngressRule: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ports", 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.Ports = append(m.Ports, NetworkPolicyPort{}) |
| if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = append(m.From, NetworkPolicyPeer{}) |
| if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicyList) 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: NetworkPolicyList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicyList: 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, NetworkPolicy{}) |
| if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicyPeer) 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: NetworkPolicyPeer: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", 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.PodSelector == nil { |
| m.PodSelector = &v1.LabelSelector{} |
| } |
| if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", 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.NamespaceSelector == nil { |
| m.NamespaceSelector = &v1.LabelSelector{} |
| } |
| if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", 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.IPBlock == nil { |
| m.IPBlock = &IPBlock{} |
| } |
| if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicyPort) 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: NetworkPolicyPort: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Protocol", 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 |
| } |
| s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex]) |
| m.Protocol = &s |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Port", 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.Port == nil { |
| m.Port = &intstr.IntOrString{} |
| } |
| if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *NetworkPolicySpec) 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: NetworkPolicySpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", 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.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ingress", 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.Ingress = append(m.Ingress, NetworkPolicyIngressRule{}) |
| if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Egress", 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.Egress = append(m.Egress, NetworkPolicyEgressRule{}) |
| if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", 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.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *PodSecurityPolicy) 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: PodSecurityPolicy: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: PodSecurityPolicy: 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 |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *PodSecurityPolicyList) 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: PodSecurityPolicyList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: PodSecurityPolicyList: 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, PodSecurityPolicy{}) |
| if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *PodSecurityPolicySpec) 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: PodSecurityPolicySpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: PodSecurityPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Privileged", 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.Privileged = bool(v != 0) |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddCapabilities", 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.DefaultAddCapabilities = append(m.DefaultAddCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RequiredDropCapabilities", 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.RequiredDropCapabilities = append(m.RequiredDropCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedCapabilities", 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.AllowedCapabilities = append(m.AllowedCapabilities, k8s_io_api_core_v1.Capability(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Volumes", 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.Volumes = append(m.Volumes, FSType(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HostNetwork", 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.HostNetwork = bool(v != 0) |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HostPorts", 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.HostPorts = append(m.HostPorts, HostPortRange{}) |
| if err := m.HostPorts[len(m.HostPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 8: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HostPID", 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.HostPID = bool(v != 0) |
| case 9: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field HostIPC", 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.HostIPC = bool(v != 0) |
| case 10: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SELinux", 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.SELinux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 11: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", 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.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 12: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", 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.SupplementalGroups.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 13: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field FSGroup", 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.FSGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 14: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ReadOnlyRootFilesystem", 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.ReadOnlyRootFilesystem = bool(v != 0) |
| case 15: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DefaultAllowPrivilegeEscalation", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| b := bool(v != 0) |
| m.DefaultAllowPrivilegeEscalation = &b |
| case 16: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowPrivilegeEscalation", wireType) |
| } |
| var v int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= int(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| b := bool(v != 0) |
| m.AllowPrivilegeEscalation = &b |
| case 17: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedHostPaths", 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.AllowedHostPaths = append(m.AllowedHostPaths, AllowedHostPath{}) |
| if err := m.AllowedHostPaths[len(m.AllowedHostPaths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 18: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedFlexVolumes", 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.AllowedFlexVolumes = append(m.AllowedFlexVolumes, AllowedFlexVolume{}) |
| if err := m.AllowedFlexVolumes[len(m.AllowedFlexVolumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 19: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedUnsafeSysctls", 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.AllowedUnsafeSysctls = append(m.AllowedUnsafeSysctls, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 20: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ForbiddenSysctls", 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.ForbiddenSysctls = append(m.ForbiddenSysctls, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 21: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedProcMountTypes", 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.AllowedProcMountTypes = append(m.AllowedProcMountTypes, k8s_io_api_core_v1.ProcMountType(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 22: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", 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.RunAsGroup == nil { |
| m.RunAsGroup = &RunAsGroupStrategyOptions{} |
| } |
| if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 23: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedCSIDrivers", 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.AllowedCSIDrivers = append(m.AllowedCSIDrivers, AllowedCSIDriver{}) |
| if err := m.AllowedCSIDrivers[len(m.AllowedCSIDrivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 24: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RuntimeClass", 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.RuntimeClass == nil { |
| m.RuntimeClass = &RuntimeClassStrategyOptions{} |
| } |
| if err := m.RuntimeClass.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ReplicaSet) 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: ReplicaSet: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ReplicaSet: 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ReplicaSetCondition) 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: ReplicaSetCondition: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ReplicaSetCondition: 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 = ReplicaSetConditionType(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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ReplicaSetList) 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: ReplicaSetList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ReplicaSetList: 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, ReplicaSet{}) |
| if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ReplicaSetSpec) 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: ReplicaSetSpec: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ReplicaSetSpec: 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 != 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 |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ReplicaSetStatus) 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: ReplicaSetStatus: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ReplicaSetStatus: 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 != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType) |
| } |
| m.FullyLabeledReplicas = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.FullyLabeledReplicas |= int32(b&0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 3: |
| 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 4: |
| 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 5: |
| 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 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, ReplicaSetCondition{}) |
| if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RollingUpdateDaemonSet) 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: RollingUpdateDaemonSet: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RollingUpdateDaemonSet: 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 |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RunAsGroupStrategyOptions) 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: RunAsGroupStrategyOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RunAsGroupStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rule", 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.Rule = RunAsGroupStrategy(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ranges", 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.Ranges = append(m.Ranges, IDRange{}) |
| if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RunAsUserStrategyOptions) 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: RunAsUserStrategyOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RunAsUserStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rule", 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.Rule = RunAsUserStrategy(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ranges", 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.Ranges = append(m.Ranges, IDRange{}) |
| if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RuntimeClassStrategyOptions) 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: RuntimeClassStrategyOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RuntimeClassStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field AllowedRuntimeClassNames", 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.AllowedRuntimeClassNames = append(m.AllowedRuntimeClassNames, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DefaultRuntimeClassName", 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 |
| } |
| s := string(dAtA[iNdEx:postIndex]) |
| m.DefaultRuntimeClassName = &s |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *SELinuxStrategyOptions) 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: SELinuxStrategyOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: SELinuxStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rule", 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.Rule = SELinuxStrategy(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SELinuxOptions", 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.SELinuxOptions == nil { |
| m.SELinuxOptions = &v11.SELinuxOptions{} |
| } |
| if err := m.SELinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (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 { |
| 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 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *SupplementalGroupsStrategyOptions) 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: SupplementalGroupsStrategyOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: SupplementalGroupsStrategyOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Rule", 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.Rule = SupplementalGroupsStrategyType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Ranges", 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.Ranges = append(m.Ranges, IDRange{}) |
| if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) < 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") |
| ) |