| /* |
| 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. |
| // source: k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto |
| // DO NOT EDIT! |
| |
| /* |
| Package v1 is a generated protocol buffer package. |
| |
| It is generated from these files: |
| k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto |
| |
| It has these top-level messages: |
| APIGroup |
| APIGroupList |
| APIResource |
| APIResourceList |
| APIVersions |
| DeleteOptions |
| Duration |
| ExportOptions |
| GetOptions |
| GroupKind |
| GroupResource |
| GroupVersion |
| GroupVersionForDiscovery |
| GroupVersionKind |
| GroupVersionResource |
| Initializer |
| Initializers |
| LabelSelector |
| LabelSelectorRequirement |
| List |
| ListMeta |
| ListOptions |
| MicroTime |
| ObjectMeta |
| OwnerReference |
| Patch |
| Preconditions |
| RootPaths |
| ServerAddressByClientCIDR |
| Status |
| StatusCause |
| StatusDetails |
| Time |
| Timestamp |
| TypeMeta |
| Verbs |
| WatchEvent |
| */ |
| package v1 |
| |
| import proto "github.com/gogo/protobuf/proto" |
| import fmt "fmt" |
| import math "math" |
| |
| import k8s_io_apimachinery_pkg_runtime "k8s.io/apimachinery/pkg/runtime" |
| |
| import time "time" |
| import k8s_io_apimachinery_pkg_types "k8s.io/apimachinery/pkg/types" |
| |
| import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" |
| |
| import strings "strings" |
| import reflect "reflect" |
| |
| import io "io" |
| |
| // Reference imports to suppress errors if they are not otherwise used. |
| var _ = proto.Marshal |
| var _ = fmt.Errorf |
| var _ = math.Inf |
| var _ = time.Kitchen |
| |
| // 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package |
| |
| func (m *APIGroup) Reset() { *m = APIGroup{} } |
| func (*APIGroup) ProtoMessage() {} |
| func (*APIGroup) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} } |
| |
| func (m *APIGroupList) Reset() { *m = APIGroupList{} } |
| func (*APIGroupList) ProtoMessage() {} |
| func (*APIGroupList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} } |
| |
| func (m *APIResource) Reset() { *m = APIResource{} } |
| func (*APIResource) ProtoMessage() {} |
| func (*APIResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} } |
| |
| func (m *APIResourceList) Reset() { *m = APIResourceList{} } |
| func (*APIResourceList) ProtoMessage() {} |
| func (*APIResourceList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} } |
| |
| func (m *APIVersions) Reset() { *m = APIVersions{} } |
| func (*APIVersions) ProtoMessage() {} |
| func (*APIVersions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{4} } |
| |
| func (m *DeleteOptions) Reset() { *m = DeleteOptions{} } |
| func (*DeleteOptions) ProtoMessage() {} |
| func (*DeleteOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{5} } |
| |
| func (m *Duration) Reset() { *m = Duration{} } |
| func (*Duration) ProtoMessage() {} |
| func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{6} } |
| |
| func (m *ExportOptions) Reset() { *m = ExportOptions{} } |
| func (*ExportOptions) ProtoMessage() {} |
| func (*ExportOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{7} } |
| |
| func (m *GetOptions) Reset() { *m = GetOptions{} } |
| func (*GetOptions) ProtoMessage() {} |
| func (*GetOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} } |
| |
| func (m *GroupKind) Reset() { *m = GroupKind{} } |
| func (*GroupKind) ProtoMessage() {} |
| func (*GroupKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} } |
| |
| func (m *GroupResource) Reset() { *m = GroupResource{} } |
| func (*GroupResource) ProtoMessage() {} |
| func (*GroupResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} } |
| |
| func (m *GroupVersion) Reset() { *m = GroupVersion{} } |
| func (*GroupVersion) ProtoMessage() {} |
| func (*GroupVersion) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} } |
| |
| func (m *GroupVersionForDiscovery) Reset() { *m = GroupVersionForDiscovery{} } |
| func (*GroupVersionForDiscovery) ProtoMessage() {} |
| func (*GroupVersionForDiscovery) Descriptor() ([]byte, []int) { |
| return fileDescriptorGenerated, []int{12} |
| } |
| |
| func (m *GroupVersionKind) Reset() { *m = GroupVersionKind{} } |
| func (*GroupVersionKind) ProtoMessage() {} |
| func (*GroupVersionKind) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} } |
| |
| func (m *GroupVersionResource) Reset() { *m = GroupVersionResource{} } |
| func (*GroupVersionResource) ProtoMessage() {} |
| func (*GroupVersionResource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} } |
| |
| func (m *Initializer) Reset() { *m = Initializer{} } |
| func (*Initializer) ProtoMessage() {} |
| func (*Initializer) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} } |
| |
| func (m *Initializers) Reset() { *m = Initializers{} } |
| func (*Initializers) ProtoMessage() {} |
| func (*Initializers) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} } |
| |
| func (m *LabelSelector) Reset() { *m = LabelSelector{} } |
| func (*LabelSelector) ProtoMessage() {} |
| func (*LabelSelector) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} } |
| |
| func (m *LabelSelectorRequirement) Reset() { *m = LabelSelectorRequirement{} } |
| func (*LabelSelectorRequirement) ProtoMessage() {} |
| func (*LabelSelectorRequirement) Descriptor() ([]byte, []int) { |
| return fileDescriptorGenerated, []int{18} |
| } |
| |
| func (m *List) Reset() { *m = List{} } |
| func (*List) ProtoMessage() {} |
| func (*List) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{19} } |
| |
| func (m *ListMeta) Reset() { *m = ListMeta{} } |
| func (*ListMeta) ProtoMessage() {} |
| func (*ListMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{20} } |
| |
| func (m *ListOptions) Reset() { *m = ListOptions{} } |
| func (*ListOptions) ProtoMessage() {} |
| func (*ListOptions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{21} } |
| |
| func (m *MicroTime) Reset() { *m = MicroTime{} } |
| func (*MicroTime) ProtoMessage() {} |
| func (*MicroTime) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{22} } |
| |
| func (m *ObjectMeta) Reset() { *m = ObjectMeta{} } |
| func (*ObjectMeta) ProtoMessage() {} |
| func (*ObjectMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{23} } |
| |
| func (m *OwnerReference) Reset() { *m = OwnerReference{} } |
| func (*OwnerReference) ProtoMessage() {} |
| func (*OwnerReference) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{24} } |
| |
| func (m *Patch) Reset() { *m = Patch{} } |
| func (*Patch) ProtoMessage() {} |
| func (*Patch) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{25} } |
| |
| func (m *Preconditions) Reset() { *m = Preconditions{} } |
| func (*Preconditions) ProtoMessage() {} |
| func (*Preconditions) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{26} } |
| |
| func (m *RootPaths) Reset() { *m = RootPaths{} } |
| func (*RootPaths) ProtoMessage() {} |
| func (*RootPaths) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{27} } |
| |
| func (m *ServerAddressByClientCIDR) Reset() { *m = ServerAddressByClientCIDR{} } |
| func (*ServerAddressByClientCIDR) ProtoMessage() {} |
| func (*ServerAddressByClientCIDR) Descriptor() ([]byte, []int) { |
| return fileDescriptorGenerated, []int{28} |
| } |
| |
| func (m *Status) Reset() { *m = Status{} } |
| func (*Status) ProtoMessage() {} |
| func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{29} } |
| |
| func (m *StatusCause) Reset() { *m = StatusCause{} } |
| func (*StatusCause) ProtoMessage() {} |
| func (*StatusCause) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{30} } |
| |
| func (m *StatusDetails) Reset() { *m = StatusDetails{} } |
| func (*StatusDetails) ProtoMessage() {} |
| func (*StatusDetails) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{31} } |
| |
| func (m *Time) Reset() { *m = Time{} } |
| func (*Time) ProtoMessage() {} |
| func (*Time) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{32} } |
| |
| func (m *Timestamp) Reset() { *m = Timestamp{} } |
| func (*Timestamp) ProtoMessage() {} |
| func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{33} } |
| |
| func (m *TypeMeta) Reset() { *m = TypeMeta{} } |
| func (*TypeMeta) ProtoMessage() {} |
| func (*TypeMeta) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{34} } |
| |
| func (m *Verbs) Reset() { *m = Verbs{} } |
| func (*Verbs) ProtoMessage() {} |
| func (*Verbs) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{35} } |
| |
| func (m *WatchEvent) Reset() { *m = WatchEvent{} } |
| func (*WatchEvent) ProtoMessage() {} |
| func (*WatchEvent) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{36} } |
| |
| func init() { |
| proto.RegisterType((*APIGroup)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroup") |
| proto.RegisterType((*APIGroupList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIGroupList") |
| proto.RegisterType((*APIResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResource") |
| proto.RegisterType((*APIResourceList)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIResourceList") |
| proto.RegisterType((*APIVersions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.APIVersions") |
| proto.RegisterType((*DeleteOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.DeleteOptions") |
| proto.RegisterType((*Duration)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Duration") |
| proto.RegisterType((*ExportOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ExportOptions") |
| proto.RegisterType((*GetOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GetOptions") |
| proto.RegisterType((*GroupKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupKind") |
| proto.RegisterType((*GroupResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupResource") |
| proto.RegisterType((*GroupVersion)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersion") |
| proto.RegisterType((*GroupVersionForDiscovery)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionForDiscovery") |
| proto.RegisterType((*GroupVersionKind)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionKind") |
| proto.RegisterType((*GroupVersionResource)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.GroupVersionResource") |
| proto.RegisterType((*Initializer)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializer") |
| proto.RegisterType((*Initializers)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Initializers") |
| proto.RegisterType((*LabelSelector)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector") |
| proto.RegisterType((*LabelSelectorRequirement)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement") |
| proto.RegisterType((*List)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.List") |
| proto.RegisterType((*ListMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta") |
| proto.RegisterType((*ListOptions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ListOptions") |
| proto.RegisterType((*MicroTime)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.MicroTime") |
| proto.RegisterType((*ObjectMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta") |
| proto.RegisterType((*OwnerReference)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.OwnerReference") |
| proto.RegisterType((*Patch)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Patch") |
| proto.RegisterType((*Preconditions)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Preconditions") |
| proto.RegisterType((*RootPaths)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.RootPaths") |
| proto.RegisterType((*ServerAddressByClientCIDR)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.ServerAddressByClientCIDR") |
| proto.RegisterType((*Status)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Status") |
| proto.RegisterType((*StatusCause)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusCause") |
| proto.RegisterType((*StatusDetails)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.StatusDetails") |
| proto.RegisterType((*Time)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Time") |
| proto.RegisterType((*Timestamp)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Timestamp") |
| proto.RegisterType((*TypeMeta)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.TypeMeta") |
| proto.RegisterType((*Verbs)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.Verbs") |
| proto.RegisterType((*WatchEvent)(nil), "k8s.io.apimachinery.pkg.apis.meta.v1.WatchEvent") |
| } |
| func (m *APIGroup) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *APIGroup) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i += copy(dAtA[i:], m.Name) |
| if len(m.Versions) > 0 { |
| for _, msg := range m.Versions { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.PreferredVersion.Size())) |
| n1, err := m.PreferredVersion.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n1 |
| if len(m.ServerAddressByClientCIDRs) > 0 { |
| for _, msg := range m.ServerAddressByClientCIDRs { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *APIGroupList) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *APIGroupList) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Groups) > 0 { |
| for _, msg := range m.Groups { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *APIResource) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *APIResource) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i += copy(dAtA[i:], m.Name) |
| dAtA[i] = 0x10 |
| i++ |
| if m.Namespaced { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) |
| i += copy(dAtA[i:], m.Kind) |
| if m.Verbs != nil { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Verbs.Size())) |
| n2, err := m.Verbs.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n2 |
| } |
| if len(m.ShortNames) > 0 { |
| for _, s := range m.ShortNames { |
| dAtA[i] = 0x2a |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| dAtA[i] = 0x32 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.SingularName))) |
| i += copy(dAtA[i:], m.SingularName) |
| if len(m.Categories) > 0 { |
| for _, s := range m.Categories { |
| dAtA[i] = 0x3a |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| dAtA[i] = 0x42 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x4a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version))) |
| i += copy(dAtA[i:], m.Version) |
| return i, nil |
| } |
| |
| func (m *APIResourceList) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *APIResourceList) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion))) |
| i += copy(dAtA[i:], m.GroupVersion) |
| if len(m.APIResources) > 0 { |
| for _, msg := range m.APIResources { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *APIVersions) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *APIVersions) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Versions) > 0 { |
| for _, s := range m.Versions { |
| dAtA[i] = 0xa |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| if len(m.ServerAddressByClientCIDRs) > 0 { |
| for _, msg := range m.ServerAddressByClientCIDRs { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *DeleteOptions) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *DeleteOptions) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.GracePeriodSeconds != nil { |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.GracePeriodSeconds)) |
| } |
| if m.Preconditions != nil { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Preconditions.Size())) |
| n3, err := m.Preconditions.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n3 |
| } |
| if m.OrphanDependents != nil { |
| dAtA[i] = 0x18 |
| i++ |
| if *m.OrphanDependents { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| } |
| if m.PropagationPolicy != nil { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PropagationPolicy))) |
| i += copy(dAtA[i:], *m.PropagationPolicy) |
| } |
| return i, nil |
| } |
| |
| func (m *Duration) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Duration) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Duration)) |
| return i, nil |
| } |
| |
| func (m *ExportOptions) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ExportOptions) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0x8 |
| i++ |
| if m.Export { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| dAtA[i] = 0x10 |
| i++ |
| if m.Exact { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| return i, nil |
| } |
| |
| func (m *GetOptions) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GetOptions) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion))) |
| i += copy(dAtA[i:], m.ResourceVersion) |
| dAtA[i] = 0x10 |
| i++ |
| if m.IncludeUninitialized { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| return i, nil |
| } |
| |
| func (m *GroupKind) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GroupKind) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) |
| i += copy(dAtA[i:], m.Kind) |
| return i, nil |
| } |
| |
| func (m *GroupResource) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GroupResource) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource))) |
| i += copy(dAtA[i:], m.Resource) |
| return i, nil |
| } |
| |
| func (m *GroupVersion) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GroupVersion) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version))) |
| i += copy(dAtA[i:], m.Version) |
| return i, nil |
| } |
| |
| func (m *GroupVersionForDiscovery) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GroupVersionForDiscovery) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.GroupVersion))) |
| i += copy(dAtA[i:], m.GroupVersion) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version))) |
| i += copy(dAtA[i:], m.Version) |
| return i, nil |
| } |
| |
| func (m *GroupVersionKind) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GroupVersionKind) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version))) |
| i += copy(dAtA[i:], m.Version) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) |
| i += copy(dAtA[i:], m.Kind) |
| return i, nil |
| } |
| |
| func (m *GroupVersionResource) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *GroupVersionResource) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Version))) |
| i += copy(dAtA[i:], m.Version) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Resource))) |
| i += copy(dAtA[i:], m.Resource) |
| return i, nil |
| } |
| |
| func (m *Initializer) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Initializer) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i += copy(dAtA[i:], m.Name) |
| return i, nil |
| } |
| |
| func (m *Initializers) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Initializers) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Pending) > 0 { |
| for _, msg := range m.Pending { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if m.Result != nil { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Result.Size())) |
| n4, err := m.Result.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n4 |
| } |
| return i, nil |
| } |
| |
| func (m *LabelSelector) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *LabelSelector) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.MatchLabels) > 0 { |
| keysForMatchLabels := make([]string, 0, len(m.MatchLabels)) |
| for k := range m.MatchLabels { |
| keysForMatchLabels = append(keysForMatchLabels, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels) |
| for _, k := range keysForMatchLabels { |
| dAtA[i] = 0xa |
| i++ |
| v := m.MatchLabels[string(k)] |
| mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(k))) |
| i += copy(dAtA[i:], k) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(v))) |
| i += copy(dAtA[i:], v) |
| } |
| } |
| if len(m.MatchExpressions) > 0 { |
| for _, msg := range m.MatchExpressions { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *LabelSelectorRequirement) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *LabelSelectorRequirement) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key))) |
| i += copy(dAtA[i:], m.Key) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator))) |
| i += copy(dAtA[i:], m.Operator) |
| if len(m.Values) > 0 { |
| for _, s := range m.Values { |
| dAtA[i] = 0x1a |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *List) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *List) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) |
| n5, err := m.ListMeta.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n5 |
| if len(m.Items) > 0 { |
| for _, msg := range m.Items { |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *ListMeta) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ListMeta) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink))) |
| i += copy(dAtA[i:], m.SelfLink) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion))) |
| i += copy(dAtA[i:], m.ResourceVersion) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue))) |
| i += copy(dAtA[i:], m.Continue) |
| return i, nil |
| } |
| |
| func (m *ListOptions) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ListOptions) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.LabelSelector))) |
| i += copy(dAtA[i:], m.LabelSelector) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.FieldSelector))) |
| i += copy(dAtA[i:], m.FieldSelector) |
| dAtA[i] = 0x18 |
| i++ |
| if m.Watch { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion))) |
| i += copy(dAtA[i:], m.ResourceVersion) |
| if m.TimeoutSeconds != nil { |
| dAtA[i] = 0x28 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.TimeoutSeconds)) |
| } |
| dAtA[i] = 0x30 |
| i++ |
| if m.IncludeUninitialized { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| dAtA[i] = 0x38 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Limit)) |
| dAtA[i] = 0x42 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Continue))) |
| i += copy(dAtA[i:], m.Continue) |
| return i, nil |
| } |
| |
| func (m *ObjectMeta) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ObjectMeta) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i += copy(dAtA[i:], m.Name) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.GenerateName))) |
| i += copy(dAtA[i:], m.GenerateName) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace))) |
| i += copy(dAtA[i:], m.Namespace) |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.SelfLink))) |
| i += copy(dAtA[i:], m.SelfLink) |
| dAtA[i] = 0x2a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID))) |
| i += copy(dAtA[i:], m.UID) |
| dAtA[i] = 0x32 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ResourceVersion))) |
| i += copy(dAtA[i:], m.ResourceVersion) |
| dAtA[i] = 0x38 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Generation)) |
| dAtA[i] = 0x42 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.CreationTimestamp.Size())) |
| n6, err := m.CreationTimestamp.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n6 |
| if m.DeletionTimestamp != nil { |
| dAtA[i] = 0x4a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.DeletionTimestamp.Size())) |
| n7, err := m.DeletionTimestamp.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n7 |
| } |
| if m.DeletionGracePeriodSeconds != nil { |
| dAtA[i] = 0x50 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(*m.DeletionGracePeriodSeconds)) |
| } |
| if len(m.Labels) > 0 { |
| keysForLabels := make([]string, 0, len(m.Labels)) |
| for k := range m.Labels { |
| keysForLabels = append(keysForLabels, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) |
| for _, k := range keysForLabels { |
| dAtA[i] = 0x5a |
| i++ |
| v := m.Labels[string(k)] |
| mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(k))) |
| i += copy(dAtA[i:], k) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(v))) |
| i += copy(dAtA[i:], v) |
| } |
| } |
| if len(m.Annotations) > 0 { |
| keysForAnnotations := make([]string, 0, len(m.Annotations)) |
| for k := range m.Annotations { |
| keysForAnnotations = append(keysForAnnotations, string(k)) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) |
| for _, k := range keysForAnnotations { |
| dAtA[i] = 0x62 |
| i++ |
| v := m.Annotations[string(k)] |
| mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(k))) |
| i += copy(dAtA[i:], k) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(v))) |
| i += copy(dAtA[i:], v) |
| } |
| } |
| if len(m.OwnerReferences) > 0 { |
| for _, msg := range m.OwnerReferences { |
| dAtA[i] = 0x6a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| if len(m.Finalizers) > 0 { |
| for _, s := range m.Finalizers { |
| dAtA[i] = 0x72 |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| dAtA[i] = 0x7a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClusterName))) |
| i += copy(dAtA[i:], m.ClusterName) |
| if m.Initializers != nil { |
| dAtA[i] = 0x82 |
| i++ |
| dAtA[i] = 0x1 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Initializers.Size())) |
| n8, err := m.Initializers.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n8 |
| } |
| return i, nil |
| } |
| |
| func (m *OwnerReference) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *OwnerReference) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) |
| i += copy(dAtA[i:], m.Kind) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i += copy(dAtA[i:], m.Name) |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID))) |
| i += copy(dAtA[i:], m.UID) |
| dAtA[i] = 0x2a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion))) |
| i += copy(dAtA[i:], m.APIVersion) |
| if m.Controller != nil { |
| dAtA[i] = 0x30 |
| i++ |
| if *m.Controller { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| } |
| if m.BlockOwnerDeletion != nil { |
| dAtA[i] = 0x38 |
| i++ |
| if *m.BlockOwnerDeletion { |
| dAtA[i] = 1 |
| } else { |
| dAtA[i] = 0 |
| } |
| i++ |
| } |
| return i, nil |
| } |
| |
| func (m *Patch) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Patch) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| return i, nil |
| } |
| |
| func (m *Preconditions) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Preconditions) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if m.UID != nil { |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UID))) |
| i += copy(dAtA[i:], *m.UID) |
| } |
| return i, nil |
| } |
| |
| func (m *RootPaths) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *RootPaths) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m.Paths) > 0 { |
| for _, s := range m.Paths { |
| dAtA[i] = 0xa |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *ServerAddressByClientCIDR) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *ServerAddressByClientCIDR) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ClientCIDR))) |
| i += copy(dAtA[i:], m.ClientCIDR) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServerAddress))) |
| i += copy(dAtA[i:], m.ServerAddress) |
| return i, nil |
| } |
| |
| func (m *Status) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Status) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) |
| n9, err := m.ListMeta.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n9 |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) |
| i += copy(dAtA[i:], m.Status) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) |
| i += copy(dAtA[i:], m.Message) |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason))) |
| i += copy(dAtA[i:], m.Reason) |
| if m.Details != nil { |
| dAtA[i] = 0x2a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Details.Size())) |
| n10, err := m.Details.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n10 |
| } |
| dAtA[i] = 0x30 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Code)) |
| return i, nil |
| } |
| |
| func (m *StatusCause) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatusCause) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) |
| i += copy(dAtA[i:], m.Type) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) |
| i += copy(dAtA[i:], m.Message) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Field))) |
| i += copy(dAtA[i:], m.Field) |
| return i, nil |
| } |
| |
| func (m *StatusDetails) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *StatusDetails) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name))) |
| i += copy(dAtA[i:], m.Name) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Group))) |
| i += copy(dAtA[i:], m.Group) |
| dAtA[i] = 0x1a |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) |
| i += copy(dAtA[i:], m.Kind) |
| if len(m.Causes) > 0 { |
| for _, msg := range m.Causes { |
| dAtA[i] = 0x22 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) |
| n, err := msg.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n |
| } |
| } |
| dAtA[i] = 0x28 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.RetryAfterSeconds)) |
| dAtA[i] = 0x32 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.UID))) |
| i += copy(dAtA[i:], m.UID) |
| return i, nil |
| } |
| |
| func (m *Timestamp) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *Timestamp) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0x8 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Seconds)) |
| dAtA[i] = 0x10 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Nanos)) |
| return i, nil |
| } |
| |
| func (m *TypeMeta) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *TypeMeta) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind))) |
| i += copy(dAtA[i:], m.Kind) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion))) |
| i += copy(dAtA[i:], m.APIVersion) |
| return i, nil |
| } |
| |
| func (m Verbs) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m Verbs) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| if len(m) > 0 { |
| for _, s := range m { |
| dAtA[i] = 0xa |
| i++ |
| l = len(s) |
| for l >= 1<<7 { |
| dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
| l >>= 7 |
| i++ |
| } |
| dAtA[i] = uint8(l) |
| i++ |
| i += copy(dAtA[i:], s) |
| } |
| } |
| return i, nil |
| } |
| |
| func (m *WatchEvent) Marshal() (dAtA []byte, err error) { |
| size := m.Size() |
| dAtA = make([]byte, size) |
| n, err := m.MarshalTo(dAtA) |
| if err != nil { |
| return nil, err |
| } |
| return dAtA[:n], nil |
| } |
| |
| func (m *WatchEvent) MarshalTo(dAtA []byte) (int, error) { |
| var i int |
| _ = i |
| var l int |
| _ = l |
| dAtA[i] = 0xa |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) |
| i += copy(dAtA[i:], m.Type) |
| dAtA[i] = 0x12 |
| i++ |
| i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size())) |
| n11, err := m.Object.MarshalTo(dAtA[i:]) |
| if err != nil { |
| return 0, err |
| } |
| i += n11 |
| return i, nil |
| } |
| |
| func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int { |
| dAtA[offset] = uint8(v) |
| dAtA[offset+1] = uint8(v >> 8) |
| dAtA[offset+2] = uint8(v >> 16) |
| dAtA[offset+3] = uint8(v >> 24) |
| dAtA[offset+4] = uint8(v >> 32) |
| dAtA[offset+5] = uint8(v >> 40) |
| dAtA[offset+6] = uint8(v >> 48) |
| dAtA[offset+7] = uint8(v >> 56) |
| return offset + 8 |
| } |
| func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int { |
| dAtA[offset] = uint8(v) |
| dAtA[offset+1] = uint8(v >> 8) |
| dAtA[offset+2] = uint8(v >> 16) |
| dAtA[offset+3] = uint8(v >> 24) |
| return offset + 4 |
| } |
| func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { |
| for v >= 1<<7 { |
| dAtA[offset] = uint8(v&0x7f | 0x80) |
| v >>= 7 |
| offset++ |
| } |
| dAtA[offset] = uint8(v) |
| return offset + 1 |
| } |
| func (m *APIGroup) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Versions) > 0 { |
| for _, e := range m.Versions { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| l = m.PreferredVersion.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.ServerAddressByClientCIDRs) > 0 { |
| for _, e := range m.ServerAddressByClientCIDRs { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *APIGroupList) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.Groups) > 0 { |
| for _, e := range m.Groups { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *APIResource) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 2 |
| l = len(m.Kind) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.Verbs != nil { |
| l = m.Verbs.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if len(m.ShortNames) > 0 { |
| for _, s := range m.ShortNames { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| l = len(m.SingularName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Categories) > 0 { |
| for _, s := range m.Categories { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Version) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *APIResourceList) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.GroupVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.APIResources) > 0 { |
| for _, e := range m.APIResources { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *APIVersions) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.Versions) > 0 { |
| for _, s := range m.Versions { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.ServerAddressByClientCIDRs) > 0 { |
| for _, e := range m.ServerAddressByClientCIDRs { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *DeleteOptions) Size() (n int) { |
| var l int |
| _ = l |
| if m.GracePeriodSeconds != nil { |
| n += 1 + sovGenerated(uint64(*m.GracePeriodSeconds)) |
| } |
| if m.Preconditions != nil { |
| l = m.Preconditions.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.OrphanDependents != nil { |
| n += 2 |
| } |
| if m.PropagationPolicy != nil { |
| l = len(*m.PropagationPolicy) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *Duration) Size() (n int) { |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Duration)) |
| return n |
| } |
| |
| func (m *ExportOptions) Size() (n int) { |
| var l int |
| _ = l |
| n += 2 |
| n += 2 |
| return n |
| } |
| |
| func (m *GetOptions) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.ResourceVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 2 |
| return n |
| } |
| |
| func (m *GroupKind) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Kind) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *GroupResource) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Resource) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *GroupVersion) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Version) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *GroupVersionForDiscovery) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.GroupVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Version) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *GroupVersionKind) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Version) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Kind) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *GroupVersionResource) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Version) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Resource) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *Initializer) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *Initializers) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.Pending) > 0 { |
| for _, e := range m.Pending { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if m.Result != nil { |
| l = m.Result.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *LabelSelector) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.MatchLabels) > 0 { |
| for k, v := range m.MatchLabels { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) |
| } |
| } |
| if len(m.MatchExpressions) > 0 { |
| for _, e := range m.MatchExpressions { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *LabelSelectorRequirement) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Key) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Operator) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Values) > 0 { |
| for _, s := range m.Values { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *List) Size() (n int) { |
| var l int |
| _ = l |
| l = m.ListMeta.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Items) > 0 { |
| for _, e := range m.Items { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *ListMeta) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.SelfLink) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.ResourceVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Continue) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *ListOptions) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.LabelSelector) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.FieldSelector) |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 2 |
| l = len(m.ResourceVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.TimeoutSeconds != nil { |
| n += 1 + sovGenerated(uint64(*m.TimeoutSeconds)) |
| } |
| n += 2 |
| n += 1 + sovGenerated(uint64(m.Limit)) |
| l = len(m.Continue) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *ObjectMeta) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.GenerateName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Namespace) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.SelfLink) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.UID) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.ResourceVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| n += 1 + sovGenerated(uint64(m.Generation)) |
| l = m.CreationTimestamp.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.DeletionTimestamp != nil { |
| l = m.DeletionTimestamp.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| if m.DeletionGracePeriodSeconds != nil { |
| n += 1 + sovGenerated(uint64(*m.DeletionGracePeriodSeconds)) |
| } |
| if len(m.Labels) > 0 { |
| for k, v := range m.Labels { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) |
| } |
| } |
| if len(m.Annotations) > 0 { |
| for k, v := range m.Annotations { |
| _ = k |
| _ = v |
| mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) |
| n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) |
| } |
| } |
| if len(m.OwnerReferences) > 0 { |
| for _, e := range m.OwnerReferences { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| if len(m.Finalizers) > 0 { |
| for _, s := range m.Finalizers { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| l = len(m.ClusterName) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.Initializers != nil { |
| l = m.Initializers.Size() |
| n += 2 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *OwnerReference) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Kind) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.UID) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.APIVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.Controller != nil { |
| n += 2 |
| } |
| if m.BlockOwnerDeletion != nil { |
| n += 2 |
| } |
| return n |
| } |
| |
| func (m *Patch) Size() (n int) { |
| var l int |
| _ = l |
| return n |
| } |
| |
| func (m *Preconditions) Size() (n int) { |
| var l int |
| _ = l |
| if m.UID != nil { |
| l = len(*m.UID) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| return n |
| } |
| |
| func (m *RootPaths) Size() (n int) { |
| var l int |
| _ = l |
| if len(m.Paths) > 0 { |
| for _, s := range m.Paths { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *ServerAddressByClientCIDR) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.ClientCIDR) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.ServerAddress) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *Status) Size() (n int) { |
| var l int |
| _ = l |
| l = m.ListMeta.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Status) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Message) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Reason) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if m.Details != nil { |
| l = m.Details.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| n += 1 + sovGenerated(uint64(m.Code)) |
| return n |
| } |
| |
| func (m *StatusCause) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Type) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Message) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Field) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *StatusDetails) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Name) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Group) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.Kind) |
| n += 1 + l + sovGenerated(uint64(l)) |
| if len(m.Causes) > 0 { |
| for _, e := range m.Causes { |
| l = e.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| n += 1 + sovGenerated(uint64(m.RetryAfterSeconds)) |
| l = len(m.UID) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m *Timestamp) Size() (n int) { |
| var l int |
| _ = l |
| n += 1 + sovGenerated(uint64(m.Seconds)) |
| n += 1 + sovGenerated(uint64(m.Nanos)) |
| return n |
| } |
| |
| func (m *TypeMeta) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Kind) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = len(m.APIVersion) |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func (m Verbs) Size() (n int) { |
| var l int |
| _ = l |
| if len(m) > 0 { |
| for _, s := range m { |
| l = len(s) |
| n += 1 + l + sovGenerated(uint64(l)) |
| } |
| } |
| return n |
| } |
| |
| func (m *WatchEvent) Size() (n int) { |
| var l int |
| _ = l |
| l = len(m.Type) |
| n += 1 + l + sovGenerated(uint64(l)) |
| l = m.Object.Size() |
| n += 1 + l + sovGenerated(uint64(l)) |
| return n |
| } |
| |
| func sovGenerated(x uint64) (n int) { |
| for { |
| n++ |
| x >>= 7 |
| if x == 0 { |
| break |
| } |
| } |
| return n |
| } |
| func sozGenerated(x uint64) (n int) { |
| return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
| } |
| func (this *APIGroup) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&APIGroup{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `Versions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Versions), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`, |
| `PreferredVersion:` + strings.Replace(strings.Replace(this.PreferredVersion.String(), "GroupVersionForDiscovery", "GroupVersionForDiscovery", 1), `&`, ``, 1) + `,`, |
| `ServerAddressByClientCIDRs:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServerAddressByClientCIDRs), "ServerAddressByClientCIDR", "ServerAddressByClientCIDR", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *APIGroupList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&APIGroupList{`, |
| `Groups:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Groups), "APIGroup", "APIGroup", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *APIResource) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&APIResource{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `Namespaced:` + fmt.Sprintf("%v", this.Namespaced) + `,`, |
| `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, |
| `Verbs:` + strings.Replace(fmt.Sprintf("%v", this.Verbs), "Verbs", "Verbs", 1) + `,`, |
| `ShortNames:` + fmt.Sprintf("%v", this.ShortNames) + `,`, |
| `SingularName:` + fmt.Sprintf("%v", this.SingularName) + `,`, |
| `Categories:` + fmt.Sprintf("%v", this.Categories) + `,`, |
| `Group:` + fmt.Sprintf("%v", this.Group) + `,`, |
| `Version:` + fmt.Sprintf("%v", this.Version) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *APIResourceList) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&APIResourceList{`, |
| `GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`, |
| `APIResources:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.APIResources), "APIResource", "APIResource", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *DeleteOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&DeleteOptions{`, |
| `GracePeriodSeconds:` + valueToStringGenerated(this.GracePeriodSeconds) + `,`, |
| `Preconditions:` + strings.Replace(fmt.Sprintf("%v", this.Preconditions), "Preconditions", "Preconditions", 1) + `,`, |
| `OrphanDependents:` + valueToStringGenerated(this.OrphanDependents) + `,`, |
| `PropagationPolicy:` + valueToStringGenerated(this.PropagationPolicy) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Duration) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Duration{`, |
| `Duration:` + fmt.Sprintf("%v", this.Duration) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ExportOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ExportOptions{`, |
| `Export:` + fmt.Sprintf("%v", this.Export) + `,`, |
| `Exact:` + fmt.Sprintf("%v", this.Exact) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *GetOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&GetOptions{`, |
| `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`, |
| `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *GroupVersionForDiscovery) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&GroupVersionForDiscovery{`, |
| `GroupVersion:` + fmt.Sprintf("%v", this.GroupVersion) + `,`, |
| `Version:` + fmt.Sprintf("%v", this.Version) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Initializer) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Initializer{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Initializers) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Initializers{`, |
| `Pending:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Pending), "Initializer", "Initializer", 1), `&`, ``, 1) + `,`, |
| `Result:` + strings.Replace(fmt.Sprintf("%v", this.Result), "Status", "Status", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *LabelSelector) String() string { |
| if this == nil { |
| return "nil" |
| } |
| keysForMatchLabels := make([]string, 0, len(this.MatchLabels)) |
| for k := range this.MatchLabels { |
| keysForMatchLabels = append(keysForMatchLabels, k) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForMatchLabels) |
| mapStringForMatchLabels := "map[string]string{" |
| for _, k := range keysForMatchLabels { |
| mapStringForMatchLabels += fmt.Sprintf("%v: %v,", k, this.MatchLabels[k]) |
| } |
| mapStringForMatchLabels += "}" |
| s := strings.Join([]string{`&LabelSelector{`, |
| `MatchLabels:` + mapStringForMatchLabels + `,`, |
| `MatchExpressions:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.MatchExpressions), "LabelSelectorRequirement", "LabelSelectorRequirement", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *LabelSelectorRequirement) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&LabelSelectorRequirement{`, |
| `Key:` + fmt.Sprintf("%v", this.Key) + `,`, |
| `Operator:` + fmt.Sprintf("%v", this.Operator) + `,`, |
| `Values:` + fmt.Sprintf("%v", this.Values) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *List) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&List{`, |
| `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`, |
| `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ListMeta) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ListMeta{`, |
| `SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`, |
| `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`, |
| `Continue:` + fmt.Sprintf("%v", this.Continue) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ListOptions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ListOptions{`, |
| `LabelSelector:` + fmt.Sprintf("%v", this.LabelSelector) + `,`, |
| `FieldSelector:` + fmt.Sprintf("%v", this.FieldSelector) + `,`, |
| `Watch:` + fmt.Sprintf("%v", this.Watch) + `,`, |
| `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`, |
| `TimeoutSeconds:` + valueToStringGenerated(this.TimeoutSeconds) + `,`, |
| `IncludeUninitialized:` + fmt.Sprintf("%v", this.IncludeUninitialized) + `,`, |
| `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`, |
| `Continue:` + fmt.Sprintf("%v", this.Continue) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ObjectMeta) String() string { |
| if this == nil { |
| return "nil" |
| } |
| keysForLabels := make([]string, 0, len(this.Labels)) |
| for k := range this.Labels { |
| keysForLabels = append(keysForLabels, k) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) |
| mapStringForLabels := "map[string]string{" |
| for _, k := range keysForLabels { |
| mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) |
| } |
| mapStringForLabels += "}" |
| keysForAnnotations := make([]string, 0, len(this.Annotations)) |
| for k := range this.Annotations { |
| keysForAnnotations = append(keysForAnnotations, k) |
| } |
| github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) |
| mapStringForAnnotations := "map[string]string{" |
| for _, k := range keysForAnnotations { |
| mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) |
| } |
| mapStringForAnnotations += "}" |
| s := strings.Join([]string{`&ObjectMeta{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `GenerateName:` + fmt.Sprintf("%v", this.GenerateName) + `,`, |
| `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`, |
| `SelfLink:` + fmt.Sprintf("%v", this.SelfLink) + `,`, |
| `UID:` + fmt.Sprintf("%v", this.UID) + `,`, |
| `ResourceVersion:` + fmt.Sprintf("%v", this.ResourceVersion) + `,`, |
| `Generation:` + fmt.Sprintf("%v", this.Generation) + `,`, |
| `CreationTimestamp:` + strings.Replace(strings.Replace(this.CreationTimestamp.String(), "Time", "Time", 1), `&`, ``, 1) + `,`, |
| `DeletionTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.DeletionTimestamp), "Time", "Time", 1) + `,`, |
| `DeletionGracePeriodSeconds:` + valueToStringGenerated(this.DeletionGracePeriodSeconds) + `,`, |
| `Labels:` + mapStringForLabels + `,`, |
| `Annotations:` + mapStringForAnnotations + `,`, |
| `OwnerReferences:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.OwnerReferences), "OwnerReference", "OwnerReference", 1), `&`, ``, 1) + `,`, |
| `Finalizers:` + fmt.Sprintf("%v", this.Finalizers) + `,`, |
| `ClusterName:` + fmt.Sprintf("%v", this.ClusterName) + `,`, |
| `Initializers:` + strings.Replace(fmt.Sprintf("%v", this.Initializers), "Initializers", "Initializers", 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *OwnerReference) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&OwnerReference{`, |
| `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `UID:` + fmt.Sprintf("%v", this.UID) + `,`, |
| `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`, |
| `Controller:` + valueToStringGenerated(this.Controller) + `,`, |
| `BlockOwnerDeletion:` + valueToStringGenerated(this.BlockOwnerDeletion) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Patch) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Patch{`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Preconditions) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Preconditions{`, |
| `UID:` + valueToStringGenerated(this.UID) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *RootPaths) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&RootPaths{`, |
| `Paths:` + fmt.Sprintf("%v", this.Paths) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *ServerAddressByClientCIDR) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&ServerAddressByClientCIDR{`, |
| `ClientCIDR:` + fmt.Sprintf("%v", this.ClientCIDR) + `,`, |
| `ServerAddress:` + fmt.Sprintf("%v", this.ServerAddress) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Status) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Status{`, |
| `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "ListMeta", 1), `&`, ``, 1) + `,`, |
| `Status:` + fmt.Sprintf("%v", this.Status) + `,`, |
| `Message:` + fmt.Sprintf("%v", this.Message) + `,`, |
| `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, |
| `Details:` + strings.Replace(fmt.Sprintf("%v", this.Details), "StatusDetails", "StatusDetails", 1) + `,`, |
| `Code:` + fmt.Sprintf("%v", this.Code) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatusCause) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatusCause{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `Message:` + fmt.Sprintf("%v", this.Message) + `,`, |
| `Field:` + fmt.Sprintf("%v", this.Field) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *StatusDetails) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&StatusDetails{`, |
| `Name:` + fmt.Sprintf("%v", this.Name) + `,`, |
| `Group:` + fmt.Sprintf("%v", this.Group) + `,`, |
| `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, |
| `Causes:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Causes), "StatusCause", "StatusCause", 1), `&`, ``, 1) + `,`, |
| `RetryAfterSeconds:` + fmt.Sprintf("%v", this.RetryAfterSeconds) + `,`, |
| `UID:` + fmt.Sprintf("%v", this.UID) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *Timestamp) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&Timestamp{`, |
| `Seconds:` + fmt.Sprintf("%v", this.Seconds) + `,`, |
| `Nanos:` + fmt.Sprintf("%v", this.Nanos) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *TypeMeta) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&TypeMeta{`, |
| `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`, |
| `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func (this *WatchEvent) String() string { |
| if this == nil { |
| return "nil" |
| } |
| s := strings.Join([]string{`&WatchEvent{`, |
| `Type:` + fmt.Sprintf("%v", this.Type) + `,`, |
| `Object:` + strings.Replace(strings.Replace(this.Object.String(), "RawExtension", "k8s_io_apimachinery_pkg_runtime.RawExtension", 1), `&`, ``, 1) + `,`, |
| `}`, |
| }, "") |
| return s |
| } |
| func valueToStringGenerated(v interface{}) string { |
| rv := reflect.ValueOf(v) |
| if rv.IsNil() { |
| return "nil" |
| } |
| pv := reflect.Indirect(rv).Interface() |
| return fmt.Sprintf("*%v", pv) |
| } |
| func (m *APIGroup) 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: APIGroup: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: APIGroup: 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 > 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 Versions", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Versions = append(m.Versions, GroupVersionForDiscovery{}) |
| if err := m.Versions[len(m.Versions)-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 PreferredVersion", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.PreferredVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{}) |
| if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *APIGroupList) 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: APIGroupList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: APIGroupList: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Groups", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Groups = append(m.Groups, APIGroup{}) |
| if err := m.Groups[len(m.Groups)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *APIResource) 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: APIResource: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: APIResource: 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Name = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Namespaced", 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.Namespaced = bool(v != 0) |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Kind = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Verbs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Verbs == nil { |
| m.Verbs = Verbs{} |
| } |
| if err := m.Verbs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ShortNames", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ShortNames = append(m.ShortNames, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SingularName", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.SingularName = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 7: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Categories", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Categories = append(m.Categories, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 8: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 9: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Version = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *APIResourceList) 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: APIResourceList: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: APIResourceList: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.GroupVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field APIResources", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.APIResources = append(m.APIResources, APIResource{}) |
| if err := m.APIResources[len(m.APIResources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *APIVersions) 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: APIVersions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: APIVersions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Versions = append(m.Versions, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ServerAddressByClientCIDRs", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ServerAddressByClientCIDRs = append(m.ServerAddressByClientCIDRs, ServerAddressByClientCIDR{}) |
| if err := m.ServerAddressByClientCIDRs[len(m.ServerAddressByClientCIDRs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *DeleteOptions) 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: DeleteOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: DeleteOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field GracePeriodSeconds", wireType) |
| } |
| var v int64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= (int64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.GracePeriodSeconds = &v |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Preconditions", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Preconditions == nil { |
| m.Preconditions = &Preconditions{} |
| } |
| if err := m.Preconditions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field OrphanDependents", 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.OrphanDependents = &b |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field PropagationPolicy", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| s := DeletionPropagation(dAtA[iNdEx:postIndex]) |
| m.PropagationPolicy = &s |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Duration) 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: Duration: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Duration: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType) |
| } |
| m.Duration = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Duration |= (time.Duration(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ExportOptions) 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: ExportOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ExportOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Export", 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.Export = bool(v != 0) |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Exact", 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.Exact = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GetOptions) 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: GetOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GetOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ResourceVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", 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.IncludeUninitialized = bool(v != 0) |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GroupKind) 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: GroupKind: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GroupKind: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Kind = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GroupResource) 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: GroupResource: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GroupResource: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Resource = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GroupVersion) 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: GroupVersion: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GroupVersion: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Version = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GroupVersionForDiscovery) 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: GroupVersionForDiscovery: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GroupVersionForDiscovery: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field GroupVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.GroupVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Version = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GroupVersionKind) 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: GroupVersionKind: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GroupVersionKind: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Version = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Kind = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *GroupVersionResource) 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: GroupVersionResource: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: GroupVersionResource: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Version = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Resource = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Initializer) 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: Initializer: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Initializer: 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 > 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) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Initializers) 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: Initializers: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Initializers: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Pending", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Pending = append(m.Pending, Initializer{}) |
| if err := m.Pending[len(m.Pending)-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 Result", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Result == nil { |
| m.Result = &Status{} |
| } |
| if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *LabelSelector) 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: LabelSelector: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| var keykey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| keykey |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| if m.MatchLabels == nil { |
| m.MatchLabels = make(map[string]string) |
| } |
| if iNdEx < postIndex { |
| var valuekey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| valuekey |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| m.MatchLabels[mapkey] = mapvalue |
| } else { |
| var mapvalue string |
| m.MatchLabels[mapkey] = mapvalue |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.MatchExpressions = append(m.MatchExpressions, LabelSelectorRequirement{}) |
| if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *LabelSelectorRequirement) 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: LabelSelectorRequirement: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Key = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Operator = LabelSelectorOperator(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Values = append(m.Values, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *List) 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: List: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Items = append(m.Items, k8s_io_apimachinery_pkg_runtime.RawExtension{}) |
| if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ListMeta) 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: ListMeta: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ListMeta: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.SelfLink = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ResourceVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Continue = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ListOptions) 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: ListOptions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ListOptions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.LabelSelector = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field FieldSelector", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.FieldSelector = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Watch", 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.Watch = bool(v != 0) |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ResourceVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field TimeoutSeconds", wireType) |
| } |
| var v int64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= (int64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.TimeoutSeconds = &v |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field IncludeUninitialized", 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.IncludeUninitialized = bool(v != 0) |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) |
| } |
| m.Limit = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Limit |= (int64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 8: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Continue", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Continue = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ObjectMeta) 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: ObjectMeta: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ObjectMeta: 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 > 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 GenerateName", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.GenerateName = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Namespace = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field SelfLink", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.SelfLink = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ResourceVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ResourceVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType) |
| } |
| m.Generation = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Generation |= (int64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 8: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field CreationTimestamp", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.CreationTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 9: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DeletionTimestamp", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.DeletionTimestamp == nil { |
| m.DeletionTimestamp = &Time{} |
| } |
| if err := m.DeletionTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 10: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field DeletionGracePeriodSeconds", wireType) |
| } |
| var v int64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| v |= (int64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| m.DeletionGracePeriodSeconds = &v |
| case 11: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| var keykey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| keykey |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| if m.Labels == nil { |
| m.Labels = make(map[string]string) |
| } |
| if iNdEx < postIndex { |
| var valuekey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| valuekey |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| m.Labels[mapkey] = mapvalue |
| } else { |
| var mapvalue string |
| m.Labels[mapkey] = mapvalue |
| } |
| iNdEx = postIndex |
| case 12: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| var keykey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| keykey |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) |
| iNdEx = postStringIndexmapkey |
| if m.Annotations == nil { |
| m.Annotations = make(map[string]string) |
| } |
| if iNdEx < postIndex { |
| var valuekey uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| valuekey |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue]) |
| iNdEx = postStringIndexmapvalue |
| m.Annotations[mapkey] = mapvalue |
| } else { |
| var mapvalue string |
| m.Annotations[mapkey] = mapvalue |
| } |
| iNdEx = postIndex |
| case 13: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field OwnerReferences", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.OwnerReferences = append(m.OwnerReferences, OwnerReference{}) |
| if err := m.OwnerReferences[len(m.OwnerReferences)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 14: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Finalizers", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Finalizers = append(m.Finalizers, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| case 15: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ClusterName = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 16: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Initializers", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Initializers == nil { |
| m.Initializers = &Initializers{} |
| } |
| if err := m.Initializers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *OwnerReference) 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: OwnerReference: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: OwnerReference: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Kind = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Name = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.APIVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Controller", 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.Controller = &b |
| case 7: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field BlockOwnerDeletion", 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.BlockOwnerDeletion = &b |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Patch) 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: Patch: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Patch: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Preconditions) 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: Preconditions: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Preconditions: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| s := k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex]) |
| m.UID = &s |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *RootPaths) 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: RootPaths: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: RootPaths: 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 stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *ServerAddressByClientCIDR) 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: ServerAddressByClientCIDR: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: ServerAddressByClientCIDR: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ClientCIDR", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ClientCIDR = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.ServerAddress = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Status) 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: Status: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Status = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Message = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| 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 > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Reason = StatusReason(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 5: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if m.Details == nil { |
| m.Details = &StatusDetails{} |
| } |
| if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 6: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) |
| } |
| m.Code = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Code |= (int32(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatusCause) 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: StatusCause: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatusCause: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Type = CauseType(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Message = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Field = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *StatusDetails) 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: StatusDetails: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: StatusDetails: 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 > 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 Group", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Group = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 3: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Kind = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 4: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Causes", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Causes = append(m.Causes, StatusCause{}) |
| if err := m.Causes[len(m.Causes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| case 5: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field RetryAfterSeconds", wireType) |
| } |
| m.RetryAfterSeconds = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.RetryAfterSeconds |= (int32(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 6: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.UID = k8s_io_apimachinery_pkg_types.UID(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Timestamp) 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: Timestamp: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Timestamp: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Seconds", wireType) |
| } |
| m.Seconds = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Seconds |= (int64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| case 2: |
| if wireType != 0 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Nanos", wireType) |
| } |
| m.Nanos = 0 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| m.Nanos |= (int32(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *TypeMeta) 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: TypeMeta: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: TypeMeta: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Kind = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.APIVersion = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *Verbs) 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: Verbs: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: Verbs: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| *m = append(*m, string(dAtA[iNdEx:postIndex])) |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func (m *WatchEvent) 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: WatchEvent: wiretype end group for non-group") |
| } |
| if fieldNum <= 0 { |
| return fmt.Errorf("proto: WatchEvent: illegal tag %d (wire type %d)", fieldNum, wire) |
| } |
| switch fieldNum { |
| case 1: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) |
| } |
| var stringLen uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| stringLen |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| intStringLen := int(stringLen) |
| if intStringLen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + intStringLen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| m.Type = string(dAtA[iNdEx:postIndex]) |
| iNdEx = postIndex |
| case 2: |
| if wireType != 2 { |
| return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType) |
| } |
| var msglen int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| msglen |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| if msglen < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| postIndex := iNdEx + msglen |
| if postIndex > l { |
| return io.ErrUnexpectedEOF |
| } |
| if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
| return err |
| } |
| iNdEx = postIndex |
| default: |
| iNdEx = preIndex |
| skippy, err := skipGenerated(dAtA[iNdEx:]) |
| if err != nil { |
| return err |
| } |
| if skippy < 0 { |
| return ErrInvalidLengthGenerated |
| } |
| if (iNdEx + skippy) > l { |
| return io.ErrUnexpectedEOF |
| } |
| iNdEx += skippy |
| } |
| } |
| |
| if iNdEx > l { |
| return io.ErrUnexpectedEOF |
| } |
| return nil |
| } |
| func skipGenerated(dAtA []byte) (n int, err error) { |
| l := len(dAtA) |
| iNdEx := 0 |
| for iNdEx < l { |
| var wire uint64 |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| wire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| wireType := int(wire & 0x7) |
| switch wireType { |
| case 0: |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| iNdEx++ |
| if dAtA[iNdEx-1] < 0x80 { |
| break |
| } |
| } |
| return iNdEx, nil |
| case 1: |
| iNdEx += 8 |
| return iNdEx, nil |
| case 2: |
| var length int |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| length |= (int(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| iNdEx += length |
| if length < 0 { |
| return 0, ErrInvalidLengthGenerated |
| } |
| return iNdEx, nil |
| case 3: |
| for { |
| var innerWire uint64 |
| var start int = iNdEx |
| for shift := uint(0); ; shift += 7 { |
| if shift >= 64 { |
| return 0, ErrIntOverflowGenerated |
| } |
| if iNdEx >= l { |
| return 0, io.ErrUnexpectedEOF |
| } |
| b := dAtA[iNdEx] |
| iNdEx++ |
| innerWire |= (uint64(b) & 0x7F) << shift |
| if b < 0x80 { |
| break |
| } |
| } |
| innerWireType := int(innerWire & 0x7) |
| if innerWireType == 4 { |
| break |
| } |
| next, err := skipGenerated(dAtA[start:]) |
| if err != nil { |
| return 0, err |
| } |
| iNdEx = start + next |
| } |
| return iNdEx, nil |
| case 4: |
| return iNdEx, nil |
| case 5: |
| iNdEx += 4 |
| return iNdEx, nil |
| default: |
| return 0, fmt.Errorf("proto: illegal wireType %d", wireType) |
| } |
| } |
| panic("unreachable") |
| } |
| |
| var ( |
| ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") |
| ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") |
| ) |
| |
| func init() { |
| proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto", fileDescriptorGenerated) |
| } |
| |
| var fileDescriptorGenerated = []byte{ |
| // 2435 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4d, 0x6c, 0x23, 0x49, |
| 0x15, 0x4e, 0xdb, 0xb1, 0x63, 0x3f, 0xc7, 0xf9, 0xa9, 0xcd, 0x80, 0x37, 0x02, 0x3b, 0xdb, 0x8b, |
| 0x56, 0x59, 0x98, 0xb5, 0x49, 0x16, 0x56, 0xc3, 0x00, 0x03, 0xe9, 0x38, 0x33, 0x8a, 0x76, 0x32, |
| 0x63, 0x55, 0x76, 0x06, 0x31, 0x8c, 0x10, 0x9d, 0x76, 0xc5, 0x69, 0xd2, 0xee, 0xf6, 0x56, 0x95, |
| 0x33, 0x09, 0x1c, 0xd8, 0x03, 0x48, 0x1c, 0x10, 0x9a, 0x23, 0x27, 0xb4, 0x23, 0xb8, 0x70, 0xe5, |
| 0xc4, 0x05, 0x4e, 0x48, 0xcc, 0x71, 0x24, 0x2e, 0x7b, 0x40, 0xd6, 0x8e, 0xf7, 0xc0, 0x09, 0x71, |
| 0xcf, 0x09, 0x55, 0x75, 0xf5, 0x9f, 0x1d, 0x4f, 0xda, 0x3b, 0x0b, 0xe2, 0x14, 0xf7, 0xfb, 0xf9, |
| 0xde, 0xab, 0x57, 0xaf, 0x5e, 0xbd, 0x7a, 0x81, 0xbd, 0xe3, 0x6b, 0xac, 0x6e, 0x7b, 0x8d, 0xe3, |
| 0xfe, 0x01, 0xa1, 0x2e, 0xe1, 0x84, 0x35, 0x4e, 0x88, 0xdb, 0xf6, 0x68, 0x43, 0x31, 0xcc, 0x9e, |
| 0xdd, 0x35, 0xad, 0x23, 0xdb, 0x25, 0xf4, 0xac, 0xd1, 0x3b, 0xee, 0x08, 0x02, 0x6b, 0x74, 0x09, |
| 0x37, 0x1b, 0x27, 0x1b, 0x8d, 0x0e, 0x71, 0x09, 0x35, 0x39, 0x69, 0xd7, 0x7b, 0xd4, 0xe3, 0x1e, |
| 0xfa, 0x92, 0xaf, 0x55, 0x8f, 0x6b, 0xd5, 0x7b, 0xc7, 0x1d, 0x41, 0x60, 0x75, 0xa1, 0x55, 0x3f, |
| 0xd9, 0x58, 0x7d, 0xab, 0x63, 0xf3, 0xa3, 0xfe, 0x41, 0xdd, 0xf2, 0xba, 0x8d, 0x8e, 0xd7, 0xf1, |
| 0x1a, 0x52, 0xf9, 0xa0, 0x7f, 0x28, 0xbf, 0xe4, 0x87, 0xfc, 0xe5, 0x83, 0xae, 0x4e, 0x74, 0x85, |
| 0xf6, 0x5d, 0x6e, 0x77, 0xc9, 0xa8, 0x17, 0xab, 0xef, 0x5c, 0xa6, 0xc0, 0xac, 0x23, 0xd2, 0x35, |
| 0xc7, 0xf4, 0xde, 0x9e, 0xa4, 0xd7, 0xe7, 0xb6, 0xd3, 0xb0, 0x5d, 0xce, 0x38, 0x1d, 0x55, 0xd2, |
| 0xff, 0x96, 0x85, 0xc2, 0x56, 0x6b, 0xf7, 0x16, 0xf5, 0xfa, 0x3d, 0xb4, 0x06, 0xb3, 0xae, 0xd9, |
| 0x25, 0x15, 0x6d, 0x4d, 0x5b, 0x2f, 0x1a, 0xf3, 0x4f, 0x07, 0xb5, 0x99, 0xe1, 0xa0, 0x36, 0x7b, |
| 0xc7, 0xec, 0x12, 0x2c, 0x39, 0xc8, 0x81, 0xc2, 0x09, 0xa1, 0xcc, 0xf6, 0x5c, 0x56, 0xc9, 0xac, |
| 0x65, 0xd7, 0x4b, 0x9b, 0x37, 0xea, 0x69, 0x82, 0x56, 0x97, 0x06, 0xee, 0xfb, 0xaa, 0x37, 0x3d, |
| 0xda, 0xb4, 0x99, 0xe5, 0x9d, 0x10, 0x7a, 0x66, 0x2c, 0x29, 0x2b, 0x05, 0xc5, 0x64, 0x38, 0xb4, |
| 0x80, 0x7e, 0xae, 0xc1, 0x52, 0x8f, 0x92, 0x43, 0x42, 0x29, 0x69, 0x2b, 0x7e, 0x25, 0xbb, 0xa6, |
| 0x7d, 0x06, 0x66, 0x2b, 0xca, 0xec, 0x52, 0x6b, 0x04, 0x1f, 0x8f, 0x59, 0x44, 0xbf, 0xd3, 0x60, |
| 0x95, 0x11, 0x7a, 0x42, 0xe8, 0x56, 0xbb, 0x4d, 0x09, 0x63, 0xc6, 0xd9, 0xb6, 0x63, 0x13, 0x97, |
| 0x6f, 0xef, 0x36, 0x31, 0xab, 0xcc, 0xca, 0x38, 0x7c, 0x27, 0x9d, 0x43, 0xfb, 0x93, 0x70, 0x0c, |
| 0x5d, 0x79, 0xb4, 0x3a, 0x51, 0x84, 0xe1, 0x17, 0xb8, 0xa1, 0x1f, 0xc2, 0x7c, 0xb0, 0x91, 0xb7, |
| 0x6d, 0xc6, 0xd1, 0x7d, 0xc8, 0x77, 0xc4, 0x07, 0xab, 0x68, 0xd2, 0xc1, 0x7a, 0x3a, 0x07, 0x03, |
| 0x0c, 0x63, 0x41, 0xf9, 0x93, 0x97, 0x9f, 0x0c, 0x2b, 0x34, 0xfd, 0xcf, 0x59, 0x28, 0x6d, 0xb5, |
| 0x76, 0x31, 0x61, 0x5e, 0x9f, 0x5a, 0x24, 0x45, 0xd2, 0x6c, 0x02, 0x88, 0xbf, 0xac, 0x67, 0x5a, |
| 0xa4, 0x5d, 0xc9, 0xac, 0x69, 0xeb, 0x05, 0x03, 0x29, 0x39, 0xb8, 0x13, 0x72, 0x70, 0x4c, 0x4a, |
| 0xa0, 0x1e, 0xdb, 0x6e, 0x5b, 0xee, 0x76, 0x0c, 0xf5, 0x5d, 0xdb, 0x6d, 0x63, 0xc9, 0x41, 0xb7, |
| 0x21, 0x77, 0x42, 0xe8, 0x81, 0x88, 0xbf, 0x48, 0x88, 0xaf, 0xa4, 0x5b, 0xde, 0x7d, 0xa1, 0x62, |
| 0x14, 0x87, 0x83, 0x5a, 0x4e, 0xfe, 0xc4, 0x3e, 0x08, 0xaa, 0x03, 0xb0, 0x23, 0x8f, 0x72, 0xe9, |
| 0x4e, 0x25, 0xb7, 0x96, 0x5d, 0x2f, 0x1a, 0x0b, 0xc2, 0xbf, 0xfd, 0x90, 0x8a, 0x63, 0x12, 0xe8, |
| 0x1a, 0xcc, 0x33, 0xdb, 0xed, 0xf4, 0x1d, 0x93, 0x0a, 0x42, 0x25, 0x2f, 0xfd, 0x5c, 0x51, 0x7e, |
| 0xce, 0xef, 0xc7, 0x78, 0x38, 0x21, 0x29, 0x2c, 0x59, 0x26, 0x27, 0x1d, 0x8f, 0xda, 0x84, 0x55, |
| 0xe6, 0x22, 0x4b, 0xdb, 0x21, 0x15, 0xc7, 0x24, 0xd0, 0xeb, 0x90, 0x93, 0x91, 0xaf, 0x14, 0xa4, |
| 0x89, 0xb2, 0x32, 0x91, 0x93, 0xdb, 0x82, 0x7d, 0x1e, 0x7a, 0x13, 0xe6, 0xd4, 0xa9, 0xa9, 0x14, |
| 0xa5, 0xd8, 0xa2, 0x12, 0x9b, 0x0b, 0xd2, 0x3a, 0xe0, 0xeb, 0x7f, 0xd4, 0x60, 0x31, 0xb6, 0x7f, |
| 0x32, 0x57, 0xae, 0xc1, 0x7c, 0x27, 0x76, 0x52, 0xd4, 0x5e, 0x86, 0xab, 0x89, 0x9f, 0x22, 0x9c, |
| 0x90, 0x44, 0x04, 0x8a, 0x54, 0x21, 0x05, 0x15, 0x61, 0x23, 0x75, 0xa2, 0x05, 0x3e, 0x44, 0x96, |
| 0x62, 0x44, 0x86, 0x23, 0x64, 0xfd, 0x9f, 0x9a, 0x4c, 0xba, 0xa0, 0x46, 0xa0, 0xf5, 0x58, 0x1d, |
| 0xd2, 0x64, 0x08, 0xe7, 0x27, 0xd4, 0x90, 0x4b, 0x0e, 0x6f, 0xe6, 0xff, 0xe2, 0xf0, 0x5e, 0x2f, |
| 0xfc, 0xe6, 0xc3, 0xda, 0xcc, 0x07, 0xff, 0x58, 0x9b, 0xd1, 0x3f, 0xc9, 0x40, 0xb9, 0x49, 0x1c, |
| 0xc2, 0xc9, 0xdd, 0x1e, 0x97, 0x2b, 0xb8, 0x09, 0xa8, 0x43, 0x4d, 0x8b, 0xb4, 0x08, 0xb5, 0xbd, |
| 0xf6, 0x3e, 0xb1, 0x3c, 0xb7, 0xcd, 0xe4, 0x16, 0x65, 0x8d, 0xcf, 0x0d, 0x07, 0x35, 0x74, 0x6b, |
| 0x8c, 0x8b, 0x2f, 0xd0, 0x40, 0x0e, 0x94, 0x7b, 0x54, 0xfe, 0xb6, 0xb9, 0x2a, 0xe0, 0xe2, 0xe0, |
| 0xbc, 0x9d, 0x6e, 0xed, 0xad, 0xb8, 0xaa, 0xb1, 0x3c, 0x1c, 0xd4, 0xca, 0x09, 0x12, 0x4e, 0x82, |
| 0xa3, 0xef, 0xc2, 0x92, 0x47, 0x7b, 0x47, 0xa6, 0xdb, 0x24, 0x3d, 0xe2, 0xb6, 0x89, 0xcb, 0x99, |
| 0x3c, 0xcc, 0x05, 0x63, 0x45, 0x94, 0xdd, 0xbb, 0x23, 0x3c, 0x3c, 0x26, 0x8d, 0x1e, 0xc0, 0x72, |
| 0x8f, 0x7a, 0x3d, 0xb3, 0x63, 0x0a, 0xc4, 0x96, 0xe7, 0xd8, 0xd6, 0x99, 0x3c, 0xec, 0x45, 0xe3, |
| 0xea, 0x70, 0x50, 0x5b, 0x6e, 0x8d, 0x32, 0xcf, 0x07, 0xb5, 0x57, 0x64, 0xe8, 0x04, 0x25, 0x62, |
| 0xe2, 0x71, 0x18, 0x7d, 0x17, 0x0a, 0xcd, 0x3e, 0x95, 0x14, 0xf4, 0x6d, 0x28, 0xb4, 0xd5, 0x6f, |
| 0x15, 0xd5, 0xd7, 0x82, 0x3b, 0x29, 0x90, 0x39, 0x1f, 0xd4, 0xca, 0xe2, 0xea, 0xad, 0x07, 0x04, |
| 0x1c, 0xaa, 0xe8, 0x0f, 0xa1, 0xbc, 0x73, 0xda, 0xf3, 0x28, 0x0f, 0xf6, 0xeb, 0x0d, 0xc8, 0x13, |
| 0x49, 0x90, 0x68, 0x85, 0xa8, 0x90, 0xfa, 0x62, 0x58, 0x71, 0xc5, 0xc1, 0x26, 0xa7, 0xa6, 0xc5, |
| 0x55, 0x45, 0x0c, 0x0f, 0xf6, 0x8e, 0x20, 0x62, 0x9f, 0xa7, 0x3f, 0xd1, 0x00, 0x6e, 0x91, 0x10, |
| 0x7b, 0x0b, 0x16, 0x83, 0x43, 0x91, 0x3c, 0xab, 0x9f, 0x57, 0xda, 0x8b, 0x38, 0xc9, 0xc6, 0xa3, |
| 0xf2, 0xa8, 0x05, 0x2b, 0xb6, 0x6b, 0x39, 0xfd, 0x36, 0xb9, 0xe7, 0xda, 0xae, 0xcd, 0x6d, 0xd3, |
| 0xb1, 0x7f, 0x12, 0xd6, 0xe5, 0x2f, 0x28, 0x9c, 0x95, 0xdd, 0x0b, 0x64, 0xf0, 0x85, 0x9a, 0xfa, |
| 0x43, 0x28, 0xca, 0x0a, 0x21, 0x8a, 0x73, 0x54, 0xae, 0xb4, 0x17, 0x94, 0xab, 0xa0, 0xba, 0x67, |
| 0x26, 0x55, 0xf7, 0xd8, 0x81, 0x70, 0xa0, 0xec, 0xeb, 0x06, 0x17, 0x4e, 0x2a, 0x0b, 0x57, 0xa1, |
| 0x10, 0x2c, 0x5c, 0x59, 0x09, 0x1b, 0x8d, 0x00, 0x08, 0x87, 0x12, 0x31, 0x6b, 0x47, 0x90, 0xa8, |
| 0x76, 0xe9, 0x8c, 0xc5, 0xaa, 0x6f, 0xe6, 0xc5, 0xd5, 0x37, 0x66, 0xe9, 0x67, 0x50, 0x99, 0xd4, |
| 0x9d, 0xbc, 0x44, 0x3d, 0x4e, 0xef, 0x8a, 0xfe, 0x6b, 0x0d, 0x96, 0xe2, 0x48, 0xe9, 0xb7, 0x2f, |
| 0xbd, 0x91, 0xcb, 0xef, 0xf1, 0x58, 0x44, 0x7e, 0xab, 0xc1, 0x4a, 0x62, 0x69, 0x53, 0xed, 0xf8, |
| 0x14, 0x4e, 0xc5, 0x93, 0x23, 0x3b, 0x45, 0x72, 0x34, 0xa0, 0xb4, 0x1b, 0xe6, 0x3d, 0xbd, 0xbc, |
| 0xf3, 0xd1, 0xff, 0xa2, 0xc1, 0x7c, 0x4c, 0x83, 0xa1, 0x87, 0x30, 0x27, 0xea, 0x9b, 0xed, 0x76, |
| 0x54, 0x57, 0x96, 0xf2, 0xb2, 0x8c, 0x81, 0x44, 0xeb, 0x6a, 0xf9, 0x48, 0x38, 0x80, 0x44, 0x2d, |
| 0xc8, 0x53, 0xc2, 0xfa, 0x0e, 0x57, 0xa5, 0xfd, 0x6a, 0xca, 0x6b, 0x8d, 0x9b, 0xbc, 0xcf, 0x0c, |
| 0x10, 0x35, 0x0a, 0x4b, 0x7d, 0xac, 0x70, 0xf4, 0xbf, 0x67, 0xa0, 0x7c, 0xdb, 0x3c, 0x20, 0xce, |
| 0x3e, 0x71, 0x88, 0xc5, 0x3d, 0x8a, 0x7e, 0x0a, 0xa5, 0xae, 0xc9, 0xad, 0x23, 0x49, 0x0d, 0x7a, |
| 0xcb, 0x66, 0x3a, 0x43, 0x09, 0xa4, 0xfa, 0x5e, 0x04, 0xb3, 0xe3, 0x72, 0x7a, 0x66, 0xbc, 0xa2, |
| 0x16, 0x56, 0x8a, 0x71, 0x70, 0xdc, 0x9a, 0x7c, 0x10, 0xc8, 0xef, 0x9d, 0xd3, 0x9e, 0xb8, 0x44, |
| 0xa7, 0x7f, 0x87, 0x24, 0x5c, 0xc0, 0xe4, 0xfd, 0xbe, 0x4d, 0x49, 0x97, 0xb8, 0x3c, 0x7a, 0x10, |
| 0xec, 0x8d, 0xe0, 0xe3, 0x31, 0x8b, 0xab, 0x37, 0x60, 0x69, 0xd4, 0x79, 0xb4, 0x04, 0xd9, 0x63, |
| 0x72, 0xe6, 0xe7, 0x02, 0x16, 0x3f, 0xd1, 0x0a, 0xe4, 0x4e, 0x4c, 0xa7, 0xaf, 0xea, 0x0f, 0xf6, |
| 0x3f, 0xae, 0x67, 0xae, 0x69, 0xfa, 0xef, 0x35, 0xa8, 0x4c, 0x72, 0x04, 0x7d, 0x31, 0x06, 0x64, |
| 0x94, 0x94, 0x57, 0xd9, 0x77, 0xc9, 0x99, 0x8f, 0xba, 0x03, 0x05, 0xaf, 0x27, 0x9e, 0x70, 0x1e, |
| 0x55, 0x79, 0xfe, 0x66, 0x90, 0xbb, 0x77, 0x15, 0xfd, 0x7c, 0x50, 0xbb, 0x92, 0x80, 0x0f, 0x18, |
| 0x38, 0x54, 0x45, 0x3a, 0xe4, 0xa5, 0x3f, 0xe2, 0x52, 0x16, 0xed, 0x93, 0xdc, 0xfc, 0xfb, 0x92, |
| 0x82, 0x15, 0x47, 0xff, 0x93, 0x06, 0xb3, 0xb2, 0x3d, 0x7c, 0x08, 0x05, 0x11, 0xbf, 0xb6, 0xc9, |
| 0x4d, 0xe9, 0x57, 0xea, 0xc7, 0x84, 0xd0, 0xde, 0x23, 0xdc, 0x8c, 0xce, 0x57, 0x40, 0xc1, 0x21, |
| 0x22, 0xc2, 0x90, 0xb3, 0x39, 0xe9, 0x06, 0x1b, 0xf9, 0xd6, 0x44, 0x68, 0xf5, 0xfe, 0xad, 0x63, |
| 0xf3, 0xd1, 0xce, 0x29, 0x27, 0xae, 0xd8, 0x8c, 0xa8, 0x18, 0xec, 0x0a, 0x0c, 0xec, 0x43, 0xe9, |
| 0x7f, 0xd0, 0x20, 0x34, 0x25, 0x8e, 0x3b, 0x23, 0xce, 0xe1, 0x6d, 0xdb, 0x3d, 0x56, 0x61, 0x0d, |
| 0xdd, 0xd9, 0x57, 0x74, 0x1c, 0x4a, 0x5c, 0x74, 0xc5, 0x66, 0xa6, 0xbc, 0x62, 0xaf, 0x42, 0xc1, |
| 0xf2, 0x5c, 0x6e, 0xbb, 0xfd, 0xb1, 0xfa, 0xb2, 0xad, 0xe8, 0x38, 0x94, 0xd0, 0x9f, 0x65, 0xa1, |
| 0x24, 0x7c, 0x0d, 0xee, 0xf8, 0x6f, 0x42, 0xd9, 0x89, 0xef, 0x9e, 0xf2, 0xf9, 0x8a, 0x82, 0x48, |
| 0x9e, 0x47, 0x9c, 0x94, 0x15, 0xca, 0x87, 0x36, 0x71, 0xda, 0xa1, 0x72, 0x26, 0xa9, 0x7c, 0x33, |
| 0xce, 0xc4, 0x49, 0x59, 0x51, 0x67, 0x1f, 0x89, 0xbc, 0x56, 0x8d, 0x5a, 0x18, 0xda, 0xef, 0x09, |
| 0x22, 0xf6, 0x79, 0x17, 0xc5, 0x67, 0x76, 0xca, 0xf8, 0x5c, 0x87, 0x05, 0xb1, 0x91, 0x5e, 0x9f, |
| 0x07, 0xdd, 0x6c, 0x4e, 0xf6, 0x5d, 0x68, 0x38, 0xa8, 0x2d, 0xbc, 0x97, 0xe0, 0xe0, 0x11, 0xc9, |
| 0x89, 0xed, 0x4b, 0xfe, 0xd3, 0xb6, 0x2f, 0x62, 0xd5, 0x8e, 0xdd, 0xb5, 0x79, 0x65, 0x4e, 0x3a, |
| 0x11, 0xae, 0xfa, 0xb6, 0x20, 0x62, 0x9f, 0x97, 0xd8, 0xd2, 0xc2, 0xa5, 0x5b, 0xfa, 0x3e, 0x14, |
| 0xf7, 0x6c, 0x8b, 0x7a, 0x62, 0x2d, 0xe2, 0x62, 0x62, 0x89, 0xa6, 0x3d, 0x2c, 0xe0, 0xc1, 0x1a, |
| 0x03, 0xbe, 0x70, 0xc5, 0x35, 0x5d, 0xcf, 0x6f, 0xcd, 0x73, 0x91, 0x2b, 0x77, 0x04, 0x11, 0xfb, |
| 0xbc, 0xeb, 0x2b, 0xe2, 0x3e, 0xfa, 0xe5, 0x93, 0xda, 0xcc, 0xe3, 0x27, 0xb5, 0x99, 0x0f, 0x9f, |
| 0xa8, 0xbb, 0xe9, 0x5f, 0x00, 0x70, 0xf7, 0xe0, 0xc7, 0xc4, 0xf2, 0x73, 0xfe, 0xf2, 0x57, 0xb9, |
| 0xe8, 0x31, 0xd4, 0x30, 0x48, 0xbe, 0x60, 0x33, 0x23, 0x3d, 0x46, 0x8c, 0x87, 0x13, 0x92, 0xa8, |
| 0x01, 0xc5, 0xf0, 0xa5, 0xae, 0xf2, 0x7b, 0x59, 0xa9, 0x15, 0xc3, 0xe7, 0x3c, 0x8e, 0x64, 0x12, |
| 0x07, 0x70, 0xf6, 0xd2, 0x03, 0x68, 0x40, 0xb6, 0x6f, 0xb7, 0x65, 0x4a, 0x14, 0x8d, 0xaf, 0x06, |
| 0x05, 0xf0, 0xde, 0x6e, 0xf3, 0x7c, 0x50, 0x7b, 0x6d, 0xd2, 0x8c, 0x8b, 0x9f, 0xf5, 0x08, 0xab, |
| 0xdf, 0xdb, 0x6d, 0x62, 0xa1, 0x7c, 0x51, 0x92, 0xe6, 0xa7, 0x4c, 0xd2, 0x4d, 0x00, 0xb5, 0x6a, |
| 0xa1, 0xed, 0xe7, 0x46, 0x38, 0xb5, 0xb8, 0x15, 0x72, 0x70, 0x4c, 0x0a, 0x31, 0x58, 0xb6, 0x28, |
| 0x91, 0xbf, 0xc5, 0xd6, 0x33, 0x6e, 0x76, 0xfd, 0x77, 0x7b, 0x69, 0xf3, 0xcb, 0xe9, 0x2a, 0xa6, |
| 0x50, 0x33, 0x5e, 0x55, 0x66, 0x96, 0xb7, 0x47, 0xc1, 0xf0, 0x38, 0x3e, 0xf2, 0x60, 0xb9, 0xad, |
| 0x5e, 0x3d, 0x91, 0xd1, 0xe2, 0xd4, 0x46, 0xaf, 0x08, 0x83, 0xcd, 0x51, 0x20, 0x3c, 0x8e, 0x8d, |
| 0x7e, 0x08, 0xab, 0x01, 0x71, 0xfc, 0xe9, 0x59, 0x01, 0x19, 0xa9, 0xaa, 0x78, 0x0c, 0x37, 0x27, |
| 0x4a, 0xe1, 0x17, 0x20, 0xa0, 0x36, 0xe4, 0x1d, 0xbf, 0xbb, 0x28, 0xc9, 0x1b, 0xe1, 0x5b, 0xe9, |
| 0x56, 0x11, 0x65, 0x7f, 0x3d, 0xde, 0x55, 0x84, 0xcf, 0x2f, 0xd5, 0x50, 0x28, 0x6c, 0x74, 0x0a, |
| 0x25, 0xd3, 0x75, 0x3d, 0x6e, 0xfa, 0x8f, 0xe1, 0x79, 0x69, 0x6a, 0x6b, 0x6a, 0x53, 0x5b, 0x11, |
| 0xc6, 0x48, 0x17, 0x13, 0xe3, 0xe0, 0xb8, 0x29, 0xf4, 0x08, 0x16, 0xbd, 0x47, 0x2e, 0xa1, 0x98, |
| 0x1c, 0x12, 0x4a, 0x5c, 0x8b, 0xb0, 0x4a, 0x59, 0x5a, 0xff, 0x5a, 0x4a, 0xeb, 0x09, 0xe5, 0x28, |
| 0xa5, 0x93, 0x74, 0x86, 0x47, 0xad, 0xa0, 0x3a, 0xc0, 0xa1, 0xed, 0xaa, 0x5e, 0xb4, 0xb2, 0x10, |
| 0x8d, 0x9e, 0x6e, 0x86, 0x54, 0x1c, 0x93, 0x40, 0x5f, 0x87, 0x92, 0xe5, 0xf4, 0x19, 0x27, 0xfe, |
| 0x8c, 0x6b, 0x51, 0x9e, 0xa0, 0x70, 0x7d, 0xdb, 0x11, 0x0b, 0xc7, 0xe5, 0xd0, 0x11, 0xcc, 0xdb, |
| 0xb1, 0xa6, 0xb7, 0xb2, 0x24, 0x73, 0x71, 0x73, 0xea, 0x4e, 0x97, 0x19, 0x4b, 0xa2, 0x12, 0xc5, |
| 0x29, 0x38, 0x81, 0xbc, 0xfa, 0x0d, 0x28, 0x7d, 0xca, 0x1e, 0x4c, 0xf4, 0x70, 0xa3, 0x5b, 0x37, |
| 0x55, 0x0f, 0xf7, 0xd7, 0x0c, 0x2c, 0x24, 0x03, 0x1e, 0xbe, 0x75, 0xb4, 0x89, 0x33, 0xcb, 0xa0, |
| 0x2a, 0x67, 0x27, 0x56, 0x65, 0x55, 0xfc, 0x66, 0x5f, 0xa6, 0xf8, 0x6d, 0x02, 0x98, 0x3d, 0x3b, |
| 0xa8, 0x7b, 0x7e, 0x1d, 0x0d, 0x2b, 0x57, 0x34, 0x45, 0xc3, 0x31, 0x29, 0x39, 0x95, 0xf4, 0x5c, |
| 0x4e, 0x3d, 0xc7, 0x21, 0x54, 0x5d, 0xa6, 0xfe, 0x54, 0x32, 0xa4, 0xe2, 0x98, 0x04, 0xba, 0x09, |
| 0xe8, 0xc0, 0xf1, 0xac, 0x63, 0x19, 0x82, 0xe0, 0x9c, 0xcb, 0x2a, 0x59, 0xf0, 0x87, 0x52, 0xc6, |
| 0x18, 0x17, 0x5f, 0xa0, 0xa1, 0xcf, 0x41, 0xae, 0x25, 0xda, 0x0a, 0xfd, 0x2e, 0x24, 0xe7, 0x49, |
| 0xe8, 0x86, 0x1f, 0x09, 0x2d, 0x1c, 0xf8, 0x4c, 0x17, 0x05, 0xfd, 0x2a, 0x14, 0xb1, 0xe7, 0xf1, |
| 0x96, 0xc9, 0x8f, 0x18, 0xaa, 0x41, 0xae, 0x27, 0x7e, 0xa8, 0x61, 0xa1, 0x9c, 0xff, 0x4a, 0x0e, |
| 0xf6, 0xe9, 0xfa, 0xaf, 0x34, 0x78, 0x75, 0xe2, 0xec, 0x4e, 0x44, 0xd4, 0x0a, 0xbf, 0x94, 0x4b, |
| 0x61, 0x44, 0x23, 0x39, 0x1c, 0x93, 0x12, 0x9d, 0x58, 0x62, 0xe0, 0x37, 0xda, 0x89, 0x25, 0xac, |
| 0xe1, 0xa4, 0xac, 0xfe, 0xef, 0x0c, 0xe4, 0xfd, 0x67, 0xd9, 0x7f, 0xb9, 0xf9, 0x7e, 0x03, 0xf2, |
| 0x4c, 0xda, 0x51, 0xee, 0x85, 0xd5, 0xd2, 0xb7, 0x8e, 0x15, 0x57, 0x34, 0x31, 0x5d, 0xc2, 0x98, |
| 0xd9, 0x09, 0x92, 0x37, 0x6c, 0x62, 0xf6, 0x7c, 0x32, 0x0e, 0xf8, 0xe8, 0x1d, 0xf1, 0x0a, 0x35, |
| 0x59, 0xd8, 0x17, 0x56, 0x03, 0x48, 0x2c, 0xa9, 0xe7, 0x83, 0xda, 0xbc, 0x02, 0x97, 0xdf, 0x58, |
| 0x49, 0xa3, 0x07, 0x30, 0xd7, 0x26, 0xdc, 0xb4, 0x1d, 0xbf, 0x1d, 0x4c, 0x3d, 0x99, 0xf4, 0xc1, |
| 0x9a, 0xbe, 0xaa, 0x51, 0x12, 0x3e, 0xa9, 0x0f, 0x1c, 0x00, 0x8a, 0x83, 0x67, 0x79, 0x6d, 0x7f, |
| 0x4c, 0x9f, 0x8b, 0x0e, 0xde, 0xb6, 0xd7, 0x26, 0x58, 0x72, 0xf4, 0xc7, 0x1a, 0x94, 0x7c, 0xa4, |
| 0x6d, 0xb3, 0xcf, 0x08, 0xda, 0x08, 0x57, 0xe1, 0x6f, 0x77, 0x70, 0x27, 0xcf, 0xbe, 0x77, 0xd6, |
| 0x23, 0xe7, 0x83, 0x5a, 0x51, 0x8a, 0x89, 0x8f, 0x70, 0x01, 0xb1, 0x18, 0x65, 0x2e, 0x89, 0xd1, |
| 0xeb, 0x90, 0x93, 0xad, 0xb7, 0x0a, 0x66, 0xd8, 0xe8, 0xc9, 0xf6, 0x1c, 0xfb, 0x3c, 0xfd, 0xe3, |
| 0x0c, 0x94, 0x13, 0x8b, 0x4b, 0xd1, 0xd5, 0x85, 0xa3, 0x92, 0x4c, 0x8a, 0xf1, 0xdb, 0xe4, 0x7f, |
| 0xae, 0x7c, 0x1f, 0xf2, 0x96, 0x58, 0x5f, 0xf0, 0xdf, 0xad, 0x8d, 0x69, 0xb6, 0x42, 0x46, 0x26, |
| 0xca, 0x24, 0xf9, 0xc9, 0xb0, 0x02, 0x44, 0xb7, 0x60, 0x99, 0x12, 0x4e, 0xcf, 0xb6, 0x0e, 0x39, |
| 0xa1, 0xf1, 0xfe, 0x3f, 0x17, 0xf5, 0x3d, 0x78, 0x54, 0x00, 0x8f, 0xeb, 0x04, 0xa5, 0x32, 0xff, |
| 0x12, 0xa5, 0x52, 0x77, 0x60, 0xf6, 0x7f, 0xd8, 0xa3, 0xff, 0x00, 0x8a, 0x51, 0x17, 0xf5, 0x19, |
| 0x9b, 0xd4, 0x7f, 0x04, 0x05, 0x91, 0x8d, 0x41, 0xf7, 0x7f, 0xc9, 0x4d, 0x94, 0xbc, 0x23, 0x32, |
| 0x69, 0xee, 0x08, 0x7d, 0x13, 0xfc, 0xff, 0x99, 0x89, 0x6a, 0xea, 0xbf, 0xd8, 0x63, 0xd5, 0x34, |
| 0xfe, 0xfc, 0x8e, 0x8d, 0xcc, 0x7e, 0xa1, 0x01, 0xc8, 0xe7, 0xe3, 0xce, 0x09, 0x71, 0xb9, 0x70, |
| 0x4c, 0xec, 0xc0, 0xa8, 0x63, 0xf2, 0x18, 0x49, 0x0e, 0xba, 0x07, 0x79, 0x4f, 0x76, 0x57, 0x6a, |
| 0x86, 0x35, 0xe5, 0x38, 0x20, 0xcc, 0x3a, 0xbf, 0x45, 0xc3, 0x0a, 0xcc, 0x58, 0x7f, 0xfa, 0xbc, |
| 0x3a, 0xf3, 0xec, 0x79, 0x75, 0xe6, 0xa3, 0xe7, 0xd5, 0x99, 0x0f, 0x86, 0x55, 0xed, 0xe9, 0xb0, |
| 0xaa, 0x3d, 0x1b, 0x56, 0xb5, 0x8f, 0x86, 0x55, 0xed, 0xe3, 0x61, 0x55, 0x7b, 0xfc, 0x49, 0x75, |
| 0xe6, 0x41, 0xe6, 0x64, 0xe3, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6c, 0xc5, 0x28, 0xb2, 0x54, |
| 0x20, 0x00, 0x00, |
| } |