From bea189e9c953564fb3777b0ab625046662f77538 Mon Sep 17 00:00:00 2001 From: Dominika Hodovska Date: Tue, 14 Jun 2016 15:09:53 +0200 Subject: [PATCH 1/5] Add sysctl api, validation & Docker support --- pkg/api/helpers.go | 62 ++++++++++ pkg/api/helpers_test.go | 39 ++++++ pkg/api/types.go | 8 ++ pkg/api/validation/validation.go | 66 ++++++++++ pkg/api/validation/validation_test.go | 140 ++++++++++++++++++++++ pkg/kubelet/dockertools/docker_manager.go | 13 ++ 6 files changed, 328 insertions(+) diff --git a/pkg/api/helpers.go b/pkg/api/helpers.go index 617d49c46c8..50e811b352f 100644 --- a/pkg/api/helpers.go +++ b/pkg/api/helpers.go @@ -438,6 +438,20 @@ const ( // PreferAvoidPodsAnnotationKey represents the key of preferAvoidPods data (json serialized) // in the Annotations of a Node. PreferAvoidPodsAnnotationKey string = "scheduler.alpha.kubernetes.io/preferAvoidPods" + + // SysctlsPodAnnotationKey represents the key of sysctls which are set for the infrastructure + // container of a pod. The annotation value is a comma separated list of sysctl_name=value + // key-value pairs. Only a limited set of whitelisted and isolated sysctls is supported by + // the kubelet. Pods with other sysctls will fail to launch. + SysctlsPodAnnotationKey string = "security.alpha.kubernetes.io/sysctls" + + // UnsafeSysctlsPodAnnotationKey represents the key of sysctls which are set for the infrastructure + // container of a pod. The annotation value is a comma separated list of sysctl_name=value + // key-value pairs. Unsafe sysctls must be explicitly enabled for a kubelet. They are properly + // namespaced to a pod or a container, but their isolation is usually unclear or weak. Their use + // is at-your-own-risk. Pods that attempt to set an unsafe sysctl that is not enabled for a kubelet + // will fail to launch. + UnsafeSysctlsPodAnnotationKey string = "security.alpha.kubernetes.io/unsafe-sysctls" ) // GetAffinityFromPod gets the json serialized affinity data from Pod.Annotations @@ -522,3 +536,51 @@ func GetAvoidPodsFromNodeAnnotations(annotations map[string]string) (AvoidPods, } return avoidPods, nil } + +// SysctlsFromPodAnnotations parses the sysctl annotations into a slice of safe Sysctls +// and a slice of unsafe Sysctls. This is only a convenience wrapper around +// SysctlsFromPodAnnotation. +func SysctlsFromPodAnnotations(a map[string]string) ([]Sysctl, []Sysctl, error) { + safe, err := SysctlsFromPodAnnotation(a[SysctlsPodAnnotationKey]) + if err != nil { + return nil, nil, err + } + unsafe, err := SysctlsFromPodAnnotation(a[UnsafeSysctlsPodAnnotationKey]) + if err != nil { + return nil, nil, err + } + + return safe, unsafe, nil +} + +// SysctlsFromPodAnnotation parses an annotation value into a slice of Sysctls. +func SysctlsFromPodAnnotation(annotation string) ([]Sysctl, error) { + if len(annotation) == 0 { + return nil, nil + } + + kvs := strings.Split(annotation, ",") + sysctls := make([]Sysctl, len(kvs)) + for i, kv := range kvs { + cs := strings.Split(kv, "=") + if len(cs) != 2 { + return nil, fmt.Errorf("sysctl %q not of the format sysctl_name=value", kv) + } + sysctls[i].Name = cs[0] + sysctls[i].Value = cs[1] + } + return sysctls, nil +} + +// PodAnnotationsFromSysctls creates an annotation value for a slice of Sysctls. +func PodAnnotationsFromSysctls(sysctls []Sysctl) string { + if len(sysctls) == 0 { + return "" + } + + kvs := make([]string, len(sysctls)) + for i := range sysctls { + kvs[i] = fmt.Sprintf("%s=%s", sysctls[i].Name, sysctls[i].Value) + } + return strings.Join(kvs, ",") +} diff --git a/pkg/api/helpers_test.go b/pkg/api/helpers_test.go index 49b50b69e04..b40f6fdca3e 100644 --- a/pkg/api/helpers_test.go +++ b/pkg/api/helpers_test.go @@ -391,3 +391,42 @@ func TestGetAvoidPodsFromNode(t *testing.T) { } } } + +func TestSysctlsFromPodAnnotation(t *testing.T) { + type Test struct { + annotation string + expectValue []Sysctl + expectErr bool + } + for i, test := range []Test{ + { + annotation: "", + expectValue: nil, + }, + { + annotation: "foo.bar", + expectErr: true, + }, + { + annotation: "foo.bar=42", + expectValue: []Sysctl{{Name: "foo.bar", Value: "42"}}, + }, + { + annotation: "foo.bar=42,", + expectErr: true, + }, + { + annotation: "foo.bar=42,abc.def=1", + expectValue: []Sysctl{{Name: "foo.bar", Value: "42"}, {Name: "abc.def", Value: "1"}}, + }, + } { + sysctls, err := SysctlsFromPodAnnotation(test.annotation) + if test.expectErr && err == nil { + t.Errorf("[%v]expected error but got none", i) + } else if !test.expectErr && err != nil { + t.Errorf("[%v]did not expect error but got: %v", i, err) + } else if !reflect.DeepEqual(sysctls, test.expectValue) { + t.Errorf("[%v]expect value %v but got %v", i, test.expectValue, sysctls) + } + } +} diff --git a/pkg/api/types.go b/pkg/api/types.go index 99692b56331..5062276521d 100644 --- a/pkg/api/types.go +++ b/pkg/api/types.go @@ -1564,6 +1564,14 @@ type PodSpec struct { Subdomain string `json:"subdomain,omitempty"` } +// Sysctl defines a kernel parameter to be set +type Sysctl struct { + // Name of a property to set + Name string `json:"name"` + // Value of a property to set + Value string `json:"value"` +} + // PodSecurityContext holds pod-level security attributes and common container settings. // Some fields are also present in container.securityContext. Field values of // container.securityContext take precedence over field values of PodSecurityContext. diff --git a/pkg/api/validation/validation.go b/pkg/api/validation/validation.go index e14da40d992..42a8e5f6b78 100644 --- a/pkg/api/validation/validation.go +++ b/pkg/api/validation/validation.go @@ -23,6 +23,7 @@ import ( "os" "path" "reflect" + "regexp" "strings" "github.com/golang/glog" @@ -132,6 +133,23 @@ func ValidatePodSpecificAnnotations(annotations map[string]string, spec *api.Pod allErrs = append(allErrs, ValidateSeccompPodAnnotations(annotations, fldPath)...) allErrs = append(allErrs, ValidateAppArmorPodAnnotations(annotations, spec, fldPath)...) + sysctls, err := api.SysctlsFromPodAnnotation(annotations[api.SysctlsPodAnnotationKey]) + if err != nil { + allErrs = append(allErrs, field.Invalid(fldPath.Key(api.SysctlsPodAnnotationKey), annotations[api.SysctlsPodAnnotationKey], err.Error())) + } else { + allErrs = append(allErrs, validateSysctls(sysctls, fldPath.Key(api.SysctlsPodAnnotationKey))...) + } + unsafeSysctls, err := api.SysctlsFromPodAnnotation(annotations[api.UnsafeSysctlsPodAnnotationKey]) + if err != nil { + allErrs = append(allErrs, field.Invalid(fldPath.Key(api.UnsafeSysctlsPodAnnotationKey), annotations[api.UnsafeSysctlsPodAnnotationKey], err.Error())) + } else { + allErrs = append(allErrs, validateSysctls(unsafeSysctls, fldPath.Key(api.UnsafeSysctlsPodAnnotationKey))...) + } + inBoth := sysctlIntersection(sysctls, unsafeSysctls) + if len(inBoth) > 0 { + allErrs = append(allErrs, field.Invalid(fldPath.Key(api.UnsafeSysctlsPodAnnotationKey), strings.Join(inBoth, ", "), "can not be safe and unsafe")) + } + return allErrs } @@ -2128,6 +2146,40 @@ func podSpecHasContainer(spec *api.PodSpec, containerName string) bool { return false } +const ( + // a sysctl segment regex, concatenated with dots to form a sysctl name + SysctlSegmentFmt string = "[a-z0-9]([-_a-z0-9]*[a-z0-9])?" + + // a sysctl name regex + SysctlFmt string = "(" + SysctlSegmentFmt + "\\.)*" + SysctlSegmentFmt + + // the maximal length of a sysctl name + SysctlMaxLength int = 253 +) + +var sysctlRegexp = regexp.MustCompile("^" + SysctlFmt + "$") + +// IsValidSysctlName checks that the given string is a valid sysctl name, +// i.e. matches SysctlFmt. +func IsValidSysctlName(name string) bool { + if len(name) > SysctlMaxLength { + return false + } + return sysctlRegexp.MatchString(name) +} + +func validateSysctls(sysctls []api.Sysctl, fldPath *field.Path) field.ErrorList { + allErrs := field.ErrorList{} + for i, s := range sysctls { + if len(s.Name) == 0 { + allErrs = append(allErrs, field.Required(fldPath.Index(i).Child("name"), "")) + } else if !IsValidSysctlName(s.Name) { + allErrs = append(allErrs, field.Invalid(fldPath.Index(i).Child("name"), s.Name, fmt.Sprintf("must have at most %d characters and match regex %s", SysctlMaxLength, SysctlFmt))) + } + } + return allErrs +} + // ValidatePodSecurityContext test that the specified PodSecurityContext has valid data. func ValidatePodSecurityContext(securityContext *api.PodSecurityContext, spec *api.PodSpec, specPath, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} @@ -3475,3 +3527,17 @@ func isValidHostnamesMap(serializedPodHostNames string) bool { } return true } + +func sysctlIntersection(a []api.Sysctl, b []api.Sysctl) []string { + lookup := make(map[string]struct{}, len(a)) + result := []string{} + for i := range a { + lookup[a[i].Name] = struct{}{} + } + for i := range b { + if _, found := lookup[b[i].Name]; found { + result = append(result, b[i].Name) + } + } + return result +} diff --git a/pkg/api/validation/validation_test.go b/pkg/api/validation/validation_test.go index 9414136396d..334c851c846 100644 --- a/pkg/api/validation/validation_test.go +++ b/pkg/api/validation/validation_test.go @@ -3538,6 +3538,17 @@ func TestValidatePod(t *testing.T) { }, Spec: validPodSpec, }, + { // syntactically valid sysctls + ObjectMeta: api.ObjectMeta{ + Name: "123", + Namespace: "ns", + Annotations: map[string]string{ + api.SysctlsPodAnnotationKey: "kernel.shmmni=32768,kernel.shmmax=1000000000", + api.UnsafeSysctlsPodAnnotationKey: "knet.ipv4.route.min_pmtu=1000", + }, + }, + Spec: validPodSpec, + }, } for _, pod := range successCases { if errs := ValidatePod(&pod); len(errs) != 0 { @@ -3987,6 +3998,47 @@ func TestValidatePod(t *testing.T) { }, Spec: validPodSpec, }, + "invalid sysctl annotation": { + ObjectMeta: api.ObjectMeta{ + Name: "123", + Namespace: "ns", + Annotations: map[string]string{ + api.SysctlsPodAnnotationKey: "foo:", + }, + }, + Spec: validPodSpec, + }, + "invalid comma-separated sysctl annotation": { + ObjectMeta: api.ObjectMeta{ + Name: "123", + Namespace: "ns", + Annotations: map[string]string{ + api.SysctlsPodAnnotationKey: "kernel.msgmax,", + }, + }, + Spec: validPodSpec, + }, + "invalid unsafe sysctl annotation": { + ObjectMeta: api.ObjectMeta{ + Name: "123", + Namespace: "ns", + Annotations: map[string]string{ + api.SysctlsPodAnnotationKey: "foo:", + }, + }, + Spec: validPodSpec, + }, + "intersecting safe sysctls and unsafe sysctls annotations": { + ObjectMeta: api.ObjectMeta{ + Name: "123", + Namespace: "ns", + Annotations: map[string]string{ + api.SysctlsPodAnnotationKey: "kernel.shmmax=10000000", + api.UnsafeSysctlsPodAnnotationKey: "kernel.shmmax=10000000", + }, + }, + Spec: validPodSpec, + }, } for k, v := range errorCases { if errs := ValidatePod(&v); len(errs) == 0 { @@ -7826,3 +7878,91 @@ func TestValidateHasLabel(t *testing.T) { t.Errorf("expected failure") } } + +func TestIsValidSysctlName(t *testing.T) { + valid := []string{ + "a.b.c.d", + "a", + "a_b", + "a-b", + "abc", + "abc.def", + } + invalid := []string{ + "", + "*", + "ä", + "a_", + "_", + "__", + "_a", + "_a._b", + "-", + ".", + "a.", + ".a", + "a.b.", + "a*.b", + "a*b", + "*a", + "a.*", + "*", + "abc*", + "a.abc*", + "a.b.*", + "Abc", + func(n int) string { + x := make([]byte, n) + for i := range x { + x[i] = byte('a') + } + return string(x) + }(256), + } + for _, s := range valid { + if !IsValidSysctlName(s) { + t.Errorf("%q expected to be a valid sysctl name", s) + } + } + for _, s := range invalid { + if IsValidSysctlName(s) { + t.Errorf("%q expected to be an invalid sysctl name", s) + } + } +} + +func TestValidateSysctls(t *testing.T) { + valid := []string{ + "net.foo.bar", + "kernel.shmmax", + } + invalid := []string{ + "i..nvalid", + "_invalid", + } + + sysctls := make([]api.Sysctl, len(valid)) + for i, sysctl := range valid { + sysctls[i].Name = sysctl + } + errs := validateSysctls(sysctls, field.NewPath("foo")) + if len(errs) != 0 { + t.Errorf("unexpected validation errors: %v", errs) + } + + sysctls = make([]api.Sysctl, len(invalid)) + for i, sysctl := range invalid { + sysctls[i].Name = sysctl + } + errs = validateSysctls(sysctls, field.NewPath("foo")) + if len(errs) != 2 { + t.Errorf("expected 2 validation errors. Got: %v", errs) + } else { + if got, expected := errs[0].Error(), "foo"; !strings.Contains(got, expected) { + t.Errorf("unexpected errors: expected=%q, got=%q", expected, got) + } + if got, expected := errs[1].Error(), "foo"; !strings.Contains(got, expected) { + t.Errorf("unexpected errors: expected=%q, got=%q", expected, got) + } + } +} diff --git a/pkg/kubelet/dockertools/docker_manager.go b/pkg/kubelet/dockertools/docker_manager.go index 094039b4e54..26652567cf2 100644 --- a/pkg/kubelet/dockertools/docker_manager.go +++ b/pkg/kubelet/dockertools/docker_manager.go @@ -660,6 +660,19 @@ func (dm *DockerManager) runContainer( SecurityOpt: securityOpts, } + // Set sysctls if requested + sysctls, err := api.SysctlsFromPodAnnotation(pod.Annotations[api.SysctlsPodAnnotationKey]) + if err != nil { + dm.recorder.Eventf(ref, api.EventTypeWarning, events.FailedToCreateContainer, "Failed to create docker container %q of pod %q with error: %v", container.Name, format.Pod(pod), err) + return kubecontainer.ContainerID{}, err + } + if len(sysctls) > 0 { + hc.Sysctls = make(map[string]string, len(sysctls)) + for _, c := range sysctls { + hc.Sysctls[c.Name] = c.Value + } + } + // If current api version is newer than docker 1.10 requested, set OomScoreAdj to HostConfig result, err := dm.checkDockerAPIVersion(dockerV110APIVersion) if err != nil { From ed36baed20c1070974e2fc8e8561e3e264d6111f Mon Sep 17 00:00:00 2001 From: "Dr. Stefan Schimanski" Date: Fri, 19 Aug 2016 10:33:56 +0200 Subject: [PATCH 2/5] Add sysctl PodSecurityPolicy support --- pkg/apis/extensions/helpers.go | 37 ++++ pkg/apis/extensions/helpers_test.go | 62 +++++++ pkg/apis/extensions/types.go | 7 + pkg/apis/extensions/validation/validation.go | 41 +++++ .../extensions/validation/validation_test.go | 69 +++++++- pkg/security/podsecuritypolicy/factory.go | 20 +++ pkg/security/podsecuritypolicy/provider.go | 2 + .../sysctl/mustmatchpatterns.go | 92 ++++++++++ .../sysctl/mustmatchpatterns_test.go | 106 ++++++++++++ .../podsecuritypolicy/sysctl/types.go | 28 +++ pkg/security/podsecuritypolicy/types.go | 2 + .../podsecuritypolicy/admission_test.go | 161 +++++++++++++++++- 12 files changed, 620 insertions(+), 7 deletions(-) create mode 100644 pkg/apis/extensions/helpers.go create mode 100644 pkg/apis/extensions/helpers_test.go create mode 100644 pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns.go create mode 100644 pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns_test.go create mode 100644 pkg/security/podsecuritypolicy/sysctl/types.go diff --git a/pkg/apis/extensions/helpers.go b/pkg/apis/extensions/helpers.go new file mode 100644 index 00000000000..27d3e23add1 --- /dev/null +++ b/pkg/apis/extensions/helpers.go @@ -0,0 +1,37 @@ +/* +Copyright 2016 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. +*/ + +package extensions + +import ( + "strings" +) + +// SysctlsFromPodSecurityPolicyAnnotation parses an annotation value of the key +// SysctlsSecurityPolocyAnnotationKey into a slice of sysctls. An empty slice +// is returned if annotation is the empty string. +func SysctlsFromPodSecurityPolicyAnnotation(annotation string) ([]string, error) { + if len(annotation) == 0 { + return []string{}, nil + } + + return strings.Split(annotation, ","), nil +} + +// PodAnnotationsFromSysctls creates an annotation value for a slice of Sysctls. +func PodAnnotationsFromSysctls(sysctls []string) string { + return strings.Join(sysctls, ",") +} diff --git a/pkg/apis/extensions/helpers_test.go b/pkg/apis/extensions/helpers_test.go new file mode 100644 index 00000000000..29ae139ec96 --- /dev/null +++ b/pkg/apis/extensions/helpers_test.go @@ -0,0 +1,62 @@ +/* +Copyright 2016 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. +*/ + +package extensions + +import ( + "reflect" + "testing" +) + +func TestPodAnnotationsFromSysctls(t *testing.T) { + type Test struct { + sysctls []string + expectedValue string + } + for _, test := range []Test{ + {sysctls: []string{"a.b"}, expectedValue: "a.b"}, + {sysctls: []string{"a.b", "c.d"}, expectedValue: "a.b,c.d"}, + {sysctls: []string{"a.b", "a.b"}, expectedValue: "a.b,a.b"}, + {sysctls: []string{}, expectedValue: ""}, + {sysctls: nil, expectedValue: ""}, + } { + a := PodAnnotationsFromSysctls(test.sysctls) + if a != test.expectedValue { + t.Errorf("wrong value for %v: got=%q wanted=%q", test.sysctls, a, test.expectedValue) + } + } +} + +func TestSysctlsFromPodSecurityPolicyAnnotation(t *testing.T) { + type Test struct { + expectedValue []string + annotation string + } + for _, test := range []Test{ + {annotation: "a.b", expectedValue: []string{"a.b"}}, + {annotation: "a.b,c.d", expectedValue: []string{"a.b", "c.d"}}, + {annotation: "a.b,a.b", expectedValue: []string{"a.b", "a.b"}}, + {annotation: "", expectedValue: []string{}}, + } { + sysctls, err := SysctlsFromPodSecurityPolicyAnnotation(test.annotation) + if err != nil { + t.Errorf("error for %q: %v", test.annotation, err) + } + if !reflect.DeepEqual(sysctls, test.expectedValue) { + t.Errorf("wrong value for %q: got=%v wanted=%v", test.annotation, sysctls, test.expectedValue) + } + } +} diff --git a/pkg/apis/extensions/types.go b/pkg/apis/extensions/types.go index 6543cdfba3f..f98a10ebdd5 100644 --- a/pkg/apis/extensions/types.go +++ b/pkg/apis/extensions/types.go @@ -35,6 +35,13 @@ import ( "k8s.io/kubernetes/pkg/util/intstr" ) +const ( + // SysctlsPodSecurityPolicyAnnotationKey represents the key of a whitelist of + // allowed safe and unsafe sysctls in a pod spec. It's a comma-separated list of plain sysctl + // names or sysctl patterns (which end in *). The string "*" matches all sysctls. + SysctlsPodSecurityPolicyAnnotationKey string = "security.alpha.kubernetes.io/sysctls" +) + // describes the attributes of a scale subresource type ScaleSpec struct { // desired number of instances for the scaled object. diff --git a/pkg/apis/extensions/validation/validation.go b/pkg/apis/extensions/validation/validation.go index 1c7ef924662..bb2526d6679 100644 --- a/pkg/apis/extensions/validation/validation.go +++ b/pkg/apis/extensions/validation/validation.go @@ -574,6 +574,7 @@ func ValidatePodSecurityPolicySpec(spec *extensions.PodSecurityPolicySpec, fldPa func ValidatePodSecurityPolicySpecificAnnotations(annotations map[string]string, fldPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} + if p := annotations[apparmor.DefaultProfileAnnotationKey]; p != "" { if err := apparmor.ValidateProfileFormat(p); err != nil { allErrs = append(allErrs, field.Invalid(fldPath.Key(apparmor.DefaultProfileAnnotationKey), p, err.Error())) @@ -586,6 +587,16 @@ func ValidatePodSecurityPolicySpecificAnnotations(annotations map[string]string, } } } + + sysctlAnnotation := annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] + sysctlFldPath := fldPath.Key(extensions.SysctlsPodSecurityPolicyAnnotationKey) + sysctls, err := extensions.SysctlsFromPodSecurityPolicyAnnotation(sysctlAnnotation) + if err != nil { + allErrs = append(allErrs, field.Invalid(sysctlFldPath, sysctlAnnotation, err.Error())) + } else { + allErrs = append(allErrs, validatePodSecurityPolicySysctls(sysctlFldPath, sysctls)...) + } + return allErrs } @@ -674,6 +685,36 @@ func validatePodSecurityPolicyVolumes(fldPath *field.Path, volumes []extensions. return allErrs } +const sysctlPatternSegmentFmt string = "([a-z0-9][-_a-z0-9]*)?[a-z0-9*]" +const SysctlPatternFmt string = "(" + apivalidation.SysctlSegmentFmt + "\\.)*" + sysctlPatternSegmentFmt + +var sysctlPatternRegexp = regexp.MustCompile("^" + SysctlPatternFmt + "$") + +func IsValidSysctlPattern(name string) bool { + if len(name) > apivalidation.SysctlMaxLength { + return false + } + return sysctlPatternRegexp.MatchString(name) +} + +// validatePodSecurityPolicySysctls validates the sysctls fields of PodSecurityPolicy. +func validatePodSecurityPolicySysctls(fldPath *field.Path, sysctls []string) field.ErrorList { + allErrs := field.ErrorList{} + for i, s := range sysctls { + if !IsValidSysctlPattern(string(s)) { + allErrs = append( + allErrs, + field.Invalid(fldPath.Index(i), sysctls[i], fmt.Sprintf("must have at most %d characters and match regex %s", + apivalidation.SysctlMaxLength, + SysctlPatternFmt, + )), + ) + } + } + + return allErrs +} + // validateIDRanges ensures the range is valid. func validateIDRanges(fldPath *field.Path, rng extensions.IDRange) field.ErrorList { allErrs := field.ErrorList{} diff --git a/pkg/apis/extensions/validation/validation_test.go b/pkg/apis/extensions/validation/validation_test.go index 93e6f9b303a..1b4a366e67a 100644 --- a/pkg/apis/extensions/validation/validation_test.go +++ b/pkg/apis/extensions/validation/validation_test.go @@ -1512,7 +1512,8 @@ func TestValidatePodSecurityPolicy(t *testing.T) { validPSP := func() *extensions.PodSecurityPolicy { return &extensions.PodSecurityPolicy{ ObjectMeta: api.ObjectMeta{ - Name: "foo", + Name: "foo", + Annotations: map[string]string{}, }, Spec: extensions.PodSecurityPolicySpec{ SELinux: extensions.SELinuxStrategyOptions{ @@ -1596,6 +1597,9 @@ func TestValidatePodSecurityPolicy(t *testing.T) { apparmor.AllowedProfilesAnnotationKey: apparmor.ProfileRuntimeDefault + ",not-good", } + invalidSysctlPattern := validPSP() + invalidSysctlPattern.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "a.*.b" + errorCases := map[string]struct { psp *extensions.PodSecurityPolicy errorType field.ErrorType @@ -1686,6 +1690,11 @@ func TestValidatePodSecurityPolicy(t *testing.T) { errorType: field.ErrorTypeInvalid, errorDetail: "invalid AppArmor profile name: \"not-good\"", }, + "invalid sysctl pattern": { + psp: invalidSysctlPattern, + errorType: field.ErrorTypeInvalid, + errorDetail: fmt.Sprintf("must have at most 253 characters and match regex %s", SysctlPatternFmt), + }, } for k, v := range errorCases { @@ -1728,6 +1737,9 @@ func TestValidatePodSecurityPolicy(t *testing.T) { apparmor.AllowedProfilesAnnotationKey: apparmor.ProfileRuntimeDefault + "," + apparmor.ProfileNamePrefix + "foo", } + withSysctl := validPSP() + withSysctl.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "net.*" + successCases := map[string]struct { psp *extensions.PodSecurityPolicy }{ @@ -1749,6 +1761,9 @@ func TestValidatePodSecurityPolicy(t *testing.T) { "valid AppArmor annotations": { psp: validAppArmor, }, + "with network sysctls": { + psp: withSysctl, + }, } for k, v := range successCases { @@ -2031,6 +2046,58 @@ func TestValidateNetworkPolicyUpdate(t *testing.T) { } } +func TestIsValidSysctlPattern(t *testing.T) { + valid := []string{ + "a.b.c.d", + "a", + "a_b", + "a-b", + "abc", + "abc.def", + "*", + "a.*", + "*", + "abc*", + "a.abc*", + "a.b.*", + } + invalid := []string{ + "", + "ä", + "a_", + "_", + "_a", + "_a._b", + "__", + "-", + ".", + "a.", + ".a", + "a.b.", + "a*.b", + "a*b", + "*a", + "Abc", + func(n int) string { + x := make([]byte, n) + for i := range x { + x[i] = byte('a') + } + return string(x) + }(256), + } + for _, s := range valid { + if !IsValidSysctlPattern(s) { + t.Errorf("%q expected to be a valid sysctl pattern", s) + } + } + for _, s := range invalid { + if IsValidSysctlPattern(s) { + t.Errorf("%q expected to be an invalid sysctl pattern", s) + } + } +} + func newBool(val bool) *bool { p := new(bool) *p = val diff --git a/pkg/security/podsecuritypolicy/factory.go b/pkg/security/podsecuritypolicy/factory.go index f055c419876..8b187a45aba 100644 --- a/pkg/security/podsecuritypolicy/factory.go +++ b/pkg/security/podsecuritypolicy/factory.go @@ -25,6 +25,7 @@ import ( "k8s.io/kubernetes/pkg/security/podsecuritypolicy/capabilities" "k8s.io/kubernetes/pkg/security/podsecuritypolicy/group" "k8s.io/kubernetes/pkg/security/podsecuritypolicy/selinux" + "k8s.io/kubernetes/pkg/security/podsecuritypolicy/sysctl" "k8s.io/kubernetes/pkg/security/podsecuritypolicy/user" "k8s.io/kubernetes/pkg/util/errors" ) @@ -70,6 +71,19 @@ func (f *simpleStrategyFactory) CreateStrategies(psp *extensions.PodSecurityPoli errs = append(errs, err) } + var unsafeSysctls []string + if ann, found := psp.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey]; found { + var err error + unsafeSysctls, err = extensions.SysctlsFromPodSecurityPolicyAnnotation(ann) + if err != nil { + errs = append(errs, err) + } + } + sysctlsStrat, err := createSysctlsStrategy(unsafeSysctls) + if err != nil { + errs = append(errs, err) + } + if len(errs) > 0 { return nil, errors.NewAggregate(errs) } @@ -81,6 +95,7 @@ func (f *simpleStrategyFactory) CreateStrategies(psp *extensions.PodSecurityPoli FSGroupStrategy: fsGroupStrat, SupplementalGroupStrategy: supGroupStrat, CapabilitiesStrategy: capStrat, + SysctlsStrategy: sysctlsStrat, } return strategies, nil @@ -145,3 +160,8 @@ func createSupplementalGroupStrategy(opts *extensions.SupplementalGroupsStrategy func createCapabilitiesStrategy(defaultAddCaps, requiredDropCaps, allowedCaps []api.Capability) (capabilities.Strategy, error) { return capabilities.NewDefaultCapabilities(defaultAddCaps, requiredDropCaps, allowedCaps) } + +// createSysctlsStrategy creates a new unsafe sysctls strategy. +func createSysctlsStrategy(sysctlsPatterns []string) (sysctl.SysctlsStrategy, error) { + return sysctl.NewMustMatchPatterns(sysctlsPatterns) +} diff --git a/pkg/security/podsecuritypolicy/provider.go b/pkg/security/podsecuritypolicy/provider.go index 82a6156a3ad..6856a3adb8a 100644 --- a/pkg/security/podsecuritypolicy/provider.go +++ b/pkg/security/podsecuritypolicy/provider.go @@ -210,6 +210,8 @@ func (s *simpleProvider) ValidatePodSecurityContext(pod *api.Pod, fldPath *field allErrs = append(allErrs, field.Invalid(fldPath.Child("hostIPC"), pod.Spec.SecurityContext.HostIPC, "Host IPC is not allowed to be used")) } + allErrs = append(allErrs, s.strategies.SysctlsStrategy.Validate(pod)...) + return allErrs } diff --git a/pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns.go b/pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns.go new file mode 100644 index 00000000000..66b11f71446 --- /dev/null +++ b/pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns.go @@ -0,0 +1,92 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "fmt" + "strings" + + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/util/validation/field" +) + +// mustMatchPatterns implements the CapabilitiesStrategy interface +type mustMatchPatterns struct { + patterns []string +} + +var ( + _ SysctlsStrategy = &mustMatchPatterns{} + + defaultSysctlsPatterns = []string{"*"} +) + +// NewMustMatchPatterns creates a new mustMatchPattern strategy that will provide validation. +// Passing nil means the default pattern, passing an empty list means to disallow all sysctls. +func NewMustMatchPatterns(patterns []string) (SysctlsStrategy, error) { + if patterns == nil { + patterns = defaultSysctlsPatterns + } + return &mustMatchPatterns{ + patterns: patterns, + }, nil +} + +// Validate ensures that the specified values fall within the range of the strategy. +func (s *mustMatchPatterns) Validate(pod *api.Pod) field.ErrorList { + allErrs := field.ErrorList{} + allErrs = append(allErrs, s.validateAnnotation(pod, api.SysctlsPodAnnotationKey)...) + allErrs = append(allErrs, s.validateAnnotation(pod, api.UnsafeSysctlsPodAnnotationKey)...) + return allErrs +} + +func (s *mustMatchPatterns) validateAnnotation(pod *api.Pod, key string) field.ErrorList { + allErrs := field.ErrorList{} + + fieldPath := field.NewPath("pod", "metadata", "annotations").Key(key) + + sysctls, err := api.SysctlsFromPodAnnotation(pod.Annotations[key]) + if err != nil { + allErrs = append(allErrs, field.Invalid(fieldPath, pod.Annotations[key], err.Error())) + } + + if len(sysctls) > 0 { + if len(s.patterns) == 0 { + allErrs = append(allErrs, field.Invalid(fieldPath, pod.Annotations[key], "sysctls are not allowed")) + } else { + for i, sysctl := range sysctls { + allErrs = append(allErrs, s.ValidateSysctl(sysctl.Name, fieldPath.Index(i))...) + } + } + } + + return allErrs +} + +func (s *mustMatchPatterns) ValidateSysctl(sysctlName string, fldPath *field.Path) field.ErrorList { + for _, s := range s.patterns { + if s[len(s)-1] == '*' { + prefix := s[:len(s)-1] + if strings.HasPrefix(sysctlName, string(prefix)) { + return nil + } + } else if sysctlName == s { + return nil + } + } + return field.ErrorList{field.Forbidden(fldPath, fmt.Sprintf("sysctl %q is not allowed", sysctlName))} +} diff --git a/pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns_test.go b/pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns_test.go new file mode 100644 index 00000000000..23aefbcaabd --- /dev/null +++ b/pkg/security/podsecuritypolicy/sysctl/mustmatchpatterns_test.go @@ -0,0 +1,106 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "testing" + + "k8s.io/kubernetes/pkg/api" +) + +func TestValidate(t *testing.T) { + tests := map[string]struct { + patterns []string + allowed []string + disallowed []string + }{ + // no container requests + "nil": { + patterns: nil, + allowed: []string{"foo"}, + }, + "empty": { + patterns: []string{}, + disallowed: []string{"foo"}, + }, + "without wildcard": { + patterns: []string{"a", "a.b"}, + allowed: []string{"a", "a.b"}, + disallowed: []string{"b"}, + }, + "with catch-all wildcard": { + patterns: []string{"*"}, + allowed: []string{"a", "a.b"}, + }, + "with catch-all wildcard and non-wildcard": { + patterns: []string{"a.b.c", "*"}, + allowed: []string{"a", "a.b", "a.b.c", "b"}, + }, + "without catch-all wildcard": { + patterns: []string{"a.*", "b.*", "c.d.e", "d.e.f.*"}, + allowed: []string{"a.b", "b.c", "c.d.e", "d.e.f.g.h"}, + disallowed: []string{"a", "b", "c", "c.d", "d.e", "d.e.f"}, + }, + } + + for k, v := range tests { + strategy, err := NewMustMatchPatterns(v.patterns) + if err != nil { + t.Errorf("%s failed: %v", k, err) + continue + } + + pod := &api.Pod{} + errs := strategy.Validate(pod) + if len(errs) != 0 { + t.Errorf("%s: unexpected validaton errors for empty sysctls: %v", k, errs) + } + + sysctls := []api.Sysctl{} + for _, s := range v.allowed { + sysctls = append(sysctls, api.Sysctl{ + Name: s, + Value: "dummy", + }) + } + testAllowed := func(key string, category string) { + pod.Annotations = map[string]string{ + key: api.PodAnnotationsFromSysctls(sysctls), + } + errs = strategy.Validate(pod) + if len(errs) != 0 { + t.Errorf("%s: unexpected validaton errors for %s sysctls: %v", k, category, errs) + } + } + testDisallowed := func(key string, category string) { + for _, s := range v.disallowed { + pod.Annotations = map[string]string{ + key: api.PodAnnotationsFromSysctls([]api.Sysctl{{s, "dummy"}}), + } + errs = strategy.Validate(pod) + if len(errs) == 0 { + t.Errorf("%s: expected error for %s sysctl %q", k, category, s) + } + } + } + + testAllowed(api.SysctlsPodAnnotationKey, "safe") + testAllowed(api.UnsafeSysctlsPodAnnotationKey, "unsafe") + testDisallowed(api.SysctlsPodAnnotationKey, "safe") + testDisallowed(api.UnsafeSysctlsPodAnnotationKey, "unsafe") + } +} diff --git a/pkg/security/podsecuritypolicy/sysctl/types.go b/pkg/security/podsecuritypolicy/sysctl/types.go new file mode 100644 index 00000000000..6d41ed14c6b --- /dev/null +++ b/pkg/security/podsecuritypolicy/sysctl/types.go @@ -0,0 +1,28 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/util/validation/field" +) + +// SysctlsStrategy defines the interface for all sysctl strategies. +type SysctlsStrategy interface { + // Validate ensures that the specified values fall within the range of the strategy. + Validate(pod *api.Pod) field.ErrorList +} diff --git a/pkg/security/podsecuritypolicy/types.go b/pkg/security/podsecuritypolicy/types.go index 7cf9104986b..d1d34fd16de 100644 --- a/pkg/security/podsecuritypolicy/types.go +++ b/pkg/security/podsecuritypolicy/types.go @@ -23,6 +23,7 @@ import ( "k8s.io/kubernetes/pkg/security/podsecuritypolicy/capabilities" "k8s.io/kubernetes/pkg/security/podsecuritypolicy/group" "k8s.io/kubernetes/pkg/security/podsecuritypolicy/selinux" + "k8s.io/kubernetes/pkg/security/podsecuritypolicy/sysctl" "k8s.io/kubernetes/pkg/security/podsecuritypolicy/user" "k8s.io/kubernetes/pkg/util/validation/field" ) @@ -63,4 +64,5 @@ type ProviderStrategies struct { FSGroupStrategy group.GroupStrategy SupplementalGroupStrategy group.GroupStrategy CapabilitiesStrategy capabilities.Strategy + SysctlsStrategy sysctl.SysctlsStrategy } diff --git a/plugin/pkg/admission/security/podsecuritypolicy/admission_test.go b/plugin/pkg/admission/security/podsecuritypolicy/admission_test.go index 53fc22ae281..a0631d6d2b2 100644 --- a/plugin/pkg/admission/security/podsecuritypolicy/admission_test.go +++ b/plugin/pkg/admission/security/podsecuritypolicy/admission_test.go @@ -26,7 +26,7 @@ import ( kadmission "k8s.io/kubernetes/pkg/admission" kapi "k8s.io/kubernetes/pkg/api" - extensions "k8s.io/kubernetes/pkg/apis/extensions" + "k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/auth/user" "k8s.io/kubernetes/pkg/client/cache" clientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset" @@ -34,7 +34,7 @@ import ( "k8s.io/kubernetes/pkg/security/apparmor" kpsp "k8s.io/kubernetes/pkg/security/podsecuritypolicy" psputil "k8s.io/kubernetes/pkg/security/podsecuritypolicy/util" - diff "k8s.io/kubernetes/pkg/util/diff" + "k8s.io/kubernetes/pkg/util/diff" ) const defaultContainerName = "test-c" @@ -1028,6 +1028,151 @@ func TestAdmitReadOnlyRootFilesystem(t *testing.T) { } } +func TestAdmitSysctls(t *testing.T) { + podWithSysctls := func(safeSysctls []string, unsafeSysctls []string) *kapi.Pod { + pod := goodPod() + dummySysctls := func(names []string) []kapi.Sysctl { + sysctls := make([]kapi.Sysctl, len(names)) + for i, n := range names { + sysctls[i].Name = n + sysctls[i].Value = "dummy" + } + return sysctls + } + pod.Annotations[kapi.SysctlsPodAnnotationKey] = kapi.PodAnnotationsFromSysctls(dummySysctls(safeSysctls)) + pod.Annotations[kapi.UnsafeSysctlsPodAnnotationKey] = kapi.PodAnnotationsFromSysctls(dummySysctls(unsafeSysctls)) + return pod + } + + noSysctls := restrictivePSP() + noSysctls.Name = "no sysctls" + + emptySysctls := restrictivePSP() + emptySysctls.Name = "empty sysctls" + emptySysctls.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "" + + mixedSysctls := restrictivePSP() + mixedSysctls.Name = "wildcard sysctls" + mixedSysctls.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "a.*,b.*,c,d.e.f" + + aSysctl := restrictivePSP() + aSysctl.Name = "a sysctl" + aSysctl.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "a" + + bSysctl := restrictivePSP() + bSysctl.Name = "b sysctl" + bSysctl.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "b" + + cSysctl := restrictivePSP() + cSysctl.Name = "c sysctl" + cSysctl.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "c" + + catchallSysctls := restrictivePSP() + catchallSysctls.Name = "catchall sysctl" + catchallSysctls.Annotations[extensions.SysctlsPodSecurityPolicyAnnotationKey] = "*" + + tests := map[string]struct { + pod *kapi.Pod + psps []*extensions.PodSecurityPolicy + shouldPass bool + expectedPSP string + }{ + "pod without unsafe sysctls request allowed under noSysctls PSP": { + pod: goodPod(), + psps: []*extensions.PodSecurityPolicy{noSysctls}, + shouldPass: true, + expectedPSP: noSysctls.Name, + }, + "pod without any sysctls request allowed under emptySysctls PSP": { + pod: goodPod(), + psps: []*extensions.PodSecurityPolicy{emptySysctls}, + shouldPass: true, + expectedPSP: emptySysctls.Name, + }, + "pod with safe sysctls request allowed under noSysctls PSP": { + pod: podWithSysctls([]string{"a", "b"}, []string{}), + psps: []*extensions.PodSecurityPolicy{noSysctls}, + shouldPass: true, + expectedPSP: noSysctls.Name, + }, + "pod with unsafe sysctls request allowed under noSysctls PSP": { + pod: podWithSysctls([]string{}, []string{"a", "b"}), + psps: []*extensions.PodSecurityPolicy{noSysctls}, + shouldPass: true, + expectedPSP: noSysctls.Name, + }, + "pod with safe sysctls request disallowed under emptySysctls PSP": { + pod: podWithSysctls([]string{"a", "b"}, []string{}), + psps: []*extensions.PodSecurityPolicy{emptySysctls}, + shouldPass: false, + }, + "pod with unsafe sysctls request disallowed under emptySysctls PSP": { + pod: podWithSysctls([]string{}, []string{"a", "b"}), + psps: []*extensions.PodSecurityPolicy{emptySysctls}, + shouldPass: false, + }, + "pod with matching sysctls request allowed under mixedSysctls PSP": { + pod: podWithSysctls([]string{"a.b", "b.c"}, []string{"c", "d.e.f"}), + psps: []*extensions.PodSecurityPolicy{mixedSysctls}, + shouldPass: true, + expectedPSP: mixedSysctls.Name, + }, + "pod with not-matching unsafe sysctls request allowed under mixedSysctls PSP": { + pod: podWithSysctls([]string{"a.b", "b.c", "c", "d.e.f"}, []string{"e"}), + psps: []*extensions.PodSecurityPolicy{mixedSysctls}, + shouldPass: false, + }, + "pod with not-matching safe sysctls request allowed under mixedSysctls PSP": { + pod: podWithSysctls([]string{"a.b", "b.c", "c", "d.e.f", "e"}, []string{}), + psps: []*extensions.PodSecurityPolicy{mixedSysctls}, + shouldPass: false, + }, + "pod with sysctls request allowed under catchallSysctls PSP": { + pod: podWithSysctls([]string{"e"}, []string{"f"}), + psps: []*extensions.PodSecurityPolicy{catchallSysctls}, + shouldPass: true, + expectedPSP: catchallSysctls.Name, + }, + "pod with sysctls request allowed under catchallSysctls PSP, not under mixedSysctls or emptySysctls PSP": { + pod: podWithSysctls([]string{"e"}, []string{"f"}), + psps: []*extensions.PodSecurityPolicy{mixedSysctls, catchallSysctls, emptySysctls}, + shouldPass: true, + expectedPSP: catchallSysctls.Name, + }, + "pod with safe c sysctl request allowed under cSysctl PSP, not under aSysctl or bSysctl PSP": { + pod: podWithSysctls([]string{}, []string{"c"}), + psps: []*extensions.PodSecurityPolicy{aSysctl, bSysctl, cSysctl}, + shouldPass: true, + expectedPSP: cSysctl.Name, + }, + "pod with unsafe c sysctl request allowed under cSysctl PSP, not under aSysctl or bSysctl PSP": { + pod: podWithSysctls([]string{"c"}, []string{}), + psps: []*extensions.PodSecurityPolicy{aSysctl, bSysctl, cSysctl}, + shouldPass: true, + expectedPSP: cSysctl.Name, + }, + } + + for k, v := range tests { + origSafeSysctls, origUnsafeSysctls, err := kapi.SysctlsFromPodAnnotations(v.pod.Annotations) + if err != nil { + t.Fatalf("invalid sysctl annotation: %v", err) + } + + testPSPAdmit(k, v.psps, v.pod, v.shouldPass, v.expectedPSP, t) + + if v.shouldPass { + safeSysctls, unsafeSysctls, _ := kapi.SysctlsFromPodAnnotations(v.pod.Annotations) + if !reflect.DeepEqual(safeSysctls, origSafeSysctls) { + t.Errorf("%s: wrong safe sysctls: expected=%v, got=%v", k, origSafeSysctls, safeSysctls) + } + if !reflect.DeepEqual(unsafeSysctls, origUnsafeSysctls) { + t.Errorf("%s: wrong unsafe sysctls: expected=%v, got=%v", k, origSafeSysctls, safeSysctls) + } + } + } +} + func testPSPAdmit(testCaseName string, psps []*extensions.PodSecurityPolicy, pod *kapi.Pod, shouldPass bool, expectedPSP string, t *testing.T) { namespace := createNamespaceForTest() serviceAccount := createSAForTest() @@ -1044,17 +1189,17 @@ func testPSPAdmit(testCaseName string, psps []*extensions.PodSecurityPolicy, pod err := plugin.Admit(attrs) if shouldPass && err != nil { - t.Errorf("%s expected no errors but received %v", testCaseName, err) + t.Errorf("%s: expected no errors but received %v", testCaseName, err) } if shouldPass && err == nil { if pod.Annotations[psputil.ValidatedPSPAnnotation] != expectedPSP { - t.Errorf("%s expected to validate under %s but found %s", testCaseName, expectedPSP, pod.Annotations[psputil.ValidatedPSPAnnotation]) + t.Errorf("%s: expected to validate under %s but found %s", testCaseName, expectedPSP, pod.Annotations[psputil.ValidatedPSPAnnotation]) } } if !shouldPass && err == nil { - t.Errorf("%s expected errors but received none", testCaseName) + t.Errorf("%s: expected errors but received none", testCaseName) } } @@ -1238,7 +1383,8 @@ func TestCreateProvidersFromConstraints(t *testing.T) { func restrictivePSP() *extensions.PodSecurityPolicy { return &extensions.PodSecurityPolicy{ ObjectMeta: kapi.ObjectMeta{ - Name: "restrictive", + Name: "restrictive", + Annotations: map[string]string{}, }, Spec: extensions.PodSecurityPolicySpec{ RunAsUser: extensions.RunAsUserStrategyOptions{ @@ -1291,6 +1437,9 @@ func createSAForTest() *kapi.ServiceAccount { // psp when defaults are filled in. func goodPod() *kapi.Pod { return &kapi.Pod{ + ObjectMeta: kapi.ObjectMeta{ + Annotations: map[string]string{}, + }, Spec: kapi.PodSpec{ ServiceAccountName: "default", SecurityContext: &kapi.PodSecurityContext{}, From e356e5224775c0746ae98e8b7901028d4d25ed97 Mon Sep 17 00:00:00 2001 From: "Dr. Stefan Schimanski" Date: Fri, 19 Aug 2016 10:53:25 +0200 Subject: [PATCH 3/5] Add sysctl whitelist on the node --- cmd/kubelet/app/options/options.go | 1 + cmd/kubelet/app/server.go | 3 + hack/.linted_packages | 2 + hack/verify-flags/known-flags.txt | 1 + pkg/apis/componentconfig/types.go | 2 + pkg/apis/componentconfig/v1alpha1/types.go | 3 + pkg/kubelet/dockertools/docker_manager.go | 12 +- pkg/kubelet/kubelet.go | 22 +++ pkg/kubelet/sysctl/namespace.go | 60 ++++++++ pkg/kubelet/sysctl/namespace_test.go | 36 +++++ pkg/kubelet/sysctl/runtime.go | 96 ++++++++++++ pkg/kubelet/sysctl/whitelist.go | 171 +++++++++++++++++++++ pkg/kubelet/sysctl/whitelist_test.go | 84 ++++++++++ 13 files changed, 489 insertions(+), 4 deletions(-) create mode 100644 pkg/kubelet/sysctl/namespace.go create mode 100644 pkg/kubelet/sysctl/namespace_test.go create mode 100644 pkg/kubelet/sysctl/runtime.go create mode 100644 pkg/kubelet/sysctl/whitelist.go create mode 100644 pkg/kubelet/sysctl/whitelist_test.go diff --git a/cmd/kubelet/app/options/options.go b/cmd/kubelet/app/options/options.go index 05a87b15224..4435d506deb 100644 --- a/cmd/kubelet/app/options/options.go +++ b/cmd/kubelet/app/options/options.go @@ -183,6 +183,7 @@ func (s *KubeletServer) AddFlags(fs *pflag.FlagSet) { fs.BoolVar(&s.MakeIPTablesUtilChains, "make-iptables-util-chains", s.MakeIPTablesUtilChains, "If true, kubelet will ensure iptables utility rules are present on host.") fs.Int32Var(&s.IPTablesMasqueradeBit, "iptables-masquerade-bit", s.IPTablesMasqueradeBit, "The bit of the fwmark space to mark packets for SNAT. Must be within the range [0, 31]. Please match this parameter with corresponding parameter in kube-proxy.") fs.Int32Var(&s.IPTablesDropBit, "iptables-drop-bit", s.IPTablesDropBit, "The bit of the fwmark space to mark packets for dropping. Must be within the range [0, 31].") + fs.StringSliceVar(&s.AllowedUnsafeSysctls, "experimental-allowed-unsafe-sysctls", s.AllowedUnsafeSysctls, "Comma-separated whitelist of unsafe sysctls or unsafe sysctl patterns (ending in *). Use these at your own risk.") // Flags intended for testing, not recommended used in production environments. fs.StringVar(&s.RemoteRuntimeEndpoint, "container-runtime-endpoint", s.RemoteRuntimeEndpoint, "The unix socket endpoint of remote runtime service. If not empty, this option will override --container-runtime. This is an experimental feature. Intended for testing only.") diff --git a/cmd/kubelet/app/server.go b/cmd/kubelet/app/server.go index 47890f8e476..3d3787e66fa 100644 --- a/cmd/kubelet/app/server.go +++ b/cmd/kubelet/app/server.go @@ -290,6 +290,7 @@ func UnsecuredKubeletConfig(s *options.KubeletServer) (*KubeletConfig, error) { StandaloneMode: (len(s.APIServerList) == 0), StreamingConnectionIdleTimeout: s.StreamingConnectionIdleTimeout.Duration, SyncFrequency: s.SyncFrequency.Duration, + AllowedUnsafeSysctls: s.AllowedUnsafeSysctls, SystemCgroups: s.SystemCgroups, TLSOptions: tlsOptions, Writer: writer, @@ -1098,6 +1099,7 @@ type KubeletConfig struct { StandaloneMode bool StreamingConnectionIdleTimeout time.Duration SyncFrequency time.Duration + AllowedUnsafeSysctls []string SystemCgroups string TLSOptions *server.TLSOptions Writer io.Writer @@ -1218,6 +1220,7 @@ func CreateAndInitKubelet(kc *KubeletConfig) (k KubeletBootstrap, pc *config.Pod kc.MakeIPTablesUtilChains, kc.iptablesMasqueradeBit, kc.iptablesDropBit, + kc.AllowedUnsafeSysctls, ) if err != nil { diff --git a/hack/.linted_packages b/hack/.linted_packages index 383f631ad23..98df7d91ddb 100644 --- a/hack/.linted_packages +++ b/hack/.linted_packages @@ -100,6 +100,7 @@ pkg/kubelet/api pkg/kubelet/container pkg/kubelet/envvars pkg/kubelet/eviction +pkg/kubelet/sysctls pkg/kubelet/util/format pkg/kubelet/util/ioutils pkg/kubelet/volume @@ -139,6 +140,7 @@ pkg/runtime/serializer/yaml pkg/security pkg/security/podsecuritypolicy/apparmor pkg/security/podsecuritypolicy/capabilities +pkg/security/podsecuritypolicy/sysctl pkg/serviceaccount pkg/storage pkg/storage/etcd3 diff --git a/hack/verify-flags/known-flags.txt b/hack/verify-flags/known-flags.txt index 789bb6ca499..a5b14a90aa6 100644 --- a/hack/verify-flags/known-flags.txt +++ b/hack/verify-flags/known-flags.txt @@ -164,6 +164,7 @@ executor-logv executor-path executor-suicide-timeout exit-on-lock-contention +experimental-allowed-unsafe-sysctls experimental-bootstrap-kubeconfig experimental-flannel-overlay experimental-keystone-url diff --git a/pkg/apis/componentconfig/types.go b/pkg/apis/componentconfig/types.go index 145ceaba3a8..71fa4731508 100644 --- a/pkg/apis/componentconfig/types.go +++ b/pkg/apis/componentconfig/types.go @@ -419,6 +419,8 @@ type KubeletConfiguration struct { // iptablesDropBit is the bit of the iptables fwmark space to use for dropping packets. Kubelet will ensure iptables mark and drop rules. // Values must be within the range [0, 31]. Must be different from IPTablesMasqueradeBit IPTablesDropBit int32 `json:"iptablesDropBit"` + // Whitelist of unsafe sysctls or sysctl patterns (ending in *). + AllowedUnsafeSysctls []string `json:"experimentalAllowedUnsafeSysctls,omitempty"` } type KubeSchedulerConfiguration struct { diff --git a/pkg/apis/componentconfig/v1alpha1/types.go b/pkg/apis/componentconfig/v1alpha1/types.go index fd4b874df42..8b0227dc26d 100644 --- a/pkg/apis/componentconfig/v1alpha1/types.go +++ b/pkg/apis/componentconfig/v1alpha1/types.go @@ -474,4 +474,7 @@ type KubeletConfiguration struct { // iptablesDropBit is the bit of the iptables fwmark space to mark for dropping packets. // Values must be within the range [0, 31]. Must be different from other mark bits. IPTablesDropBit *int32 `json:"iptablesDropBit"` + // Whitelist of unsafe sysctls or sysctl patterns (ending in *). Use these at your own risk. + // Resource isolation might be lacking and pod might influence each other on the same node. + AllowedUnsafeSysctls []string `json:"allowedUnsafeSysctls,omitempty"` } diff --git a/pkg/kubelet/dockertools/docker_manager.go b/pkg/kubelet/dockertools/docker_manager.go index 26652567cf2..de20c69a190 100644 --- a/pkg/kubelet/dockertools/docker_manager.go +++ b/pkg/kubelet/dockertools/docker_manager.go @@ -76,9 +76,10 @@ const ( // docker version should be at least 1.9.x minimumDockerAPIVersion = "1.21" - // Remote API version for docker daemon version v1.10 + // Remote API version for docker daemon versions // https://docs.docker.com/engine/reference/api/docker_remote_api/ dockerV110APIVersion = "1.22" + DockerV112APIVersion = "1.24" // ndots specifies the minimum number of dots that a domain name must contain for the resolver to consider it as FQDN (fully-qualified) // we want to able to consider SRV lookup names like _dns._udp.kube-dns.default.svc to be considered relative. @@ -661,16 +662,19 @@ func (dm *DockerManager) runContainer( } // Set sysctls if requested - sysctls, err := api.SysctlsFromPodAnnotation(pod.Annotations[api.SysctlsPodAnnotationKey]) + sysctls, unsafeSysctls, err := api.SysctlsFromPodAnnotations(pod.Annotations) if err != nil { dm.recorder.Eventf(ref, api.EventTypeWarning, events.FailedToCreateContainer, "Failed to create docker container %q of pod %q with error: %v", container.Name, format.Pod(pod), err) return kubecontainer.ContainerID{}, err } - if len(sysctls) > 0 { - hc.Sysctls = make(map[string]string, len(sysctls)) + if len(sysctls)+len(unsafeSysctls) > 0 { + hc.Sysctls = make(map[string]string, len(sysctls)+len(unsafeSysctls)) for _, c := range sysctls { hc.Sysctls[c.Name] = c.Value } + for _, c := range unsafeSysctls { + hc.Sysctls[c.Name] = c.Value + } } // If current api version is newer than docker 1.10 requested, set OomScoreAdj to HostConfig diff --git a/pkg/kubelet/kubelet.go b/pkg/kubelet/kubelet.go index ecd9e3579a0..2bcac327d12 100644 --- a/pkg/kubelet/kubelet.go +++ b/pkg/kubelet/kubelet.go @@ -67,6 +67,7 @@ import ( "k8s.io/kubernetes/pkg/kubelet/server" "k8s.io/kubernetes/pkg/kubelet/server/stats" "k8s.io/kubernetes/pkg/kubelet/status" + "k8s.io/kubernetes/pkg/kubelet/sysctl" kubetypes "k8s.io/kubernetes/pkg/kubelet/types" "k8s.io/kubernetes/pkg/kubelet/util/format" "k8s.io/kubernetes/pkg/kubelet/util/ioutils" @@ -249,6 +250,7 @@ func NewMainKubelet( makeIPTablesUtilChains bool, iptablesMasqueradeBit int, iptablesDropBit int, + allowedUnsafeSysctls []string, ) (*Kubelet, error) { if rootDirectory == "" { return nil, fmt.Errorf("invalid root directory %q", rootDirectory) @@ -591,6 +593,26 @@ func NewMainKubelet( klet.evictionManager = evictionManager klet.AddPodAdmitHandler(evictionAdmitHandler) + // add sysctl admission + runtimeSupport, err := sysctl.NewRuntimeAdmitHandler(klet.containerRuntime) + if err != nil { + return nil, err + } + safeWhitelist, err := sysctl.NewWhitelist(sysctl.SafeSysctlWhitelist(), api.SysctlsPodAnnotationKey) + if err != nil { + return nil, err + } + // Safe, whitelisted sysctls can always be used as unsafe sysctls in the spec + // Hence, we concatenate those two lists. + safeAndUnsafeSysctls := append(sysctl.SafeSysctlWhitelist(), allowedUnsafeSysctls...) + unsafeWhitelist, err := sysctl.NewWhitelist(safeAndUnsafeSysctls, api.UnsafeSysctlsPodAnnotationKey) + if err != nil { + return nil, err + } + klet.AddPodAdmitHandler(runtimeSupport) + klet.AddPodAdmitHandler(safeWhitelist) + klet.AddPodAdmitHandler(unsafeWhitelist) + // enable active deadline handler activeDeadlineHandler, err := newActiveDeadlineHandler(klet.statusManager, klet.recorder, klet.clock) if err != nil { diff --git a/pkg/kubelet/sysctl/namespace.go b/pkg/kubelet/sysctl/namespace.go new file mode 100644 index 00000000000..1619998f3f8 --- /dev/null +++ b/pkg/kubelet/sysctl/namespace.go @@ -0,0 +1,60 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "strings" +) + +// Namespace represents a kernel namespace name. +type Namespace string + +const ( + // the Linux IPC namespace + IpcNamespace = Namespace("ipc") + + // the network namespace + NetNamespace = Namespace("net") + + // the zero value if no namespace is known + UnknownNamespace = Namespace("") +) + +var namespaces = map[string]Namespace{ + "kernel.sem": IpcNamespace, +} + +var prefixNamespaces = map[string]Namespace{ + "kernel.shm": IpcNamespace, + "kernel.msg": IpcNamespace, + "fs.mqueue.": IpcNamespace, + "net.": NetNamespace, +} + +// NamespacedBy returns the namespace of the Linux kernel for a sysctl, or +// UnknownNamespace if the sysctl is not known to be namespaced. +func NamespacedBy(val string) Namespace { + if ns, found := namespaces[val]; found { + return ns + } + for p, ns := range prefixNamespaces { + if strings.HasPrefix(val, p) { + return ns + } + } + return UnknownNamespace +} diff --git a/pkg/kubelet/sysctl/namespace_test.go b/pkg/kubelet/sysctl/namespace_test.go new file mode 100644 index 00000000000..a5db297bfc4 --- /dev/null +++ b/pkg/kubelet/sysctl/namespace_test.go @@ -0,0 +1,36 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "testing" +) + +func TestNamespacedBy(t *testing.T) { + tests := map[string]Namespace{ + "kernel.shm_rmid_forced": IpcNamespace, + "net.a.b.c": NetNamespace, + "fs.mqueue.a.b.c": IpcNamespace, + "foo": UnknownNamespace, + } + + for sysctl, ns := range tests { + if got := NamespacedBy(sysctl); got != ns { + t.Errorf("wrong namespace for %q: got=%s want=%s", sysctl, got, ns) + } + } +} diff --git a/pkg/kubelet/sysctl/runtime.go b/pkg/kubelet/sysctl/runtime.go new file mode 100644 index 00000000000..1061d3aa85a --- /dev/null +++ b/pkg/kubelet/sysctl/runtime.go @@ -0,0 +1,96 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "fmt" + + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/kubelet/container" + "k8s.io/kubernetes/pkg/kubelet/dockertools" + "k8s.io/kubernetes/pkg/kubelet/lifecycle" +) + +const ( + UnsupportedReason = "SysctlUnsupported" +) + +type runtimeAdmitHandler struct { + result lifecycle.PodAdmitResult +} + +var _ lifecycle.PodAdmitHandler = &runtimeAdmitHandler{} + +// NewRuntimeAdmitHandler returns a sysctlRuntimeAdmitHandler which checks whether +// the given runtime support sysctls. +func NewRuntimeAdmitHandler(runtime container.Runtime) (*runtimeAdmitHandler, error) { + if runtime.Type() == dockertools.DockerType { + v, err := runtime.APIVersion() + if err != nil { + return nil, fmt.Errorf("failed to get runtime version: %v", err) + } + + // only Docker >= 1.12 supports sysctls + c, err := v.Compare(dockertools.DockerV112APIVersion) + if err != nil { + return nil, fmt.Errorf("failed to compare Docker version for sysctl support: %v", err) + } + if c >= 0 { + return &runtimeAdmitHandler{ + result: lifecycle.PodAdmitResult{ + Admit: true, + }, + }, nil + } + return &runtimeAdmitHandler{ + result: lifecycle.PodAdmitResult{ + Admit: false, + Reason: UnsupportedReason, + Message: "Docker before 1.12 does not support sysctls", + }, + }, nil + } + + // for other runtimes like rkt sysctls are not supported + return &runtimeAdmitHandler{ + result: lifecycle.PodAdmitResult{ + Admit: false, + Reason: UnsupportedReason, + Message: fmt.Sprintf("runtime %v does not support sysctls", runtime.Type()), + }, + }, nil +} + +// Admit checks whether the runtime supports sysctls. +func (w *runtimeAdmitHandler) Admit(attrs *lifecycle.PodAdmitAttributes) lifecycle.PodAdmitResult { + sysctls, unsafeSysctls, err := api.SysctlsFromPodAnnotations(attrs.Pod.Annotations) + if err != nil { + return lifecycle.PodAdmitResult{ + Admit: false, + Reason: AnnotationInvalidReason, + Message: fmt.Sprintf("invalid sysctl annotation: %v", err), + } + } + + if len(sysctls)+len(unsafeSysctls) > 0 { + return w.result + } + + return lifecycle.PodAdmitResult{ + Admit: true, + } +} diff --git a/pkg/kubelet/sysctl/whitelist.go b/pkg/kubelet/sysctl/whitelist.go new file mode 100644 index 00000000000..5b123312e35 --- /dev/null +++ b/pkg/kubelet/sysctl/whitelist.go @@ -0,0 +1,171 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "fmt" + "strings" + + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/api/validation" + extvalidation "k8s.io/kubernetes/pkg/apis/extensions/validation" + "k8s.io/kubernetes/pkg/kubelet/lifecycle" +) + +const ( + AnnotationInvalidReason = "InvalidSysctlAnnotation" + ForbiddenReason = "SysctlForbidden" +) + +// SafeSysctlWhitelist returns the whitelist of safe sysctls and safe sysctl patterns (ending in *). +// +// A sysctl is called safe iff +// - it is namespaced in the container or the pod +// - it is isolated, i.e. has no influence on any other pod on the same node. +func SafeSysctlWhitelist() []string { + return []string{ + "kernel.shm_rmid_forced", + "net.ipv4.ip_local_port_range", + "net.ipv4.tcp_max_syn_backlog", + "net.ipv4.tcp_syncookies", + } +} + +// Whitelist provides a list of allowed sysctls and sysctl patterns (ending in *) +// and a function to check whether a given sysctl matches this list. +type Whitelist interface { + // Validate checks that all sysctls given in a api.SysctlsPodAnnotationKey annotation + // are valid according to the whitelist. + Validate(pod *api.Pod) error +} + +// patternWhitelist takes a list of sysctls or sysctl patterns (ending in *) and +// checks validity via a sysctl and prefix map, rejecting those which are not known +// to be namespaced. +type patternWhitelist struct { + sysctls map[string]Namespace + prefixes map[string]Namespace + annotationKey string +} + +var _ lifecycle.PodAdmitHandler = &patternWhitelist{} + +// NewWhitelist creates a new Whitelist from a list of sysctls and sysctl pattern (ending in *). +func NewWhitelist(patterns []string, annotationKey string) (*patternWhitelist, error) { + w := &patternWhitelist{ + sysctls: map[string]Namespace{}, + prefixes: map[string]Namespace{}, + annotationKey: annotationKey, + } + + for _, s := range patterns { + if !extvalidation.IsValidSysctlPattern(s) { + return nil, fmt.Errorf("sysctl %q must have at most %d characters and match regex %s", + s, + validation.SysctlMaxLength, + extvalidation.SysctlPatternFmt, + ) + } + if strings.HasSuffix(s, "*") { + prefix := s[:len(s)-1] + ns := NamespacedBy(prefix) + if ns == UnknownNamespace { + return nil, fmt.Errorf("the sysctls %q are not known to be namespaced", s) + } + w.prefixes[prefix] = ns + } else { + ns := NamespacedBy(s) + if ns == UnknownNamespace { + return nil, fmt.Errorf("the sysctl %q are not known to be namespaced", s) + } + w.sysctls[s] = ns + } + } + return w, nil +} + +// validateSysctl checks that a sysctl is whitelisted because it is known +// to be namespaced by the Linux kernel. Note that being whitelisted is required, but not +// sufficient: the container runtime might have a stricter check and refuse to launch a pod. +// +// The parameters hostNet and hostIPC are used to forbid sysctls for pod sharing the +// respective namespaces with the host. This check is only possible for sysctls on +// the static default whitelist, not those on the custom whitelist provided by the admin. +func (w *patternWhitelist) validateSysctl(sysctl string, hostNet, hostIPC bool) error { + nsErrorFmt := "%q not allowed with host %s enabled" + if ns, found := w.sysctls[sysctl]; found { + if ns == IpcNamespace && hostIPC { + return fmt.Errorf(nsErrorFmt, sysctl, ns) + } + if ns == NetNamespace && hostNet { + return fmt.Errorf(nsErrorFmt, sysctl, ns) + } + return nil + } + for p, ns := range w.prefixes { + if strings.HasPrefix(sysctl, p) { + if ns == IpcNamespace && hostIPC { + return fmt.Errorf(nsErrorFmt, sysctl, ns) + } + if ns == NetNamespace && hostNet { + return fmt.Errorf(nsErrorFmt, sysctl, ns) + } + return nil + } + } + return fmt.Errorf("%q not whitelisted", sysctl) +} + +// Admit checks that all sysctls given in a api.SysctlsPodAnnotationKey annotation +// are valid according to the whitelist. +func (w *patternWhitelist) Admit(attrs *lifecycle.PodAdmitAttributes) lifecycle.PodAdmitResult { + pod := attrs.Pod + a := pod.Annotations[w.annotationKey] + if a == "" { + return lifecycle.PodAdmitResult{ + Admit: true, + } + } + + sysctls, err := api.SysctlsFromPodAnnotation(a) + if err != nil { + return lifecycle.PodAdmitResult{ + Admit: false, + Reason: AnnotationInvalidReason, + Message: fmt.Sprintf("invalid %s annotation: %v", w.annotationKey, err), + } + } + + var hostNet, hostIPC bool + if pod.Spec.SecurityContext != nil { + hostNet = pod.Spec.SecurityContext.HostNetwork + hostIPC = pod.Spec.SecurityContext.HostIPC + } + for _, s := range sysctls { + if err := w.validateSysctl(s.Name, hostNet, hostIPC); err != nil { + return lifecycle.PodAdmitResult{ + Admit: false, + Reason: ForbiddenReason, + Message: fmt.Sprintf("forbidden sysctl: %v", err), + } + } + } + + return lifecycle.PodAdmitResult{ + Admit: true, + } +} diff --git a/pkg/kubelet/sysctl/whitelist_test.go b/pkg/kubelet/sysctl/whitelist_test.go new file mode 100644 index 00000000000..27d3728e099 --- /dev/null +++ b/pkg/kubelet/sysctl/whitelist_test.go @@ -0,0 +1,84 @@ +/* +Copyright 2016 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. +*/ + +package sysctl + +import ( + "testing" + + "k8s.io/kubernetes/pkg/api" +) + +func TestNewWhitelist(t *testing.T) { + type Test struct { + sysctls []string + err bool + } + for _, test := range []Test{ + {sysctls: []string{"kernel.msg*", "kernel.sem"}}, + {sysctls: []string{" kernel.msg*"}, err: true}, + {sysctls: []string{"kernel.msg* "}, err: true}, + {sysctls: []string{"net.-"}, err: true}, + {sysctls: []string{"net.*.foo"}, err: true}, + {sysctls: []string{"foo"}, err: true}, + } { + _, err := NewWhitelist(append(SafeSysctlWhitelist(), test.sysctls...), api.SysctlsPodAnnotationKey) + if test.err && err == nil { + t.Errorf("expected an error creating a whitelist for %v", test.sysctls) + } else if !test.err && err != nil { + t.Errorf("got unexpected error creating a whitelist for %v: %v", test.sysctls, err) + } + } +} + +func TestWhitelist(t *testing.T) { + type Test struct { + sysctl string + hostNet, hostIPC bool + } + valid := []Test{ + {sysctl: "kernel.shm_rmid_forced"}, + {sysctl: "net.ipv4.ip_local_port_range"}, + {sysctl: "kernel.msgmax"}, + {sysctl: "kernel.sem"}, + } + invalid := []Test{ + {sysctl: "kernel.shm_rmid_forced", hostIPC: true}, + {sysctl: "net.ipv4.ip_local_port_range", hostNet: true}, + {sysctl: "foo"}, + {sysctl: "net.a.b.c", hostNet: false}, + {sysctl: "net.ipv4.ip_local_port_range.a.b.c", hostNet: false}, + {sysctl: "kernel.msgmax", hostIPC: true}, + {sysctl: "kernel.sem", hostIPC: true}, + } + + w, err := NewWhitelist(append(SafeSysctlWhitelist(), "kernel.msg*", "kernel.sem"), api.SysctlsPodAnnotationKey) + if err != nil { + t.Fatalf("failed to create whitelist: %v", err) + } + + for _, test := range valid { + if err := w.validateSysctl(test.sysctl, test.hostNet, test.hostIPC); err != nil { + t.Errorf("expected to be whitelisted: %+v, got: %v", test, err) + } + } + + for _, test := range invalid { + if err := w.validateSysctl(test.sysctl, test.hostNet, test.hostIPC); err == nil { + t.Errorf("expected to be rejected: %+v", test) + } + } +} From dd7826359c1d958af3d5d323e44b42bfbfdda26f Mon Sep 17 00:00:00 2001 From: "Dr. Stefan Schimanski" Date: Fri, 19 Aug 2016 10:33:50 +0200 Subject: [PATCH 4/5] Add sysctl e2e tests --- test/e2e/common/sysctl.go | 234 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) create mode 100644 test/e2e/common/sysctl.go diff --git a/test/e2e/common/sysctl.go b/test/e2e/common/sysctl.go new file mode 100644 index 00000000000..11ea9872e65 --- /dev/null +++ b/test/e2e/common/sysctl.go @@ -0,0 +1,234 @@ +/* +Copyright 2014 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. +*/ + +package common + +import ( + "fmt" + + "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/kubelet/events" + "k8s.io/kubernetes/pkg/kubelet/sysctl" + "k8s.io/kubernetes/pkg/util/uuid" + "k8s.io/kubernetes/pkg/util/wait" + "k8s.io/kubernetes/test/e2e/framework" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = framework.KubeDescribe("Sysctls", func() { + f := framework.NewDefaultFramework("sysctl") + var podClient *framework.PodClient + + testPod := func() *api.Pod { + podName := "sysctl-" + string(uuid.NewUUID()) + pod := api.Pod{ + ObjectMeta: api.ObjectMeta{ + Name: podName, + Annotations: map[string]string{}, + }, + Spec: api.PodSpec{ + Containers: []api.Container{ + { + Name: "test-container", + Image: "gcr.io/google_containers/busybox:1.24", + }, + }, + RestartPolicy: api.RestartPolicyNever, + }, + } + + return &pod + } + + waitForPodErrorEventOrStarted := func(pod *api.Pod) (*api.Event, error) { + var ev *api.Event + err := wait.Poll(framework.Poll, framework.PodStartTimeout, func() (bool, error) { + evnts, err := f.Client.Events(pod.Namespace).Search(pod) + if err != nil { + return false, fmt.Errorf("error in listing events: %s", err) + } + for _, e := range evnts.Items { + switch e.Reason { + case sysctl.UnsupportedReason, sysctl.ForbiddenReason: + ev = &e + return true, nil + case events.StartedContainer: + return true, nil + } + } + return false, nil + }) + return ev, err + } + + BeforeEach(func() { + podClient = f.PodClient() + }) + + It("should support sysctls", func() { + pod := testPod() + pod.Annotations[api.SysctlsPodAnnotationKey] = api.PodAnnotationsFromSysctls([]api.Sysctl{ + { + Name: "kernel.shm_rmid_forced", + Value: "1", + }, + }) + pod.Spec.Containers[0].Command = []string{"/bin/sysctl", "kernel.shm_rmid_forced"} + + By("Creating a pod with the kernel.shm_rmid_forced sysctl") + pod = podClient.Create(pod) + + By("Watching for error events or started pod") + // watch for events instead of termination of pod because the kubelet deletes + // failed pods without running containers. This would create a race as the pod + // might have already been deleted here. + ev, err := waitForPodErrorEventOrStarted(pod) + Expect(err).NotTo(HaveOccurred()) + if ev != nil && ev.Reason == sysctl.UnsupportedReason { + framework.Skipf("No sysctl support in Docker <1.12") + } + Expect(ev).To(BeNil()) + + By("Waiting for pod completion") + err = f.WaitForPodNoLongerRunning(pod.Name) + Expect(err).NotTo(HaveOccurred()) + pod, err = podClient.Get(pod.Name) + Expect(err).NotTo(HaveOccurred()) + + By("Checking that the pod succeeded") + Expect(pod.Status.Phase).To(Equal(api.PodSucceeded)) + + By("Getting logs from the pod") + log, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name) + Expect(err).NotTo(HaveOccurred()) + + By("Checking that the sysctl is actually updated") + Expect(log).To(ContainSubstring("kernel.shm_rmid_forced = 1")) + }) + + It("should support unsafe sysctls which are actually whitelisted", func() { + pod := testPod() + pod.Annotations[api.UnsafeSysctlsPodAnnotationKey] = api.PodAnnotationsFromSysctls([]api.Sysctl{ + { + Name: "kernel.shm_rmid_forced", + Value: "1", + }, + }) + pod.Spec.Containers[0].Command = []string{"/bin/sysctl", "kernel.shm_rmid_forced"} + + By("Creating a pod with the kernel.shm_rmid_forced sysctl") + pod = podClient.Create(pod) + + By("Watching for error events or started pod") + // watch for events instead of termination of pod because the kubelet deletes + // failed pods without running containers. This would create a race as the pod + // might have already been deleted here. + ev, err := waitForPodErrorEventOrStarted(pod) + Expect(err).NotTo(HaveOccurred()) + if ev != nil && ev.Reason == sysctl.UnsupportedReason { + framework.Skipf("No sysctl support in Docker <1.12") + } + Expect(ev).To(BeNil()) + + By("Waiting for pod completion") + err = f.WaitForPodNoLongerRunning(pod.Name) + Expect(err).NotTo(HaveOccurred()) + pod, err = podClient.Get(pod.Name) + Expect(err).NotTo(HaveOccurred()) + + By("Checking that the pod succeeded") + Expect(pod.Status.Phase).To(Equal(api.PodSucceeded)) + + By("Getting logs from the pod") + log, err := framework.GetPodLogs(f.Client, f.Namespace.Name, pod.Name, pod.Spec.Containers[0].Name) + Expect(err).NotTo(HaveOccurred()) + + By("Checking that the sysctl is actually updated") + Expect(log).To(ContainSubstring("kernel.shm_rmid_forced = 1")) + }) + + It("should reject invalid sysctls", func() { + pod := testPod() + pod.Annotations[api.SysctlsPodAnnotationKey] = api.PodAnnotationsFromSysctls([]api.Sysctl{ + { + Name: "foo-", + Value: "bar", + }, + { + Name: "kernel.shmmax", + Value: "100000000", + }, + { + Name: "safe-and-unsafe", + Value: "100000000", + }, + }) + pod.Annotations[api.UnsafeSysctlsPodAnnotationKey] = api.PodAnnotationsFromSysctls([]api.Sysctl{ + { + Name: "kernel.shmall", + Value: "100000000", + }, + { + Name: "bar..", + Value: "42", + }, + { + Name: "safe-and-unsafe", + Value: "100000000", + }, + }) + + By("Creating a pod with one valid and two invalid sysctls") + client := f.Client.Pods(f.Namespace.Name) + _, err := client.Create(pod) + defer client.Delete(pod.Name, nil) + + Expect(err).NotTo(BeNil()) + Expect(err.Error()).To(ContainSubstring(`Invalid value: "foo-"`)) + Expect(err.Error()).To(ContainSubstring(`Invalid value: "bar.."`)) + Expect(err.Error()).To(ContainSubstring(`safe-and-unsafe`)) + Expect(err.Error()).NotTo(ContainSubstring("kernel.shmmax")) + }) + + It("should not launch unsafe, but not explicitly enabled sysctls on the node", func() { + pod := testPod() + pod.Annotations[api.SysctlsPodAnnotationKey] = api.PodAnnotationsFromSysctls([]api.Sysctl{ + { + Name: "kernel.msgmax", + Value: "10000000000", + }, + }) + + By("Creating a pod with a greylisted, but not whitelisted sysctl on the node") + pod = podClient.Create(pod) + + By("Watching for error events or started pod") + // watch for events instead of termination of pod because the kubelet deletes + // failed pods without running containers. This would create a race as the pod + // might have already been deleted here. + ev, err := waitForPodErrorEventOrStarted(pod) + Expect(err).NotTo(HaveOccurred()) + if ev != nil && ev.Reason == sysctl.UnsupportedReason { + framework.Skipf("No sysctl support in Docker <1.12") + } + + By("Checking that the pod was rejected") + Expect(ev).ToNot(BeNil()) + Expect(ev.Reason).To(Equal("SysctlForbidden")) + }) +}) From 03d7e33034af425e4ea7da76641d6451abfd501e Mon Sep 17 00:00:00 2001 From: "Dr. Stefan Schimanski" Date: Thu, 25 Aug 2016 11:17:52 +0200 Subject: [PATCH 5/5] Run hack/update-all.sh --- pkg/api/types.generated.go | 27751 ++++++++-------- pkg/api/zz_generated.deepcopy.go | 11 + pkg/apis/componentconfig/types.generated.go | 4994 +-- .../v1alpha1/zz_generated.conversion.go | 2 + .../v1alpha1/zz_generated.deepcopy.go | 7 + .../componentconfig/zz_generated.deepcopy.go | 7 + 6 files changed, 16535 insertions(+), 16237 deletions(-) diff --git a/pkg/api/types.generated.go b/pkg/api/types.generated.go index 6d56a80d902..727adf86dde 100644 --- a/pkg/api/types.generated.go +++ b/pkg/api/types.generated.go @@ -28780,7 +28780,7 @@ func (x *PodSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } -func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { +func (x *Sysctl) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -28794,22 +28794,14 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { } else { yysep2151 := !z.EncBinary() yy2arr2151 := z.EncBasicHandle().StructToArray - var yyq2151 [8]bool + var yyq2151 [2]bool _, _, _ = yysep2151, yyq2151, yy2arr2151 const yyr2151 bool = false - yyq2151[0] = x.HostNetwork != false - yyq2151[1] = x.HostPID != false - yyq2151[2] = x.HostIPC != false - yyq2151[3] = x.SELinuxOptions != nil - yyq2151[4] = x.RunAsUser != nil - yyq2151[5] = x.RunAsNonRoot != nil - yyq2151[6] = len(x.SupplementalGroups) != 0 - yyq2151[7] = x.FSGroup != nil var yynn2151 int if yyr2151 || yy2arr2151 { - r.EncodeArrayStart(8) + r.EncodeArrayStart(2) } else { - yynn2151 = 0 + yynn2151 = 2 for _, b := range yyq2151 { if b { yynn2151++ @@ -28820,9 +28812,220 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { } if yyr2151 || yy2arr2151 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[0] { - yym2153 := z.EncBinary() - _ = yym2153 + yym2153 := z.EncBinary() + _ = yym2153 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Name)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("name")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym2154 := z.EncBinary() + _ = yym2154 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Name)) + } + } + if yyr2151 || yy2arr2151 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym2156 := z.EncBinary() + _ = yym2156 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Value)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("value")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym2157 := z.EncBinary() + _ = yym2157 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Value)) + } + } + if yyr2151 || yy2arr2151 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *Sysctl) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym2158 := z.DecBinary() + _ = yym2158 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2159 := r.ContainerType() + if yyct2159 == codecSelferValueTypeMap1234 { + yyl2159 := r.ReadMapStart() + if yyl2159 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl2159, d) + } + } else if yyct2159 == codecSelferValueTypeArray1234 { + yyl2159 := r.ReadArrayStart() + if yyl2159 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl2159, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *Sysctl) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys2160Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2160Slc + var yyhl2160 bool = l >= 0 + for yyj2160 := 0; ; yyj2160++ { + if yyhl2160 { + if yyj2160 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys2160Slc = r.DecodeBytes(yys2160Slc, true, true) + yys2160 := string(yys2160Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys2160 { + case "name": + if r.TryDecodeAsNil() { + x.Name = "" + } else { + x.Name = string(r.DecodeString()) + } + case "value": + if r.TryDecodeAsNil() { + x.Value = "" + } else { + x.Value = string(r.DecodeString()) + } + default: + z.DecStructFieldNotFound(-1, yys2160) + } // end switch yys2160 + } // end for yyj2160 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *Sysctl) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj2163 int + var yyb2163 bool + var yyhl2163 bool = l >= 0 + yyj2163++ + if yyhl2163 { + yyb2163 = yyj2163 > l + } else { + yyb2163 = r.CheckBreak() + } + if yyb2163 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Name = "" + } else { + x.Name = string(r.DecodeString()) + } + yyj2163++ + if yyhl2163 { + yyb2163 = yyj2163 > l + } else { + yyb2163 = r.CheckBreak() + } + if yyb2163 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Value = "" + } else { + x.Value = string(r.DecodeString()) + } + for { + yyj2163++ + if yyhl2163 { + yyb2163 = yyj2163 > l + } else { + yyb2163 = r.CheckBreak() + } + if yyb2163 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj2163-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym2166 := z.EncBinary() + _ = yym2166 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2167 := !z.EncBinary() + yy2arr2167 := z.EncBasicHandle().StructToArray + var yyq2167 [8]bool + _, _, _ = yysep2167, yyq2167, yy2arr2167 + const yyr2167 bool = false + yyq2167[0] = x.HostNetwork != false + yyq2167[1] = x.HostPID != false + yyq2167[2] = x.HostIPC != false + yyq2167[3] = x.SELinuxOptions != nil + yyq2167[4] = x.RunAsUser != nil + yyq2167[5] = x.RunAsNonRoot != nil + yyq2167[6] = len(x.SupplementalGroups) != 0 + yyq2167[7] = x.FSGroup != nil + var yynn2167 int + if yyr2167 || yy2arr2167 { + r.EncodeArrayStart(8) + } else { + yynn2167 = 0 + for _, b := range yyq2167 { + if b { + yynn2167++ + } + } + r.EncodeMapStart(yynn2167) + yynn2167 = 0 + } + if yyr2167 || yy2arr2167 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2167[0] { + yym2169 := z.EncBinary() + _ = yym2169 if false { } else { r.EncodeBool(bool(x.HostNetwork)) @@ -28831,23 +29034,23 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeBool(false) } } else { - if yyq2151[0] { + if yyq2167[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("hostNetwork")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2154 := z.EncBinary() - _ = yym2154 + yym2170 := z.EncBinary() + _ = yym2170 if false { } else { r.EncodeBool(bool(x.HostNetwork)) } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[1] { - yym2156 := z.EncBinary() - _ = yym2156 + if yyq2167[1] { + yym2172 := z.EncBinary() + _ = yym2172 if false { } else { r.EncodeBool(bool(x.HostPID)) @@ -28856,23 +29059,23 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeBool(false) } } else { - if yyq2151[1] { + if yyq2167[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("hostPID")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2157 := z.EncBinary() - _ = yym2157 + yym2173 := z.EncBinary() + _ = yym2173 if false { } else { r.EncodeBool(bool(x.HostPID)) } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[2] { - yym2159 := z.EncBinary() - _ = yym2159 + if yyq2167[2] { + yym2175 := z.EncBinary() + _ = yym2175 if false { } else { r.EncodeBool(bool(x.HostIPC)) @@ -28881,21 +29084,21 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeBool(false) } } else { - if yyq2151[2] { + if yyq2167[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("hostIPC")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2160 := z.EncBinary() - _ = yym2160 + yym2176 := z.EncBinary() + _ = yym2176 if false { } else { r.EncodeBool(bool(x.HostIPC)) } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[3] { + if yyq2167[3] { if x.SELinuxOptions == nil { r.EncodeNil() } else { @@ -28905,7 +29108,7 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2151[3] { + if yyq2167[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -28916,84 +29119,84 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[4] { + if yyq2167[4] { if x.RunAsUser == nil { r.EncodeNil() } else { - yy2163 := *x.RunAsUser - yym2164 := z.EncBinary() - _ = yym2164 + yy2179 := *x.RunAsUser + yym2180 := z.EncBinary() + _ = yym2180 if false { } else { - r.EncodeInt(int64(yy2163)) + r.EncodeInt(int64(yy2179)) } } } else { r.EncodeNil() } } else { - if yyq2151[4] { + if yyq2167[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("runAsUser")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.RunAsUser == nil { r.EncodeNil() } else { - yy2165 := *x.RunAsUser - yym2166 := z.EncBinary() - _ = yym2166 + yy2181 := *x.RunAsUser + yym2182 := z.EncBinary() + _ = yym2182 if false { } else { - r.EncodeInt(int64(yy2165)) + r.EncodeInt(int64(yy2181)) } } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[5] { + if yyq2167[5] { if x.RunAsNonRoot == nil { r.EncodeNil() } else { - yy2168 := *x.RunAsNonRoot - yym2169 := z.EncBinary() - _ = yym2169 + yy2184 := *x.RunAsNonRoot + yym2185 := z.EncBinary() + _ = yym2185 if false { } else { - r.EncodeBool(bool(yy2168)) + r.EncodeBool(bool(yy2184)) } } } else { r.EncodeNil() } } else { - if yyq2151[5] { + if yyq2167[5] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("runAsNonRoot")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.RunAsNonRoot == nil { r.EncodeNil() } else { - yy2170 := *x.RunAsNonRoot - yym2171 := z.EncBinary() - _ = yym2171 + yy2186 := *x.RunAsNonRoot + yym2187 := z.EncBinary() + _ = yym2187 if false { } else { - r.EncodeBool(bool(yy2170)) + r.EncodeBool(bool(yy2186)) } } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[6] { + if yyq2167[6] { if x.SupplementalGroups == nil { r.EncodeNil() } else { - yym2173 := z.EncBinary() - _ = yym2173 + yym2189 := z.EncBinary() + _ = yym2189 if false { } else { z.F.EncSliceInt64V(x.SupplementalGroups, false, e) @@ -29003,15 +29206,15 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2151[6] { + if yyq2167[6] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("supplementalGroups")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.SupplementalGroups == nil { r.EncodeNil() } else { - yym2174 := z.EncBinary() - _ = yym2174 + yym2190 := z.EncBinary() + _ = yym2190 if false { } else { z.F.EncSliceInt64V(x.SupplementalGroups, false, e) @@ -29019,42 +29222,42 @@ func (x *PodSecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2151[7] { + if yyq2167[7] { if x.FSGroup == nil { r.EncodeNil() } else { - yy2176 := *x.FSGroup - yym2177 := z.EncBinary() - _ = yym2177 + yy2192 := *x.FSGroup + yym2193 := z.EncBinary() + _ = yym2193 if false { } else { - r.EncodeInt(int64(yy2176)) + r.EncodeInt(int64(yy2192)) } } } else { r.EncodeNil() } } else { - if yyq2151[7] { + if yyq2167[7] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("fsGroup")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.FSGroup == nil { r.EncodeNil() } else { - yy2178 := *x.FSGroup - yym2179 := z.EncBinary() - _ = yym2179 + yy2194 := *x.FSGroup + yym2195 := z.EncBinary() + _ = yym2195 if false { } else { - r.EncodeInt(int64(yy2178)) + r.EncodeInt(int64(yy2194)) } } } } - if yyr2151 || yy2arr2151 { + if yyr2167 || yy2arr2167 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -29067,25 +29270,25 @@ func (x *PodSecurityContext) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2180 := z.DecBinary() - _ = yym2180 + yym2196 := z.DecBinary() + _ = yym2196 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2181 := r.ContainerType() - if yyct2181 == codecSelferValueTypeMap1234 { - yyl2181 := r.ReadMapStart() - if yyl2181 == 0 { + yyct2197 := r.ContainerType() + if yyct2197 == codecSelferValueTypeMap1234 { + yyl2197 := r.ReadMapStart() + if yyl2197 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2181, d) + x.codecDecodeSelfFromMap(yyl2197, d) } - } else if yyct2181 == codecSelferValueTypeArray1234 { - yyl2181 := r.ReadArrayStart() - if yyl2181 == 0 { + } else if yyct2197 == codecSelferValueTypeArray1234 { + yyl2197 := r.ReadArrayStart() + if yyl2197 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2181, d) + x.codecDecodeSelfFromArray(yyl2197, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -29097,12 +29300,12 @@ func (x *PodSecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2182Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2182Slc - var yyhl2182 bool = l >= 0 - for yyj2182 := 0; ; yyj2182++ { - if yyhl2182 { - if yyj2182 >= l { + var yys2198Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2198Slc + var yyhl2198 bool = l >= 0 + for yyj2198 := 0; ; yyj2198++ { + if yyhl2198 { + if yyj2198 >= l { break } } else { @@ -29111,10 +29314,10 @@ func (x *PodSecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2182Slc = r.DecodeBytes(yys2182Slc, true, true) - yys2182 := string(yys2182Slc) + yys2198Slc = r.DecodeBytes(yys2198Slc, true, true) + yys2198 := string(yys2198Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2182 { + switch yys2198 { case "hostNetwork": if r.TryDecodeAsNil() { x.HostNetwork = false @@ -29153,8 +29356,8 @@ func (x *PodSecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) if x.RunAsUser == nil { x.RunAsUser = new(int64) } - yym2188 := z.DecBinary() - _ = yym2188 + yym2204 := z.DecBinary() + _ = yym2204 if false { } else { *((*int64)(x.RunAsUser)) = int64(r.DecodeInt(64)) @@ -29169,8 +29372,8 @@ func (x *PodSecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) if x.RunAsNonRoot == nil { x.RunAsNonRoot = new(bool) } - yym2190 := z.DecBinary() - _ = yym2190 + yym2206 := z.DecBinary() + _ = yym2206 if false { } else { *((*bool)(x.RunAsNonRoot)) = r.DecodeBool() @@ -29180,12 +29383,12 @@ func (x *PodSecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.SupplementalGroups = nil } else { - yyv2191 := &x.SupplementalGroups - yym2192 := z.DecBinary() - _ = yym2192 + yyv2207 := &x.SupplementalGroups + yym2208 := z.DecBinary() + _ = yym2208 if false { } else { - z.F.DecSliceInt64X(yyv2191, false, d) + z.F.DecSliceInt64X(yyv2207, false, d) } } case "fsGroup": @@ -29197,17 +29400,17 @@ func (x *PodSecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) if x.FSGroup == nil { x.FSGroup = new(int64) } - yym2194 := z.DecBinary() - _ = yym2194 + yym2210 := z.DecBinary() + _ = yym2210 if false { } else { *((*int64)(x.FSGroup)) = int64(r.DecodeInt(64)) } } default: - z.DecStructFieldNotFound(-1, yys2182) - } // end switch yys2182 - } // end for yyj2182 + z.DecStructFieldNotFound(-1, yys2198) + } // end switch yys2198 + } // end for yyj2198 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -29215,16 +29418,16 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2195 int - var yyb2195 bool - var yyhl2195 bool = l >= 0 - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + var yyj2211 int + var yyb2211 bool + var yyhl2211 bool = l >= 0 + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29234,13 +29437,13 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.HostNetwork = bool(r.DecodeBool()) } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29250,13 +29453,13 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.HostPID = bool(r.DecodeBool()) } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29266,13 +29469,13 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.HostIPC = bool(r.DecodeBool()) } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29287,13 +29490,13 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode } x.SELinuxOptions.CodecDecodeSelf(d) } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29306,20 +29509,20 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode if x.RunAsUser == nil { x.RunAsUser = new(int64) } - yym2201 := z.DecBinary() - _ = yym2201 + yym2217 := z.DecBinary() + _ = yym2217 if false { } else { *((*int64)(x.RunAsUser)) = int64(r.DecodeInt(64)) } } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29332,20 +29535,20 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode if x.RunAsNonRoot == nil { x.RunAsNonRoot = new(bool) } - yym2203 := z.DecBinary() - _ = yym2203 + yym2219 := z.DecBinary() + _ = yym2219 if false { } else { *((*bool)(x.RunAsNonRoot)) = r.DecodeBool() } } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29353,21 +29556,21 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.SupplementalGroups = nil } else { - yyv2204 := &x.SupplementalGroups - yym2205 := z.DecBinary() - _ = yym2205 + yyv2220 := &x.SupplementalGroups + yym2221 := z.DecBinary() + _ = yym2221 if false { } else { - z.F.DecSliceInt64X(yyv2204, false, d) + z.F.DecSliceInt64X(yyv2220, false, d) } } - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29380,25 +29583,25 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode if x.FSGroup == nil { x.FSGroup = new(int64) } - yym2207 := z.DecBinary() - _ = yym2207 + yym2223 := z.DecBinary() + _ = yym2223 if false { } else { *((*int64)(x.FSGroup)) = int64(r.DecodeInt(64)) } } for { - yyj2195++ - if yyhl2195 { - yyb2195 = yyj2195 > l + yyj2211++ + if yyhl2211 { + yyb2211 = yyj2211 > l } else { - yyb2195 = r.CheckBreak() + yyb2211 = r.CheckBreak() } - if yyb2195 { + if yyb2211 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2195-1, "") + z.DecStructFieldNotFound(yyj2211-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -29410,60 +29613,60 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2208 := z.EncBinary() - _ = yym2208 + yym2224 := z.EncBinary() + _ = yym2224 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2209 := !z.EncBinary() - yy2arr2209 := z.EncBasicHandle().StructToArray - var yyq2209 [8]bool - _, _, _ = yysep2209, yyq2209, yy2arr2209 - const yyr2209 bool = false - yyq2209[0] = x.Phase != "" - yyq2209[1] = len(x.Conditions) != 0 - yyq2209[2] = x.Message != "" - yyq2209[3] = x.Reason != "" - yyq2209[4] = x.HostIP != "" - yyq2209[5] = x.PodIP != "" - yyq2209[6] = x.StartTime != nil - yyq2209[7] = len(x.ContainerStatuses) != 0 - var yynn2209 int - if yyr2209 || yy2arr2209 { + yysep2225 := !z.EncBinary() + yy2arr2225 := z.EncBasicHandle().StructToArray + var yyq2225 [8]bool + _, _, _ = yysep2225, yyq2225, yy2arr2225 + const yyr2225 bool = false + yyq2225[0] = x.Phase != "" + yyq2225[1] = len(x.Conditions) != 0 + yyq2225[2] = x.Message != "" + yyq2225[3] = x.Reason != "" + yyq2225[4] = x.HostIP != "" + yyq2225[5] = x.PodIP != "" + yyq2225[6] = x.StartTime != nil + yyq2225[7] = len(x.ContainerStatuses) != 0 + var yynn2225 int + if yyr2225 || yy2arr2225 { r.EncodeArrayStart(8) } else { - yynn2209 = 0 - for _, b := range yyq2209 { + yynn2225 = 0 + for _, b := range yyq2225 { if b { - yynn2209++ + yynn2225++ } } - r.EncodeMapStart(yynn2209) - yynn2209 = 0 + r.EncodeMapStart(yynn2225) + yynn2225 = 0 } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[0] { + if yyq2225[0] { x.Phase.CodecEncodeSelf(e) } else { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2209[0] { + if yyq2225[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("phase")) z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Phase.CodecEncodeSelf(e) } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[1] { + if yyq2225[1] { if x.Conditions == nil { r.EncodeNil() } else { - yym2212 := z.EncBinary() - _ = yym2212 + yym2228 := z.EncBinary() + _ = yym2228 if false { } else { h.encSlicePodCondition(([]PodCondition)(x.Conditions), e) @@ -29473,15 +29676,15 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2209[1] { + if yyq2225[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("conditions")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.Conditions == nil { r.EncodeNil() } else { - yym2213 := z.EncBinary() - _ = yym2213 + yym2229 := z.EncBinary() + _ = yym2229 if false { } else { h.encSlicePodCondition(([]PodCondition)(x.Conditions), e) @@ -29489,11 +29692,11 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[2] { - yym2215 := z.EncBinary() - _ = yym2215 + if yyq2225[2] { + yym2231 := z.EncBinary() + _ = yym2231 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) @@ -29502,23 +29705,23 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2209[2] { + if yyq2225[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("message")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2216 := z.EncBinary() - _ = yym2216 + yym2232 := z.EncBinary() + _ = yym2232 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[3] { - yym2218 := z.EncBinary() - _ = yym2218 + if yyq2225[3] { + yym2234 := z.EncBinary() + _ = yym2234 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) @@ -29527,23 +29730,23 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2209[3] { + if yyq2225[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("reason")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2219 := z.EncBinary() - _ = yym2219 + yym2235 := z.EncBinary() + _ = yym2235 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[4] { - yym2221 := z.EncBinary() - _ = yym2221 + if yyq2225[4] { + yym2237 := z.EncBinary() + _ = yym2237 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.HostIP)) @@ -29552,23 +29755,23 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2209[4] { + if yyq2225[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("hostIP")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2222 := z.EncBinary() - _ = yym2222 + yym2238 := z.EncBinary() + _ = yym2238 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.HostIP)) } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[5] { - yym2224 := z.EncBinary() - _ = yym2224 + if yyq2225[5] { + yym2240 := z.EncBinary() + _ = yym2240 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodIP)) @@ -29577,31 +29780,31 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2209[5] { + if yyq2225[5] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("podIP")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2225 := z.EncBinary() - _ = yym2225 + yym2241 := z.EncBinary() + _ = yym2241 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodIP)) } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[6] { + if yyq2225[6] { if x.StartTime == nil { r.EncodeNil() } else { - yym2227 := z.EncBinary() - _ = yym2227 + yym2243 := z.EncBinary() + _ = yym2243 if false { } else if z.HasExtensions() && z.EncExt(x.StartTime) { - } else if yym2227 { + } else if yym2243 { z.EncBinaryMarshal(x.StartTime) - } else if !yym2227 && z.IsJSONHandle() { + } else if !yym2243 && z.IsJSONHandle() { z.EncJSONMarshal(x.StartTime) } else { z.EncFallback(x.StartTime) @@ -29611,20 +29814,20 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2209[6] { + if yyq2225[6] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("startTime")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.StartTime == nil { r.EncodeNil() } else { - yym2228 := z.EncBinary() - _ = yym2228 + yym2244 := z.EncBinary() + _ = yym2244 if false { } else if z.HasExtensions() && z.EncExt(x.StartTime) { - } else if yym2228 { + } else if yym2244 { z.EncBinaryMarshal(x.StartTime) - } else if !yym2228 && z.IsJSONHandle() { + } else if !yym2244 && z.IsJSONHandle() { z.EncJSONMarshal(x.StartTime) } else { z.EncFallback(x.StartTime) @@ -29632,14 +29835,14 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2209[7] { + if yyq2225[7] { if x.ContainerStatuses == nil { r.EncodeNil() } else { - yym2230 := z.EncBinary() - _ = yym2230 + yym2246 := z.EncBinary() + _ = yym2246 if false { } else { h.encSliceContainerStatus(([]ContainerStatus)(x.ContainerStatuses), e) @@ -29649,15 +29852,15 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2209[7] { + if yyq2225[7] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("containerStatuses")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.ContainerStatuses == nil { r.EncodeNil() } else { - yym2231 := z.EncBinary() - _ = yym2231 + yym2247 := z.EncBinary() + _ = yym2247 if false { } else { h.encSliceContainerStatus(([]ContainerStatus)(x.ContainerStatuses), e) @@ -29665,7 +29868,7 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2209 || yy2arr2209 { + if yyr2225 || yy2arr2225 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -29678,25 +29881,25 @@ func (x *PodStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2232 := z.DecBinary() - _ = yym2232 + yym2248 := z.DecBinary() + _ = yym2248 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2233 := r.ContainerType() - if yyct2233 == codecSelferValueTypeMap1234 { - yyl2233 := r.ReadMapStart() - if yyl2233 == 0 { + yyct2249 := r.ContainerType() + if yyct2249 == codecSelferValueTypeMap1234 { + yyl2249 := r.ReadMapStart() + if yyl2249 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2233, d) + x.codecDecodeSelfFromMap(yyl2249, d) } - } else if yyct2233 == codecSelferValueTypeArray1234 { - yyl2233 := r.ReadArrayStart() - if yyl2233 == 0 { + } else if yyct2249 == codecSelferValueTypeArray1234 { + yyl2249 := r.ReadArrayStart() + if yyl2249 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2233, d) + x.codecDecodeSelfFromArray(yyl2249, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -29708,12 +29911,12 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2234Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2234Slc - var yyhl2234 bool = l >= 0 - for yyj2234 := 0; ; yyj2234++ { - if yyhl2234 { - if yyj2234 >= l { + var yys2250Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2250Slc + var yyhl2250 bool = l >= 0 + for yyj2250 := 0; ; yyj2250++ { + if yyhl2250 { + if yyj2250 >= l { break } } else { @@ -29722,10 +29925,10 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2234Slc = r.DecodeBytes(yys2234Slc, true, true) - yys2234 := string(yys2234Slc) + yys2250Slc = r.DecodeBytes(yys2250Slc, true, true) + yys2250 := string(yys2250Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2234 { + switch yys2250 { case "phase": if r.TryDecodeAsNil() { x.Phase = "" @@ -29736,12 +29939,12 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Conditions = nil } else { - yyv2236 := &x.Conditions - yym2237 := z.DecBinary() - _ = yym2237 + yyv2252 := &x.Conditions + yym2253 := z.DecBinary() + _ = yym2253 if false { } else { - h.decSlicePodCondition((*[]PodCondition)(yyv2236), d) + h.decSlicePodCondition((*[]PodCondition)(yyv2252), d) } } case "message": @@ -29777,13 +29980,13 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.StartTime == nil { x.StartTime = new(pkg2_unversioned.Time) } - yym2243 := z.DecBinary() - _ = yym2243 + yym2259 := z.DecBinary() + _ = yym2259 if false { } else if z.HasExtensions() && z.DecExt(x.StartTime) { - } else if yym2243 { + } else if yym2259 { z.DecBinaryUnmarshal(x.StartTime) - } else if !yym2243 && z.IsJSONHandle() { + } else if !yym2259 && z.IsJSONHandle() { z.DecJSONUnmarshal(x.StartTime) } else { z.DecFallback(x.StartTime, false) @@ -29793,18 +29996,18 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ContainerStatuses = nil } else { - yyv2244 := &x.ContainerStatuses - yym2245 := z.DecBinary() - _ = yym2245 + yyv2260 := &x.ContainerStatuses + yym2261 := z.DecBinary() + _ = yym2261 if false { } else { - h.decSliceContainerStatus((*[]ContainerStatus)(yyv2244), d) + h.decSliceContainerStatus((*[]ContainerStatus)(yyv2260), d) } } default: - z.DecStructFieldNotFound(-1, yys2234) - } // end switch yys2234 - } // end for yyj2234 + z.DecStructFieldNotFound(-1, yys2250) + } // end switch yys2250 + } // end for yyj2250 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -29812,16 +30015,16 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2246 int - var yyb2246 bool - var yyhl2246 bool = l >= 0 - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + var yyj2262 int + var yyb2262 bool + var yyhl2262 bool = l >= 0 + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29831,13 +30034,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Phase = PodPhase(r.DecodeString()) } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29845,21 +30048,21 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Conditions = nil } else { - yyv2248 := &x.Conditions - yym2249 := z.DecBinary() - _ = yym2249 + yyv2264 := &x.Conditions + yym2265 := z.DecBinary() + _ = yym2265 if false { } else { - h.decSlicePodCondition((*[]PodCondition)(yyv2248), d) + h.decSlicePodCondition((*[]PodCondition)(yyv2264), d) } } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29869,13 +30072,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Message = string(r.DecodeString()) } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29885,13 +30088,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Reason = string(r.DecodeString()) } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29901,13 +30104,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.HostIP = string(r.DecodeString()) } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29917,13 +30120,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.PodIP = string(r.DecodeString()) } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29936,25 +30139,25 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.StartTime == nil { x.StartTime = new(pkg2_unversioned.Time) } - yym2255 := z.DecBinary() - _ = yym2255 + yym2271 := z.DecBinary() + _ = yym2271 if false { } else if z.HasExtensions() && z.DecExt(x.StartTime) { - } else if yym2255 { + } else if yym2271 { z.DecBinaryUnmarshal(x.StartTime) - } else if !yym2255 && z.IsJSONHandle() { + } else if !yym2271 && z.IsJSONHandle() { z.DecJSONUnmarshal(x.StartTime) } else { z.DecFallback(x.StartTime, false) } } - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -29962,26 +30165,26 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ContainerStatuses = nil } else { - yyv2256 := &x.ContainerStatuses - yym2257 := z.DecBinary() - _ = yym2257 + yyv2272 := &x.ContainerStatuses + yym2273 := z.DecBinary() + _ = yym2273 if false { } else { - h.decSliceContainerStatus((*[]ContainerStatus)(yyv2256), d) + h.decSliceContainerStatus((*[]ContainerStatus)(yyv2272), d) } } for { - yyj2246++ - if yyhl2246 { - yyb2246 = yyj2246 > l + yyj2262++ + if yyhl2262 { + yyb2262 = yyj2262 > l } else { - yyb2246 = r.CheckBreak() + yyb2262 = r.CheckBreak() } - if yyb2246 { + if yyb2262 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2246-1, "") + z.DecStructFieldNotFound(yyj2262-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -29993,38 +30196,38 @@ func (x *PodStatusResult) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2258 := z.EncBinary() - _ = yym2258 + yym2274 := z.EncBinary() + _ = yym2274 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2259 := !z.EncBinary() - yy2arr2259 := z.EncBasicHandle().StructToArray - var yyq2259 [4]bool - _, _, _ = yysep2259, yyq2259, yy2arr2259 - const yyr2259 bool = false - yyq2259[0] = x.Kind != "" - yyq2259[1] = x.APIVersion != "" - yyq2259[2] = true - yyq2259[3] = true - var yynn2259 int - if yyr2259 || yy2arr2259 { + yysep2275 := !z.EncBinary() + yy2arr2275 := z.EncBasicHandle().StructToArray + var yyq2275 [4]bool + _, _, _ = yysep2275, yyq2275, yy2arr2275 + const yyr2275 bool = false + yyq2275[0] = x.Kind != "" + yyq2275[1] = x.APIVersion != "" + yyq2275[2] = true + yyq2275[3] = true + var yynn2275 int + if yyr2275 || yy2arr2275 { r.EncodeArrayStart(4) } else { - yynn2259 = 0 - for _, b := range yyq2259 { + yynn2275 = 0 + for _, b := range yyq2275 { if b { - yynn2259++ + yynn2275++ } } - r.EncodeMapStart(yynn2259) - yynn2259 = 0 + r.EncodeMapStart(yynn2275) + yynn2275 = 0 } - if yyr2259 || yy2arr2259 { + if yyr2275 || yy2arr2275 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2259[0] { - yym2261 := z.EncBinary() - _ = yym2261 + if yyq2275[0] { + yym2277 := z.EncBinary() + _ = yym2277 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -30033,23 +30236,23 @@ func (x *PodStatusResult) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2259[0] { + if yyq2275[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2262 := z.EncBinary() - _ = yym2262 + yym2278 := z.EncBinary() + _ = yym2278 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2259 || yy2arr2259 { + if yyr2275 || yy2arr2275 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2259[1] { - yym2264 := z.EncBinary() - _ = yym2264 + if yyq2275[1] { + yym2280 := z.EncBinary() + _ = yym2280 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -30058,53 +30261,53 @@ func (x *PodStatusResult) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2259[1] { + if yyq2275[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2265 := z.EncBinary() - _ = yym2265 + yym2281 := z.EncBinary() + _ = yym2281 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2259 || yy2arr2259 { + if yyr2275 || yy2arr2275 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2259[2] { - yy2267 := &x.ObjectMeta - yy2267.CodecEncodeSelf(e) + if yyq2275[2] { + yy2283 := &x.ObjectMeta + yy2283.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2259[2] { + if yyq2275[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2268 := &x.ObjectMeta - yy2268.CodecEncodeSelf(e) + yy2284 := &x.ObjectMeta + yy2284.CodecEncodeSelf(e) } } - if yyr2259 || yy2arr2259 { + if yyr2275 || yy2arr2275 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2259[3] { - yy2270 := &x.Status - yy2270.CodecEncodeSelf(e) + if yyq2275[3] { + yy2286 := &x.Status + yy2286.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2259[3] { + if yyq2275[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2271 := &x.Status - yy2271.CodecEncodeSelf(e) + yy2287 := &x.Status + yy2287.CodecEncodeSelf(e) } } - if yyr2259 || yy2arr2259 { + if yyr2275 || yy2arr2275 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -30117,25 +30320,25 @@ func (x *PodStatusResult) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2272 := z.DecBinary() - _ = yym2272 + yym2288 := z.DecBinary() + _ = yym2288 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2273 := r.ContainerType() - if yyct2273 == codecSelferValueTypeMap1234 { - yyl2273 := r.ReadMapStart() - if yyl2273 == 0 { + yyct2289 := r.ContainerType() + if yyct2289 == codecSelferValueTypeMap1234 { + yyl2289 := r.ReadMapStart() + if yyl2289 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2273, d) + x.codecDecodeSelfFromMap(yyl2289, d) } - } else if yyct2273 == codecSelferValueTypeArray1234 { - yyl2273 := r.ReadArrayStart() - if yyl2273 == 0 { + } else if yyct2289 == codecSelferValueTypeArray1234 { + yyl2289 := r.ReadArrayStart() + if yyl2289 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2273, d) + x.codecDecodeSelfFromArray(yyl2289, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -30147,12 +30350,12 @@ func (x *PodStatusResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2274Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2274Slc - var yyhl2274 bool = l >= 0 - for yyj2274 := 0; ; yyj2274++ { - if yyhl2274 { - if yyj2274 >= l { + var yys2290Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2290Slc + var yyhl2290 bool = l >= 0 + for yyj2290 := 0; ; yyj2290++ { + if yyhl2290 { + if yyj2290 >= l { break } } else { @@ -30161,10 +30364,10 @@ func (x *PodStatusResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2274Slc = r.DecodeBytes(yys2274Slc, true, true) - yys2274 := string(yys2274Slc) + yys2290Slc = r.DecodeBytes(yys2290Slc, true, true) + yys2290 := string(yys2290Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2274 { + switch yys2290 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -30181,20 +30384,20 @@ func (x *PodStatusResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2277 := &x.ObjectMeta - yyv2277.CodecDecodeSelf(d) + yyv2293 := &x.ObjectMeta + yyv2293.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = PodStatus{} } else { - yyv2278 := &x.Status - yyv2278.CodecDecodeSelf(d) + yyv2294 := &x.Status + yyv2294.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2274) - } // end switch yys2274 - } // end for yyj2274 + z.DecStructFieldNotFound(-1, yys2290) + } // end switch yys2290 + } // end for yyj2290 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -30202,16 +30405,16 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2279 int - var yyb2279 bool - var yyhl2279 bool = l >= 0 - yyj2279++ - if yyhl2279 { - yyb2279 = yyj2279 > l + var yyj2295 int + var yyb2295 bool + var yyhl2295 bool = l >= 0 + yyj2295++ + if yyhl2295 { + yyb2295 = yyj2295 > l } else { - yyb2279 = r.CheckBreak() + yyb2295 = r.CheckBreak() } - if yyb2279 { + if yyb2295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30221,13 +30424,13 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj2279++ - if yyhl2279 { - yyb2279 = yyj2279 > l + yyj2295++ + if yyhl2295 { + yyb2295 = yyj2295 > l } else { - yyb2279 = r.CheckBreak() + yyb2295 = r.CheckBreak() } - if yyb2279 { + if yyb2295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30237,13 +30440,13 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj2279++ - if yyhl2279 { - yyb2279 = yyj2279 > l + yyj2295++ + if yyhl2295 { + yyb2295 = yyj2295 > l } else { - yyb2279 = r.CheckBreak() + yyb2295 = r.CheckBreak() } - if yyb2279 { + if yyb2295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30251,16 +30454,16 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2282 := &x.ObjectMeta - yyv2282.CodecDecodeSelf(d) + yyv2298 := &x.ObjectMeta + yyv2298.CodecDecodeSelf(d) } - yyj2279++ - if yyhl2279 { - yyb2279 = yyj2279 > l + yyj2295++ + if yyhl2295 { + yyb2295 = yyj2295 > l } else { - yyb2279 = r.CheckBreak() + yyb2295 = r.CheckBreak() } - if yyb2279 { + if yyb2295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30268,21 +30471,21 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.Status = PodStatus{} } else { - yyv2283 := &x.Status - yyv2283.CodecDecodeSelf(d) + yyv2299 := &x.Status + yyv2299.CodecDecodeSelf(d) } for { - yyj2279++ - if yyhl2279 { - yyb2279 = yyj2279 > l + yyj2295++ + if yyhl2295 { + yyb2295 = yyj2295 > l } else { - yyb2279 = r.CheckBreak() + yyb2295 = r.CheckBreak() } - if yyb2279 { + if yyb2295 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2279-1, "") + z.DecStructFieldNotFound(yyj2295-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -30294,39 +30497,39 @@ func (x *Pod) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2284 := z.EncBinary() - _ = yym2284 + yym2300 := z.EncBinary() + _ = yym2300 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2285 := !z.EncBinary() - yy2arr2285 := z.EncBasicHandle().StructToArray - var yyq2285 [5]bool - _, _, _ = yysep2285, yyq2285, yy2arr2285 - const yyr2285 bool = false - yyq2285[0] = x.Kind != "" - yyq2285[1] = x.APIVersion != "" - yyq2285[2] = true - yyq2285[3] = true - yyq2285[4] = true - var yynn2285 int - if yyr2285 || yy2arr2285 { + yysep2301 := !z.EncBinary() + yy2arr2301 := z.EncBasicHandle().StructToArray + var yyq2301 [5]bool + _, _, _ = yysep2301, yyq2301, yy2arr2301 + const yyr2301 bool = false + yyq2301[0] = x.Kind != "" + yyq2301[1] = x.APIVersion != "" + yyq2301[2] = true + yyq2301[3] = true + yyq2301[4] = true + var yynn2301 int + if yyr2301 || yy2arr2301 { r.EncodeArrayStart(5) } else { - yynn2285 = 0 - for _, b := range yyq2285 { + yynn2301 = 0 + for _, b := range yyq2301 { if b { - yynn2285++ + yynn2301++ } } - r.EncodeMapStart(yynn2285) - yynn2285 = 0 + r.EncodeMapStart(yynn2301) + yynn2301 = 0 } - if yyr2285 || yy2arr2285 { + if yyr2301 || yy2arr2301 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2285[0] { - yym2287 := z.EncBinary() - _ = yym2287 + if yyq2301[0] { + yym2303 := z.EncBinary() + _ = yym2303 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -30335,23 +30538,23 @@ func (x *Pod) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2285[0] { + if yyq2301[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2288 := z.EncBinary() - _ = yym2288 + yym2304 := z.EncBinary() + _ = yym2304 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2285 || yy2arr2285 { + if yyr2301 || yy2arr2301 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2285[1] { - yym2290 := z.EncBinary() - _ = yym2290 + if yyq2301[1] { + yym2306 := z.EncBinary() + _ = yym2306 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -30360,70 +30563,70 @@ func (x *Pod) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2285[1] { + if yyq2301[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2291 := z.EncBinary() - _ = yym2291 + yym2307 := z.EncBinary() + _ = yym2307 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2285 || yy2arr2285 { + if yyr2301 || yy2arr2301 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2285[2] { - yy2293 := &x.ObjectMeta - yy2293.CodecEncodeSelf(e) + if yyq2301[2] { + yy2309 := &x.ObjectMeta + yy2309.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2285[2] { + if yyq2301[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2294 := &x.ObjectMeta - yy2294.CodecEncodeSelf(e) + yy2310 := &x.ObjectMeta + yy2310.CodecEncodeSelf(e) } } - if yyr2285 || yy2arr2285 { + if yyr2301 || yy2arr2301 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2285[3] { - yy2296 := &x.Spec - yy2296.CodecEncodeSelf(e) + if yyq2301[3] { + yy2312 := &x.Spec + yy2312.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2285[3] { + if yyq2301[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2297 := &x.Spec - yy2297.CodecEncodeSelf(e) + yy2313 := &x.Spec + yy2313.CodecEncodeSelf(e) } } - if yyr2285 || yy2arr2285 { + if yyr2301 || yy2arr2301 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2285[4] { - yy2299 := &x.Status - yy2299.CodecEncodeSelf(e) + if yyq2301[4] { + yy2315 := &x.Status + yy2315.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2285[4] { + if yyq2301[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2300 := &x.Status - yy2300.CodecEncodeSelf(e) + yy2316 := &x.Status + yy2316.CodecEncodeSelf(e) } } - if yyr2285 || yy2arr2285 { + if yyr2301 || yy2arr2301 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -30436,25 +30639,25 @@ func (x *Pod) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2301 := z.DecBinary() - _ = yym2301 + yym2317 := z.DecBinary() + _ = yym2317 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2302 := r.ContainerType() - if yyct2302 == codecSelferValueTypeMap1234 { - yyl2302 := r.ReadMapStart() - if yyl2302 == 0 { + yyct2318 := r.ContainerType() + if yyct2318 == codecSelferValueTypeMap1234 { + yyl2318 := r.ReadMapStart() + if yyl2318 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2302, d) + x.codecDecodeSelfFromMap(yyl2318, d) } - } else if yyct2302 == codecSelferValueTypeArray1234 { - yyl2302 := r.ReadArrayStart() - if yyl2302 == 0 { + } else if yyct2318 == codecSelferValueTypeArray1234 { + yyl2318 := r.ReadArrayStart() + if yyl2318 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2302, d) + x.codecDecodeSelfFromArray(yyl2318, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -30466,12 +30669,12 @@ func (x *Pod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2303Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2303Slc - var yyhl2303 bool = l >= 0 - for yyj2303 := 0; ; yyj2303++ { - if yyhl2303 { - if yyj2303 >= l { + var yys2319Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2319Slc + var yyhl2319 bool = l >= 0 + for yyj2319 := 0; ; yyj2319++ { + if yyhl2319 { + if yyj2319 >= l { break } } else { @@ -30480,10 +30683,10 @@ func (x *Pod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2303Slc = r.DecodeBytes(yys2303Slc, true, true) - yys2303 := string(yys2303Slc) + yys2319Slc = r.DecodeBytes(yys2319Slc, true, true) + yys2319 := string(yys2319Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2303 { + switch yys2319 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -30500,27 +30703,27 @@ func (x *Pod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2306 := &x.ObjectMeta - yyv2306.CodecDecodeSelf(d) + yyv2322 := &x.ObjectMeta + yyv2322.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = PodSpec{} } else { - yyv2307 := &x.Spec - yyv2307.CodecDecodeSelf(d) + yyv2323 := &x.Spec + yyv2323.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = PodStatus{} } else { - yyv2308 := &x.Status - yyv2308.CodecDecodeSelf(d) + yyv2324 := &x.Status + yyv2324.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2303) - } // end switch yys2303 - } // end for yyj2303 + z.DecStructFieldNotFound(-1, yys2319) + } // end switch yys2319 + } // end for yyj2319 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -30528,16 +30731,16 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2309 int - var yyb2309 bool - var yyhl2309 bool = l >= 0 - yyj2309++ - if yyhl2309 { - yyb2309 = yyj2309 > l + var yyj2325 int + var yyb2325 bool + var yyhl2325 bool = l >= 0 + yyj2325++ + if yyhl2325 { + yyb2325 = yyj2325 > l } else { - yyb2309 = r.CheckBreak() + yyb2325 = r.CheckBreak() } - if yyb2309 { + if yyb2325 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30547,13 +30750,13 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2309++ - if yyhl2309 { - yyb2309 = yyj2309 > l + yyj2325++ + if yyhl2325 { + yyb2325 = yyj2325 > l } else { - yyb2309 = r.CheckBreak() + yyb2325 = r.CheckBreak() } - if yyb2309 { + if yyb2325 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30563,13 +30766,13 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2309++ - if yyhl2309 { - yyb2309 = yyj2309 > l + yyj2325++ + if yyhl2325 { + yyb2325 = yyj2325 > l } else { - yyb2309 = r.CheckBreak() + yyb2325 = r.CheckBreak() } - if yyb2309 { + if yyb2325 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30577,16 +30780,16 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2312 := &x.ObjectMeta - yyv2312.CodecDecodeSelf(d) + yyv2328 := &x.ObjectMeta + yyv2328.CodecDecodeSelf(d) } - yyj2309++ - if yyhl2309 { - yyb2309 = yyj2309 > l + yyj2325++ + if yyhl2325 { + yyb2325 = yyj2325 > l } else { - yyb2309 = r.CheckBreak() + yyb2325 = r.CheckBreak() } - if yyb2309 { + if yyb2325 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30594,16 +30797,16 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Spec = PodSpec{} } else { - yyv2313 := &x.Spec - yyv2313.CodecDecodeSelf(d) + yyv2329 := &x.Spec + yyv2329.CodecDecodeSelf(d) } - yyj2309++ - if yyhl2309 { - yyb2309 = yyj2309 > l + yyj2325++ + if yyhl2325 { + yyb2325 = yyj2325 > l } else { - yyb2309 = r.CheckBreak() + yyb2325 = r.CheckBreak() } - if yyb2309 { + if yyb2325 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -30611,231 +30814,26 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Status = PodStatus{} } else { - yyv2314 := &x.Status - yyv2314.CodecDecodeSelf(d) + yyv2330 := &x.Status + yyv2330.CodecDecodeSelf(d) } for { - yyj2309++ - if yyhl2309 { - yyb2309 = yyj2309 > l + yyj2325++ + if yyhl2325 { + yyb2325 = yyj2325 > l } else { - yyb2309 = r.CheckBreak() + yyb2325 = r.CheckBreak() } - if yyb2309 { + if yyb2325 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2309-1, "") + z.DecStructFieldNotFound(yyj2325-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } func (x *PodTemplateSpec) CodecEncodeSelf(e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - if x == nil { - r.EncodeNil() - } else { - yym2315 := z.EncBinary() - _ = yym2315 - if false { - } else if z.HasExtensions() && z.EncExt(x) { - } else { - yysep2316 := !z.EncBinary() - yy2arr2316 := z.EncBasicHandle().StructToArray - var yyq2316 [2]bool - _, _, _ = yysep2316, yyq2316, yy2arr2316 - const yyr2316 bool = false - yyq2316[0] = true - yyq2316[1] = true - var yynn2316 int - if yyr2316 || yy2arr2316 { - r.EncodeArrayStart(2) - } else { - yynn2316 = 0 - for _, b := range yyq2316 { - if b { - yynn2316++ - } - } - r.EncodeMapStart(yynn2316) - yynn2316 = 0 - } - if yyr2316 || yy2arr2316 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2316[0] { - yy2318 := &x.ObjectMeta - yy2318.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq2316[0] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("metadata")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2319 := &x.ObjectMeta - yy2319.CodecEncodeSelf(e) - } - } - if yyr2316 || yy2arr2316 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2316[1] { - yy2321 := &x.Spec - yy2321.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq2316[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("spec")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2322 := &x.Spec - yy2322.CodecEncodeSelf(e) - } - } - if yyr2316 || yy2arr2316 { - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - z.EncSendContainerState(codecSelfer_containerMapEnd1234) - } - } - } -} - -func (x *PodTemplateSpec) CodecDecodeSelf(d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - yym2323 := z.DecBinary() - _ = yym2323 - if false { - } else if z.HasExtensions() && z.DecExt(x) { - } else { - yyct2324 := r.ContainerType() - if yyct2324 == codecSelferValueTypeMap1234 { - yyl2324 := r.ReadMapStart() - if yyl2324 == 0 { - z.DecSendContainerState(codecSelfer_containerMapEnd1234) - } else { - x.codecDecodeSelfFromMap(yyl2324, d) - } - } else if yyct2324 == codecSelferValueTypeArray1234 { - yyl2324 := r.ReadArrayStart() - if yyl2324 == 0 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - x.codecDecodeSelfFromArray(yyl2324, d) - } - } else { - panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) - } - } -} - -func (x *PodTemplateSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yys2325Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2325Slc - var yyhl2325 bool = l >= 0 - for yyj2325 := 0; ; yyj2325++ { - if yyhl2325 { - if yyj2325 >= l { - break - } - } else { - if r.CheckBreak() { - break - } - } - z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2325Slc = r.DecodeBytes(yys2325Slc, true, true) - yys2325 := string(yys2325Slc) - z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2325 { - case "metadata": - if r.TryDecodeAsNil() { - x.ObjectMeta = ObjectMeta{} - } else { - yyv2326 := &x.ObjectMeta - yyv2326.CodecDecodeSelf(d) - } - case "spec": - if r.TryDecodeAsNil() { - x.Spec = PodSpec{} - } else { - yyv2327 := &x.Spec - yyv2327.CodecDecodeSelf(d) - } - default: - z.DecStructFieldNotFound(-1, yys2325) - } // end switch yys2325 - } // end for yyj2325 - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x *PodTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yyj2328 int - var yyb2328 bool - var yyhl2328 bool = l >= 0 - yyj2328++ - if yyhl2328 { - yyb2328 = yyj2328 > l - } else { - yyb2328 = r.CheckBreak() - } - if yyb2328 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.ObjectMeta = ObjectMeta{} - } else { - yyv2329 := &x.ObjectMeta - yyv2329.CodecDecodeSelf(d) - } - yyj2328++ - if yyhl2328 { - yyb2328 = yyj2328 > l - } else { - yyb2328 = r.CheckBreak() - } - if yyb2328 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Spec = PodSpec{} - } else { - yyv2330 := &x.Spec - yyv2330.CodecDecodeSelf(d) - } - for { - yyj2328++ - if yyhl2328 { - yyb2328 = yyj2328 > l - } else { - yyb2328 = r.CheckBreak() - } - if yyb2328 { - break - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2328-1, "") - } - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -30849,16 +30847,14 @@ func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) { } else { yysep2332 := !z.EncBinary() yy2arr2332 := z.EncBasicHandle().StructToArray - var yyq2332 [4]bool + var yyq2332 [2]bool _, _, _ = yysep2332, yyq2332, yy2arr2332 const yyr2332 bool = false - yyq2332[0] = x.Kind != "" - yyq2332[1] = x.APIVersion != "" - yyq2332[2] = true - yyq2332[3] = true + yyq2332[0] = true + yyq2332[1] = true var yynn2332 int if yyr2332 || yy2arr2332 { - r.EncodeArrayStart(4) + r.EncodeArrayStart(2) } else { yynn2332 = 0 for _, b := range yyq2332 { @@ -30872,33 +30868,240 @@ func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) { if yyr2332 || yy2arr2332 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if yyq2332[0] { - yym2334 := z.EncBinary() - _ = yym2334 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) - } + yy2334 := &x.ObjectMeta + yy2334.CodecEncodeSelf(e) } else { - r.EncodeString(codecSelferC_UTF81234, "") + r.EncodeNil() } } else { if yyq2332[0] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("metadata")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy2335 := &x.ObjectMeta + yy2335.CodecEncodeSelf(e) + } + } + if yyr2332 || yy2arr2332 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2332[1] { + yy2337 := &x.Spec + yy2337.CodecEncodeSelf(e) + } else { + r.EncodeNil() + } + } else { + if yyq2332[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("spec")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy2338 := &x.Spec + yy2338.CodecEncodeSelf(e) + } + } + if yyr2332 || yy2arr2332 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *PodTemplateSpec) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym2339 := z.DecBinary() + _ = yym2339 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2340 := r.ContainerType() + if yyct2340 == codecSelferValueTypeMap1234 { + yyl2340 := r.ReadMapStart() + if yyl2340 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl2340, d) + } + } else if yyct2340 == codecSelferValueTypeArray1234 { + yyl2340 := r.ReadArrayStart() + if yyl2340 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl2340, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *PodTemplateSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys2341Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2341Slc + var yyhl2341 bool = l >= 0 + for yyj2341 := 0; ; yyj2341++ { + if yyhl2341 { + if yyj2341 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys2341Slc = r.DecodeBytes(yys2341Slc, true, true) + yys2341 := string(yys2341Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys2341 { + case "metadata": + if r.TryDecodeAsNil() { + x.ObjectMeta = ObjectMeta{} + } else { + yyv2342 := &x.ObjectMeta + yyv2342.CodecDecodeSelf(d) + } + case "spec": + if r.TryDecodeAsNil() { + x.Spec = PodSpec{} + } else { + yyv2343 := &x.Spec + yyv2343.CodecDecodeSelf(d) + } + default: + z.DecStructFieldNotFound(-1, yys2341) + } // end switch yys2341 + } // end for yyj2341 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *PodTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj2344 int + var yyb2344 bool + var yyhl2344 bool = l >= 0 + yyj2344++ + if yyhl2344 { + yyb2344 = yyj2344 > l + } else { + yyb2344 = r.CheckBreak() + } + if yyb2344 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ObjectMeta = ObjectMeta{} + } else { + yyv2345 := &x.ObjectMeta + yyv2345.CodecDecodeSelf(d) + } + yyj2344++ + if yyhl2344 { + yyb2344 = yyj2344 > l + } else { + yyb2344 = r.CheckBreak() + } + if yyb2344 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Spec = PodSpec{} + } else { + yyv2346 := &x.Spec + yyv2346.CodecDecodeSelf(d) + } + for { + yyj2344++ + if yyhl2344 { + yyb2344 = yyj2344 > l + } else { + yyb2344 = r.CheckBreak() + } + if yyb2344 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj2344-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym2347 := z.EncBinary() + _ = yym2347 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2348 := !z.EncBinary() + yy2arr2348 := z.EncBasicHandle().StructToArray + var yyq2348 [4]bool + _, _, _ = yysep2348, yyq2348, yy2arr2348 + const yyr2348 bool = false + yyq2348[0] = x.Kind != "" + yyq2348[1] = x.APIVersion != "" + yyq2348[2] = true + yyq2348[3] = true + var yynn2348 int + if yyr2348 || yy2arr2348 { + r.EncodeArrayStart(4) + } else { + yynn2348 = 0 + for _, b := range yyq2348 { + if b { + yynn2348++ + } + } + r.EncodeMapStart(yynn2348) + yynn2348 = 0 + } + if yyr2348 || yy2arr2348 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2348[0] { + yym2350 := z.EncBinary() + _ = yym2350 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2348[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2335 := z.EncBinary() - _ = yym2335 + yym2351 := z.EncBinary() + _ = yym2351 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2332 || yy2arr2332 { + if yyr2348 || yy2arr2348 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2332[1] { - yym2337 := z.EncBinary() - _ = yym2337 + if yyq2348[1] { + yym2353 := z.EncBinary() + _ = yym2353 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -30907,53 +31110,53 @@ func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2332[1] { + if yyq2348[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2338 := z.EncBinary() - _ = yym2338 + yym2354 := z.EncBinary() + _ = yym2354 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2332 || yy2arr2332 { + if yyr2348 || yy2arr2348 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2332[2] { - yy2340 := &x.ObjectMeta - yy2340.CodecEncodeSelf(e) + if yyq2348[2] { + yy2356 := &x.ObjectMeta + yy2356.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2332[2] { + if yyq2348[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2341 := &x.ObjectMeta - yy2341.CodecEncodeSelf(e) + yy2357 := &x.ObjectMeta + yy2357.CodecEncodeSelf(e) } } - if yyr2332 || yy2arr2332 { + if yyr2348 || yy2arr2348 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2332[3] { - yy2343 := &x.Template - yy2343.CodecEncodeSelf(e) + if yyq2348[3] { + yy2359 := &x.Template + yy2359.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2332[3] { + if yyq2348[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("template")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2344 := &x.Template - yy2344.CodecEncodeSelf(e) + yy2360 := &x.Template + yy2360.CodecEncodeSelf(e) } } - if yyr2332 || yy2arr2332 { + if yyr2348 || yy2arr2348 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -30966,25 +31169,25 @@ func (x *PodTemplate) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2345 := z.DecBinary() - _ = yym2345 + yym2361 := z.DecBinary() + _ = yym2361 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2346 := r.ContainerType() - if yyct2346 == codecSelferValueTypeMap1234 { - yyl2346 := r.ReadMapStart() - if yyl2346 == 0 { + yyct2362 := r.ContainerType() + if yyct2362 == codecSelferValueTypeMap1234 { + yyl2362 := r.ReadMapStart() + if yyl2362 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2346, d) + x.codecDecodeSelfFromMap(yyl2362, d) } - } else if yyct2346 == codecSelferValueTypeArray1234 { - yyl2346 := r.ReadArrayStart() - if yyl2346 == 0 { + } else if yyct2362 == codecSelferValueTypeArray1234 { + yyl2362 := r.ReadArrayStart() + if yyl2362 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2346, d) + x.codecDecodeSelfFromArray(yyl2362, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -30996,12 +31199,12 @@ func (x *PodTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2347Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2347Slc - var yyhl2347 bool = l >= 0 - for yyj2347 := 0; ; yyj2347++ { - if yyhl2347 { - if yyj2347 >= l { + var yys2363Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2363Slc + var yyhl2363 bool = l >= 0 + for yyj2363 := 0; ; yyj2363++ { + if yyhl2363 { + if yyj2363 >= l { break } } else { @@ -31010,10 +31213,10 @@ func (x *PodTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2347Slc = r.DecodeBytes(yys2347Slc, true, true) - yys2347 := string(yys2347Slc) + yys2363Slc = r.DecodeBytes(yys2363Slc, true, true) + yys2363 := string(yys2363Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2347 { + switch yys2363 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -31030,20 +31233,20 @@ func (x *PodTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2350 := &x.ObjectMeta - yyv2350.CodecDecodeSelf(d) + yyv2366 := &x.ObjectMeta + yyv2366.CodecDecodeSelf(d) } case "template": if r.TryDecodeAsNil() { x.Template = PodTemplateSpec{} } else { - yyv2351 := &x.Template - yyv2351.CodecDecodeSelf(d) + yyv2367 := &x.Template + yyv2367.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2347) - } // end switch yys2347 - } // end for yyj2347 + z.DecStructFieldNotFound(-1, yys2363) + } // end switch yys2363 + } // end for yyj2363 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -31051,16 +31254,16 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2352 int - var yyb2352 bool - var yyhl2352 bool = l >= 0 - yyj2352++ - if yyhl2352 { - yyb2352 = yyj2352 > l + var yyj2368 int + var yyb2368 bool + var yyhl2368 bool = l >= 0 + yyj2368++ + if yyhl2368 { + yyb2368 = yyj2368 > l } else { - yyb2352 = r.CheckBreak() + yyb2368 = r.CheckBreak() } - if yyb2352 { + if yyb2368 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31070,13 +31273,13 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2352++ - if yyhl2352 { - yyb2352 = yyj2352 > l + yyj2368++ + if yyhl2368 { + yyb2368 = yyj2368 > l } else { - yyb2352 = r.CheckBreak() + yyb2368 = r.CheckBreak() } - if yyb2352 { + if yyb2368 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31086,13 +31289,13 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2352++ - if yyhl2352 { - yyb2352 = yyj2352 > l + yyj2368++ + if yyhl2368 { + yyb2368 = yyj2368 > l } else { - yyb2352 = r.CheckBreak() + yyb2368 = r.CheckBreak() } - if yyb2352 { + if yyb2368 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31100,16 +31303,16 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2355 := &x.ObjectMeta - yyv2355.CodecDecodeSelf(d) + yyv2371 := &x.ObjectMeta + yyv2371.CodecDecodeSelf(d) } - yyj2352++ - if yyhl2352 { - yyb2352 = yyj2352 > l + yyj2368++ + if yyhl2368 { + yyb2368 = yyj2368 > l } else { - yyb2352 = r.CheckBreak() + yyb2368 = r.CheckBreak() } - if yyb2352 { + if yyb2368 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31117,21 +31320,21 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Template = PodTemplateSpec{} } else { - yyv2356 := &x.Template - yyv2356.CodecDecodeSelf(d) + yyv2372 := &x.Template + yyv2372.CodecDecodeSelf(d) } for { - yyj2352++ - if yyhl2352 { - yyb2352 = yyj2352 > l + yyj2368++ + if yyhl2368 { + yyb2368 = yyj2368 > l } else { - yyb2352 = r.CheckBreak() + yyb2368 = r.CheckBreak() } - if yyb2352 { + if yyb2368 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2352-1, "") + z.DecStructFieldNotFound(yyj2368-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -31143,37 +31346,37 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2357 := z.EncBinary() - _ = yym2357 + yym2373 := z.EncBinary() + _ = yym2373 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2358 := !z.EncBinary() - yy2arr2358 := z.EncBasicHandle().StructToArray - var yyq2358 [4]bool - _, _, _ = yysep2358, yyq2358, yy2arr2358 - const yyr2358 bool = false - yyq2358[0] = x.Kind != "" - yyq2358[1] = x.APIVersion != "" - yyq2358[2] = true - var yynn2358 int - if yyr2358 || yy2arr2358 { + yysep2374 := !z.EncBinary() + yy2arr2374 := z.EncBasicHandle().StructToArray + var yyq2374 [4]bool + _, _, _ = yysep2374, yyq2374, yy2arr2374 + const yyr2374 bool = false + yyq2374[0] = x.Kind != "" + yyq2374[1] = x.APIVersion != "" + yyq2374[2] = true + var yynn2374 int + if yyr2374 || yy2arr2374 { r.EncodeArrayStart(4) } else { - yynn2358 = 1 - for _, b := range yyq2358 { + yynn2374 = 1 + for _, b := range yyq2374 { if b { - yynn2358++ + yynn2374++ } } - r.EncodeMapStart(yynn2358) - yynn2358 = 0 + r.EncodeMapStart(yynn2374) + yynn2374 = 0 } - if yyr2358 || yy2arr2358 { + if yyr2374 || yy2arr2374 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2358[0] { - yym2360 := z.EncBinary() - _ = yym2360 + if yyq2374[0] { + yym2376 := z.EncBinary() + _ = yym2376 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -31182,23 +31385,23 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2358[0] { + if yyq2374[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2361 := z.EncBinary() - _ = yym2361 + yym2377 := z.EncBinary() + _ = yym2377 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2358 || yy2arr2358 { + if yyr2374 || yy2arr2374 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2358[1] { - yym2363 := z.EncBinary() - _ = yym2363 + if yyq2374[1] { + yym2379 := z.EncBinary() + _ = yym2379 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -31207,54 +31410,54 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2358[1] { + if yyq2374[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2364 := z.EncBinary() - _ = yym2364 + yym2380 := z.EncBinary() + _ = yym2380 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2358 || yy2arr2358 { + if yyr2374 || yy2arr2374 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2358[2] { - yy2366 := &x.ListMeta - yym2367 := z.EncBinary() - _ = yym2367 + if yyq2374[2] { + yy2382 := &x.ListMeta + yym2383 := z.EncBinary() + _ = yym2383 if false { - } else if z.HasExtensions() && z.EncExt(yy2366) { + } else if z.HasExtensions() && z.EncExt(yy2382) { } else { - z.EncFallback(yy2366) + z.EncFallback(yy2382) } } else { r.EncodeNil() } } else { - if yyq2358[2] { + if yyq2374[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2368 := &x.ListMeta - yym2369 := z.EncBinary() - _ = yym2369 + yy2384 := &x.ListMeta + yym2385 := z.EncBinary() + _ = yym2385 if false { - } else if z.HasExtensions() && z.EncExt(yy2368) { + } else if z.HasExtensions() && z.EncExt(yy2384) { } else { - z.EncFallback(yy2368) + z.EncFallback(yy2384) } } } - if yyr2358 || yy2arr2358 { + if yyr2374 || yy2arr2374 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym2371 := z.EncBinary() - _ = yym2371 + yym2387 := z.EncBinary() + _ = yym2387 if false { } else { h.encSlicePodTemplate(([]PodTemplate)(x.Items), e) @@ -31267,15 +31470,15 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym2372 := z.EncBinary() - _ = yym2372 + yym2388 := z.EncBinary() + _ = yym2388 if false { } else { h.encSlicePodTemplate(([]PodTemplate)(x.Items), e) } } } - if yyr2358 || yy2arr2358 { + if yyr2374 || yy2arr2374 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -31288,25 +31491,25 @@ func (x *PodTemplateList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2373 := z.DecBinary() - _ = yym2373 + yym2389 := z.DecBinary() + _ = yym2389 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2374 := r.ContainerType() - if yyct2374 == codecSelferValueTypeMap1234 { - yyl2374 := r.ReadMapStart() - if yyl2374 == 0 { + yyct2390 := r.ContainerType() + if yyct2390 == codecSelferValueTypeMap1234 { + yyl2390 := r.ReadMapStart() + if yyl2390 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2374, d) + x.codecDecodeSelfFromMap(yyl2390, d) } - } else if yyct2374 == codecSelferValueTypeArray1234 { - yyl2374 := r.ReadArrayStart() - if yyl2374 == 0 { + } else if yyct2390 == codecSelferValueTypeArray1234 { + yyl2390 := r.ReadArrayStart() + if yyl2390 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2374, d) + x.codecDecodeSelfFromArray(yyl2390, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -31318,12 +31521,12 @@ func (x *PodTemplateList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2375Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2375Slc - var yyhl2375 bool = l >= 0 - for yyj2375 := 0; ; yyj2375++ { - if yyhl2375 { - if yyj2375 >= l { + var yys2391Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2391Slc + var yyhl2391 bool = l >= 0 + for yyj2391 := 0; ; yyj2391++ { + if yyhl2391 { + if yyj2391 >= l { break } } else { @@ -31332,10 +31535,10 @@ func (x *PodTemplateList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2375Slc = r.DecodeBytes(yys2375Slc, true, true) - yys2375 := string(yys2375Slc) + yys2391Slc = r.DecodeBytes(yys2391Slc, true, true) + yys2391 := string(yys2391Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2375 { + switch yys2391 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -31352,31 +31555,31 @@ func (x *PodTemplateList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2378 := &x.ListMeta - yym2379 := z.DecBinary() - _ = yym2379 + yyv2394 := &x.ListMeta + yym2395 := z.DecBinary() + _ = yym2395 if false { - } else if z.HasExtensions() && z.DecExt(yyv2378) { + } else if z.HasExtensions() && z.DecExt(yyv2394) { } else { - z.DecFallback(yyv2378, false) + z.DecFallback(yyv2394, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2380 := &x.Items - yym2381 := z.DecBinary() - _ = yym2381 + yyv2396 := &x.Items + yym2397 := z.DecBinary() + _ = yym2397 if false { } else { - h.decSlicePodTemplate((*[]PodTemplate)(yyv2380), d) + h.decSlicePodTemplate((*[]PodTemplate)(yyv2396), d) } } default: - z.DecStructFieldNotFound(-1, yys2375) - } // end switch yys2375 - } // end for yyj2375 + z.DecStructFieldNotFound(-1, yys2391) + } // end switch yys2391 + } // end for yyj2391 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -31384,16 +31587,16 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2382 int - var yyb2382 bool - var yyhl2382 bool = l >= 0 - yyj2382++ - if yyhl2382 { - yyb2382 = yyj2382 > l + var yyj2398 int + var yyb2398 bool + var yyhl2398 bool = l >= 0 + yyj2398++ + if yyhl2398 { + yyb2398 = yyj2398 > l } else { - yyb2382 = r.CheckBreak() + yyb2398 = r.CheckBreak() } - if yyb2382 { + if yyb2398 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31403,13 +31606,13 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj2382++ - if yyhl2382 { - yyb2382 = yyj2382 > l + yyj2398++ + if yyhl2398 { + yyb2398 = yyj2398 > l } else { - yyb2382 = r.CheckBreak() + yyb2398 = r.CheckBreak() } - if yyb2382 { + if yyb2398 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31419,13 +31622,13 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj2382++ - if yyhl2382 { - yyb2382 = yyj2382 > l + yyj2398++ + if yyhl2398 { + yyb2398 = yyj2398 > l } else { - yyb2382 = r.CheckBreak() + yyb2398 = r.CheckBreak() } - if yyb2382 { + if yyb2398 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31433,22 +31636,22 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2385 := &x.ListMeta - yym2386 := z.DecBinary() - _ = yym2386 + yyv2401 := &x.ListMeta + yym2402 := z.DecBinary() + _ = yym2402 if false { - } else if z.HasExtensions() && z.DecExt(yyv2385) { + } else if z.HasExtensions() && z.DecExt(yyv2401) { } else { - z.DecFallback(yyv2385, false) + z.DecFallback(yyv2401, false) } } - yyj2382++ - if yyhl2382 { - yyb2382 = yyj2382 > l + yyj2398++ + if yyhl2398 { + yyb2398 = yyj2398 > l } else { - yyb2382 = r.CheckBreak() + yyb2398 = r.CheckBreak() } - if yyb2382 { + if yyb2398 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31456,26 +31659,26 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2387 := &x.Items - yym2388 := z.DecBinary() - _ = yym2388 + yyv2403 := &x.Items + yym2404 := z.DecBinary() + _ = yym2404 if false { } else { - h.decSlicePodTemplate((*[]PodTemplate)(yyv2387), d) + h.decSlicePodTemplate((*[]PodTemplate)(yyv2403), d) } } for { - yyj2382++ - if yyhl2382 { - yyb2382 = yyj2382 > l + yyj2398++ + if yyhl2398 { + yyb2398 = yyj2398 > l } else { - yyb2382 = r.CheckBreak() + yyb2398 = r.CheckBreak() } - if yyb2382 { + if yyb2398 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2382-1, "") + z.DecStructFieldNotFound(yyj2398-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -31487,34 +31690,34 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2389 := z.EncBinary() - _ = yym2389 + yym2405 := z.EncBinary() + _ = yym2405 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2390 := !z.EncBinary() - yy2arr2390 := z.EncBasicHandle().StructToArray - var yyq2390 [3]bool - _, _, _ = yysep2390, yyq2390, yy2arr2390 - const yyr2390 bool = false - yyq2390[2] = x.Template != nil - var yynn2390 int - if yyr2390 || yy2arr2390 { + yysep2406 := !z.EncBinary() + yy2arr2406 := z.EncBasicHandle().StructToArray + var yyq2406 [3]bool + _, _, _ = yysep2406, yyq2406, yy2arr2406 + const yyr2406 bool = false + yyq2406[2] = x.Template != nil + var yynn2406 int + if yyr2406 || yy2arr2406 { r.EncodeArrayStart(3) } else { - yynn2390 = 2 - for _, b := range yyq2390 { + yynn2406 = 2 + for _, b := range yyq2406 { if b { - yynn2390++ + yynn2406++ } } - r.EncodeMapStart(yynn2390) - yynn2390 = 0 + r.EncodeMapStart(yynn2406) + yynn2406 = 0 } - if yyr2390 || yy2arr2390 { + if yyr2406 || yy2arr2406 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2392 := z.EncBinary() - _ = yym2392 + yym2408 := z.EncBinary() + _ = yym2408 if false { } else { r.EncodeInt(int64(x.Replicas)) @@ -31523,20 +31726,20 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("replicas")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2393 := z.EncBinary() - _ = yym2393 + yym2409 := z.EncBinary() + _ = yym2409 if false { } else { r.EncodeInt(int64(x.Replicas)) } } - if yyr2390 || yy2arr2390 { + if yyr2406 || yy2arr2406 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Selector == nil { r.EncodeNil() } else { - yym2395 := z.EncBinary() - _ = yym2395 + yym2411 := z.EncBinary() + _ = yym2411 if false { } else { z.F.EncMapStringStringV(x.Selector, false, e) @@ -31549,17 +31752,17 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x.Selector == nil { r.EncodeNil() } else { - yym2396 := z.EncBinary() - _ = yym2396 + yym2412 := z.EncBinary() + _ = yym2412 if false { } else { z.F.EncMapStringStringV(x.Selector, false, e) } } } - if yyr2390 || yy2arr2390 { + if yyr2406 || yy2arr2406 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2390[2] { + if yyq2406[2] { if x.Template == nil { r.EncodeNil() } else { @@ -31569,7 +31772,7 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2390[2] { + if yyq2406[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("template")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -31580,7 +31783,7 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2390 || yy2arr2390 { + if yyr2406 || yy2arr2406 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -31593,25 +31796,25 @@ func (x *ReplicationControllerSpec) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2398 := z.DecBinary() - _ = yym2398 + yym2414 := z.DecBinary() + _ = yym2414 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2399 := r.ContainerType() - if yyct2399 == codecSelferValueTypeMap1234 { - yyl2399 := r.ReadMapStart() - if yyl2399 == 0 { + yyct2415 := r.ContainerType() + if yyct2415 == codecSelferValueTypeMap1234 { + yyl2415 := r.ReadMapStart() + if yyl2415 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2399, d) + x.codecDecodeSelfFromMap(yyl2415, d) } - } else if yyct2399 == codecSelferValueTypeArray1234 { - yyl2399 := r.ReadArrayStart() - if yyl2399 == 0 { + } else if yyct2415 == codecSelferValueTypeArray1234 { + yyl2415 := r.ReadArrayStart() + if yyl2415 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2399, d) + x.codecDecodeSelfFromArray(yyl2415, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -31623,12 +31826,12 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2400Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2400Slc - var yyhl2400 bool = l >= 0 - for yyj2400 := 0; ; yyj2400++ { - if yyhl2400 { - if yyj2400 >= l { + var yys2416Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2416Slc + var yyhl2416 bool = l >= 0 + for yyj2416 := 0; ; yyj2416++ { + if yyhl2416 { + if yyj2416 >= l { break } } else { @@ -31637,10 +31840,10 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2400Slc = r.DecodeBytes(yys2400Slc, true, true) - yys2400 := string(yys2400Slc) + yys2416Slc = r.DecodeBytes(yys2416Slc, true, true) + yys2416 := string(yys2416Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2400 { + switch yys2416 { case "replicas": if r.TryDecodeAsNil() { x.Replicas = 0 @@ -31651,12 +31854,12 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D if r.TryDecodeAsNil() { x.Selector = nil } else { - yyv2402 := &x.Selector - yym2403 := z.DecBinary() - _ = yym2403 + yyv2418 := &x.Selector + yym2419 := z.DecBinary() + _ = yym2419 if false { } else { - z.F.DecMapStringStringX(yyv2402, false, d) + z.F.DecMapStringStringX(yyv2418, false, d) } } case "template": @@ -31671,9 +31874,9 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D x.Template.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2400) - } // end switch yys2400 - } // end for yyj2400 + z.DecStructFieldNotFound(-1, yys2416) + } // end switch yys2416 + } // end for yyj2416 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -31681,16 +31884,16 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2405 int - var yyb2405 bool - var yyhl2405 bool = l >= 0 - yyj2405++ - if yyhl2405 { - yyb2405 = yyj2405 > l + var yyj2421 int + var yyb2421 bool + var yyhl2421 bool = l >= 0 + yyj2421++ + if yyhl2421 { + yyb2421 = yyj2421 > l } else { - yyb2405 = r.CheckBreak() + yyb2421 = r.CheckBreak() } - if yyb2405 { + if yyb2421 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31700,13 +31903,13 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978 } else { x.Replicas = int32(r.DecodeInt(32)) } - yyj2405++ - if yyhl2405 { - yyb2405 = yyj2405 > l + yyj2421++ + if yyhl2421 { + yyb2421 = yyj2421 > l } else { - yyb2405 = r.CheckBreak() + yyb2421 = r.CheckBreak() } - if yyb2405 { + if yyb2421 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31714,21 +31917,21 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978 if r.TryDecodeAsNil() { x.Selector = nil } else { - yyv2407 := &x.Selector - yym2408 := z.DecBinary() - _ = yym2408 + yyv2423 := &x.Selector + yym2424 := z.DecBinary() + _ = yym2424 if false { } else { - z.F.DecMapStringStringX(yyv2407, false, d) + z.F.DecMapStringStringX(yyv2423, false, d) } } - yyj2405++ - if yyhl2405 { - yyb2405 = yyj2405 > l + yyj2421++ + if yyhl2421 { + yyb2421 = yyj2421 > l } else { - yyb2405 = r.CheckBreak() + yyb2421 = r.CheckBreak() } - if yyb2405 { + if yyb2421 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -31744,17 +31947,17 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978 x.Template.CodecDecodeSelf(d) } for { - yyj2405++ - if yyhl2405 { - yyb2405 = yyj2405 > l + yyj2421++ + if yyhl2421 { + yyb2421 = yyj2421 > l } else { - yyb2405 = r.CheckBreak() + yyb2421 = r.CheckBreak() } - if yyb2405 { + if yyb2421 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2405-1, "") + z.DecStructFieldNotFound(yyj2421-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -31766,36 +31969,36 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2410 := z.EncBinary() - _ = yym2410 + yym2426 := z.EncBinary() + _ = yym2426 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2411 := !z.EncBinary() - yy2arr2411 := z.EncBasicHandle().StructToArray - var yyq2411 [4]bool - _, _, _ = yysep2411, yyq2411, yy2arr2411 - const yyr2411 bool = false - yyq2411[1] = x.FullyLabeledReplicas != 0 - yyq2411[2] = x.ReadyReplicas != 0 - yyq2411[3] = x.ObservedGeneration != 0 - var yynn2411 int - if yyr2411 || yy2arr2411 { + yysep2427 := !z.EncBinary() + yy2arr2427 := z.EncBasicHandle().StructToArray + var yyq2427 [4]bool + _, _, _ = yysep2427, yyq2427, yy2arr2427 + const yyr2427 bool = false + yyq2427[1] = x.FullyLabeledReplicas != 0 + yyq2427[2] = x.ReadyReplicas != 0 + yyq2427[3] = x.ObservedGeneration != 0 + var yynn2427 int + if yyr2427 || yy2arr2427 { r.EncodeArrayStart(4) } else { - yynn2411 = 1 - for _, b := range yyq2411 { + yynn2427 = 1 + for _, b := range yyq2427 { if b { - yynn2411++ + yynn2427++ } } - r.EncodeMapStart(yynn2411) - yynn2411 = 0 + r.EncodeMapStart(yynn2427) + yynn2427 = 0 } - if yyr2411 || yy2arr2411 { + if yyr2427 || yy2arr2427 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2413 := z.EncBinary() - _ = yym2413 + yym2429 := z.EncBinary() + _ = yym2429 if false { } else { r.EncodeInt(int64(x.Replicas)) @@ -31804,18 +32007,18 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("replicas")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2414 := z.EncBinary() - _ = yym2414 + yym2430 := z.EncBinary() + _ = yym2430 if false { } else { r.EncodeInt(int64(x.Replicas)) } } - if yyr2411 || yy2arr2411 { + if yyr2427 || yy2arr2427 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2411[1] { - yym2416 := z.EncBinary() - _ = yym2416 + if yyq2427[1] { + yym2432 := z.EncBinary() + _ = yym2432 if false { } else { r.EncodeInt(int64(x.FullyLabeledReplicas)) @@ -31824,23 +32027,23 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeInt(0) } } else { - if yyq2411[1] { + if yyq2427[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2417 := z.EncBinary() - _ = yym2417 + yym2433 := z.EncBinary() + _ = yym2433 if false { } else { r.EncodeInt(int64(x.FullyLabeledReplicas)) } } } - if yyr2411 || yy2arr2411 { + if yyr2427 || yy2arr2427 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2411[2] { - yym2419 := z.EncBinary() - _ = yym2419 + if yyq2427[2] { + yym2435 := z.EncBinary() + _ = yym2435 if false { } else { r.EncodeInt(int64(x.ReadyReplicas)) @@ -31849,23 +32052,23 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeInt(0) } } else { - if yyq2411[2] { + if yyq2427[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("readyReplicas")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2420 := z.EncBinary() - _ = yym2420 + yym2436 := z.EncBinary() + _ = yym2436 if false { } else { r.EncodeInt(int64(x.ReadyReplicas)) } } } - if yyr2411 || yy2arr2411 { + if yyr2427 || yy2arr2427 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2411[3] { - yym2422 := z.EncBinary() - _ = yym2422 + if yyq2427[3] { + yym2438 := z.EncBinary() + _ = yym2438 if false { } else { r.EncodeInt(int64(x.ObservedGeneration)) @@ -31874,19 +32077,19 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeInt(0) } } else { - if yyq2411[3] { + if yyq2427[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("observedGeneration")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2423 := z.EncBinary() - _ = yym2423 + yym2439 := z.EncBinary() + _ = yym2439 if false { } else { r.EncodeInt(int64(x.ObservedGeneration)) } } } - if yyr2411 || yy2arr2411 { + if yyr2427 || yy2arr2427 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -31899,25 +32102,25 @@ func (x *ReplicationControllerStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2424 := z.DecBinary() - _ = yym2424 + yym2440 := z.DecBinary() + _ = yym2440 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2425 := r.ContainerType() - if yyct2425 == codecSelferValueTypeMap1234 { - yyl2425 := r.ReadMapStart() - if yyl2425 == 0 { + yyct2441 := r.ContainerType() + if yyct2441 == codecSelferValueTypeMap1234 { + yyl2441 := r.ReadMapStart() + if yyl2441 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2425, d) + x.codecDecodeSelfFromMap(yyl2441, d) } - } else if yyct2425 == codecSelferValueTypeArray1234 { - yyl2425 := r.ReadArrayStart() - if yyl2425 == 0 { + } else if yyct2441 == codecSelferValueTypeArray1234 { + yyl2441 := r.ReadArrayStart() + if yyl2441 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2425, d) + x.codecDecodeSelfFromArray(yyl2441, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -31929,12 +32132,12 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2426Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2426Slc - var yyhl2426 bool = l >= 0 - for yyj2426 := 0; ; yyj2426++ { - if yyhl2426 { - if yyj2426 >= l { + var yys2442Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2442Slc + var yyhl2442 bool = l >= 0 + for yyj2442 := 0; ; yyj2442++ { + if yyhl2442 { + if yyj2442 >= l { break } } else { @@ -31943,10 +32146,10 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978 } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2426Slc = r.DecodeBytes(yys2426Slc, true, true) - yys2426 := string(yys2426Slc) + yys2442Slc = r.DecodeBytes(yys2442Slc, true, true) + yys2442 := string(yys2442Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2426 { + switch yys2442 { case "replicas": if r.TryDecodeAsNil() { x.Replicas = 0 @@ -31972,9 +32175,9 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978 x.ObservedGeneration = int64(r.DecodeInt(64)) } default: - z.DecStructFieldNotFound(-1, yys2426) - } // end switch yys2426 - } // end for yyj2426 + z.DecStructFieldNotFound(-1, yys2442) + } // end switch yys2442 + } // end for yyj2442 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -31982,16 +32185,16 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2431 int - var yyb2431 bool - var yyhl2431 bool = l >= 0 - yyj2431++ - if yyhl2431 { - yyb2431 = yyj2431 > l + var yyj2447 int + var yyb2447 bool + var yyhl2447 bool = l >= 0 + yyj2447++ + if yyhl2447 { + yyb2447 = yyj2447 > l } else { - yyb2431 = r.CheckBreak() + yyb2447 = r.CheckBreak() } - if yyb2431 { + if yyb2447 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32001,13 +32204,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19 } else { x.Replicas = int32(r.DecodeInt(32)) } - yyj2431++ - if yyhl2431 { - yyb2431 = yyj2431 > l + yyj2447++ + if yyhl2447 { + yyb2447 = yyj2447 > l } else { - yyb2431 = r.CheckBreak() + yyb2447 = r.CheckBreak() } - if yyb2431 { + if yyb2447 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32017,13 +32220,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19 } else { x.FullyLabeledReplicas = int32(r.DecodeInt(32)) } - yyj2431++ - if yyhl2431 { - yyb2431 = yyj2431 > l + yyj2447++ + if yyhl2447 { + yyb2447 = yyj2447 > l } else { - yyb2431 = r.CheckBreak() + yyb2447 = r.CheckBreak() } - if yyb2431 { + if yyb2447 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32033,13 +32236,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19 } else { x.ReadyReplicas = int32(r.DecodeInt(32)) } - yyj2431++ - if yyhl2431 { - yyb2431 = yyj2431 > l + yyj2447++ + if yyhl2447 { + yyb2447 = yyj2447 > l } else { - yyb2431 = r.CheckBreak() + yyb2447 = r.CheckBreak() } - if yyb2431 { + if yyb2447 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32050,17 +32253,17 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19 x.ObservedGeneration = int64(r.DecodeInt(64)) } for { - yyj2431++ - if yyhl2431 { - yyb2431 = yyj2431 > l + yyj2447++ + if yyhl2447 { + yyb2447 = yyj2447 > l } else { - yyb2431 = r.CheckBreak() + yyb2447 = r.CheckBreak() } - if yyb2431 { + if yyb2447 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2431-1, "") + z.DecStructFieldNotFound(yyj2447-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -32072,39 +32275,39 @@ func (x *ReplicationController) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2436 := z.EncBinary() - _ = yym2436 + yym2452 := z.EncBinary() + _ = yym2452 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2437 := !z.EncBinary() - yy2arr2437 := z.EncBasicHandle().StructToArray - var yyq2437 [5]bool - _, _, _ = yysep2437, yyq2437, yy2arr2437 - const yyr2437 bool = false - yyq2437[0] = x.Kind != "" - yyq2437[1] = x.APIVersion != "" - yyq2437[2] = true - yyq2437[3] = true - yyq2437[4] = true - var yynn2437 int - if yyr2437 || yy2arr2437 { + yysep2453 := !z.EncBinary() + yy2arr2453 := z.EncBasicHandle().StructToArray + var yyq2453 [5]bool + _, _, _ = yysep2453, yyq2453, yy2arr2453 + const yyr2453 bool = false + yyq2453[0] = x.Kind != "" + yyq2453[1] = x.APIVersion != "" + yyq2453[2] = true + yyq2453[3] = true + yyq2453[4] = true + var yynn2453 int + if yyr2453 || yy2arr2453 { r.EncodeArrayStart(5) } else { - yynn2437 = 0 - for _, b := range yyq2437 { + yynn2453 = 0 + for _, b := range yyq2453 { if b { - yynn2437++ + yynn2453++ } } - r.EncodeMapStart(yynn2437) - yynn2437 = 0 + r.EncodeMapStart(yynn2453) + yynn2453 = 0 } - if yyr2437 || yy2arr2437 { + if yyr2453 || yy2arr2453 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2437[0] { - yym2439 := z.EncBinary() - _ = yym2439 + if yyq2453[0] { + yym2455 := z.EncBinary() + _ = yym2455 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -32113,23 +32316,23 @@ func (x *ReplicationController) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2437[0] { + if yyq2453[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2440 := z.EncBinary() - _ = yym2440 + yym2456 := z.EncBinary() + _ = yym2456 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2437 || yy2arr2437 { + if yyr2453 || yy2arr2453 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2437[1] { - yym2442 := z.EncBinary() - _ = yym2442 + if yyq2453[1] { + yym2458 := z.EncBinary() + _ = yym2458 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -32138,70 +32341,70 @@ func (x *ReplicationController) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2437[1] { + if yyq2453[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2443 := z.EncBinary() - _ = yym2443 + yym2459 := z.EncBinary() + _ = yym2459 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2437 || yy2arr2437 { + if yyr2453 || yy2arr2453 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2437[2] { - yy2445 := &x.ObjectMeta - yy2445.CodecEncodeSelf(e) + if yyq2453[2] { + yy2461 := &x.ObjectMeta + yy2461.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2437[2] { + if yyq2453[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2446 := &x.ObjectMeta - yy2446.CodecEncodeSelf(e) + yy2462 := &x.ObjectMeta + yy2462.CodecEncodeSelf(e) } } - if yyr2437 || yy2arr2437 { + if yyr2453 || yy2arr2453 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2437[3] { - yy2448 := &x.Spec - yy2448.CodecEncodeSelf(e) + if yyq2453[3] { + yy2464 := &x.Spec + yy2464.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2437[3] { + if yyq2453[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2449 := &x.Spec - yy2449.CodecEncodeSelf(e) + yy2465 := &x.Spec + yy2465.CodecEncodeSelf(e) } } - if yyr2437 || yy2arr2437 { + if yyr2453 || yy2arr2453 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2437[4] { - yy2451 := &x.Status - yy2451.CodecEncodeSelf(e) + if yyq2453[4] { + yy2467 := &x.Status + yy2467.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2437[4] { + if yyq2453[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2452 := &x.Status - yy2452.CodecEncodeSelf(e) + yy2468 := &x.Status + yy2468.CodecEncodeSelf(e) } } - if yyr2437 || yy2arr2437 { + if yyr2453 || yy2arr2453 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -32214,25 +32417,25 @@ func (x *ReplicationController) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2453 := z.DecBinary() - _ = yym2453 + yym2469 := z.DecBinary() + _ = yym2469 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2454 := r.ContainerType() - if yyct2454 == codecSelferValueTypeMap1234 { - yyl2454 := r.ReadMapStart() - if yyl2454 == 0 { + yyct2470 := r.ContainerType() + if yyct2470 == codecSelferValueTypeMap1234 { + yyl2470 := r.ReadMapStart() + if yyl2470 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2454, d) + x.codecDecodeSelfFromMap(yyl2470, d) } - } else if yyct2454 == codecSelferValueTypeArray1234 { - yyl2454 := r.ReadArrayStart() - if yyl2454 == 0 { + } else if yyct2470 == codecSelferValueTypeArray1234 { + yyl2470 := r.ReadArrayStart() + if yyl2470 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2454, d) + x.codecDecodeSelfFromArray(yyl2470, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -32244,12 +32447,12 @@ func (x *ReplicationController) codecDecodeSelfFromMap(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2455Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2455Slc - var yyhl2455 bool = l >= 0 - for yyj2455 := 0; ; yyj2455++ { - if yyhl2455 { - if yyj2455 >= l { + var yys2471Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2471Slc + var yyhl2471 bool = l >= 0 + for yyj2471 := 0; ; yyj2471++ { + if yyhl2471 { + if yyj2471 >= l { break } } else { @@ -32258,10 +32461,10 @@ func (x *ReplicationController) codecDecodeSelfFromMap(l int, d *codec1978.Decod } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2455Slc = r.DecodeBytes(yys2455Slc, true, true) - yys2455 := string(yys2455Slc) + yys2471Slc = r.DecodeBytes(yys2471Slc, true, true) + yys2471 := string(yys2471Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2455 { + switch yys2471 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -32278,27 +32481,27 @@ func (x *ReplicationController) codecDecodeSelfFromMap(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2458 := &x.ObjectMeta - yyv2458.CodecDecodeSelf(d) + yyv2474 := &x.ObjectMeta + yyv2474.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = ReplicationControllerSpec{} } else { - yyv2459 := &x.Spec - yyv2459.CodecDecodeSelf(d) + yyv2475 := &x.Spec + yyv2475.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = ReplicationControllerStatus{} } else { - yyv2460 := &x.Status - yyv2460.CodecDecodeSelf(d) + yyv2476 := &x.Status + yyv2476.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2455) - } // end switch yys2455 - } // end for yyj2455 + z.DecStructFieldNotFound(-1, yys2471) + } // end switch yys2471 + } // end for yyj2471 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -32306,16 +32509,16 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2461 int - var yyb2461 bool - var yyhl2461 bool = l >= 0 - yyj2461++ - if yyhl2461 { - yyb2461 = yyj2461 > l + var yyj2477 int + var yyb2477 bool + var yyhl2477 bool = l >= 0 + yyj2477++ + if yyhl2477 { + yyb2477 = yyj2477 > l } else { - yyb2461 = r.CheckBreak() + yyb2477 = r.CheckBreak() } - if yyb2461 { + if yyb2477 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32325,13 +32528,13 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec } else { x.Kind = string(r.DecodeString()) } - yyj2461++ - if yyhl2461 { - yyb2461 = yyj2461 > l + yyj2477++ + if yyhl2477 { + yyb2477 = yyj2477 > l } else { - yyb2461 = r.CheckBreak() + yyb2477 = r.CheckBreak() } - if yyb2461 { + if yyb2477 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32341,13 +32544,13 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec } else { x.APIVersion = string(r.DecodeString()) } - yyj2461++ - if yyhl2461 { - yyb2461 = yyj2461 > l + yyj2477++ + if yyhl2477 { + yyb2477 = yyj2477 > l } else { - yyb2461 = r.CheckBreak() + yyb2477 = r.CheckBreak() } - if yyb2461 { + if yyb2477 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32355,16 +32558,16 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2464 := &x.ObjectMeta - yyv2464.CodecDecodeSelf(d) + yyv2480 := &x.ObjectMeta + yyv2480.CodecDecodeSelf(d) } - yyj2461++ - if yyhl2461 { - yyb2461 = yyj2461 > l + yyj2477++ + if yyhl2477 { + yyb2477 = yyj2477 > l } else { - yyb2461 = r.CheckBreak() + yyb2477 = r.CheckBreak() } - if yyb2461 { + if yyb2477 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32372,16 +32575,16 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec if r.TryDecodeAsNil() { x.Spec = ReplicationControllerSpec{} } else { - yyv2465 := &x.Spec - yyv2465.CodecDecodeSelf(d) + yyv2481 := &x.Spec + yyv2481.CodecDecodeSelf(d) } - yyj2461++ - if yyhl2461 { - yyb2461 = yyj2461 > l + yyj2477++ + if yyhl2477 { + yyb2477 = yyj2477 > l } else { - yyb2461 = r.CheckBreak() + yyb2477 = r.CheckBreak() } - if yyb2461 { + if yyb2477 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32389,21 +32592,21 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec if r.TryDecodeAsNil() { x.Status = ReplicationControllerStatus{} } else { - yyv2466 := &x.Status - yyv2466.CodecDecodeSelf(d) + yyv2482 := &x.Status + yyv2482.CodecDecodeSelf(d) } for { - yyj2461++ - if yyhl2461 { - yyb2461 = yyj2461 > l + yyj2477++ + if yyhl2477 { + yyb2477 = yyj2477 > l } else { - yyb2461 = r.CheckBreak() + yyb2477 = r.CheckBreak() } - if yyb2461 { + if yyb2477 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2461-1, "") + z.DecStructFieldNotFound(yyj2477-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -32415,37 +32618,37 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2467 := z.EncBinary() - _ = yym2467 + yym2483 := z.EncBinary() + _ = yym2483 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2468 := !z.EncBinary() - yy2arr2468 := z.EncBasicHandle().StructToArray - var yyq2468 [4]bool - _, _, _ = yysep2468, yyq2468, yy2arr2468 - const yyr2468 bool = false - yyq2468[0] = x.Kind != "" - yyq2468[1] = x.APIVersion != "" - yyq2468[2] = true - var yynn2468 int - if yyr2468 || yy2arr2468 { + yysep2484 := !z.EncBinary() + yy2arr2484 := z.EncBasicHandle().StructToArray + var yyq2484 [4]bool + _, _, _ = yysep2484, yyq2484, yy2arr2484 + const yyr2484 bool = false + yyq2484[0] = x.Kind != "" + yyq2484[1] = x.APIVersion != "" + yyq2484[2] = true + var yynn2484 int + if yyr2484 || yy2arr2484 { r.EncodeArrayStart(4) } else { - yynn2468 = 1 - for _, b := range yyq2468 { + yynn2484 = 1 + for _, b := range yyq2484 { if b { - yynn2468++ + yynn2484++ } } - r.EncodeMapStart(yynn2468) - yynn2468 = 0 + r.EncodeMapStart(yynn2484) + yynn2484 = 0 } - if yyr2468 || yy2arr2468 { + if yyr2484 || yy2arr2484 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2468[0] { - yym2470 := z.EncBinary() - _ = yym2470 + if yyq2484[0] { + yym2486 := z.EncBinary() + _ = yym2486 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -32454,23 +32657,23 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2468[0] { + if yyq2484[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2471 := z.EncBinary() - _ = yym2471 + yym2487 := z.EncBinary() + _ = yym2487 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2468 || yy2arr2468 { + if yyr2484 || yy2arr2484 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2468[1] { - yym2473 := z.EncBinary() - _ = yym2473 + if yyq2484[1] { + yym2489 := z.EncBinary() + _ = yym2489 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -32479,54 +32682,54 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2468[1] { + if yyq2484[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2474 := z.EncBinary() - _ = yym2474 + yym2490 := z.EncBinary() + _ = yym2490 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2468 || yy2arr2468 { + if yyr2484 || yy2arr2484 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2468[2] { - yy2476 := &x.ListMeta - yym2477 := z.EncBinary() - _ = yym2477 + if yyq2484[2] { + yy2492 := &x.ListMeta + yym2493 := z.EncBinary() + _ = yym2493 if false { - } else if z.HasExtensions() && z.EncExt(yy2476) { + } else if z.HasExtensions() && z.EncExt(yy2492) { } else { - z.EncFallback(yy2476) + z.EncFallback(yy2492) } } else { r.EncodeNil() } } else { - if yyq2468[2] { + if yyq2484[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2478 := &x.ListMeta - yym2479 := z.EncBinary() - _ = yym2479 + yy2494 := &x.ListMeta + yym2495 := z.EncBinary() + _ = yym2495 if false { - } else if z.HasExtensions() && z.EncExt(yy2478) { + } else if z.HasExtensions() && z.EncExt(yy2494) { } else { - z.EncFallback(yy2478) + z.EncFallback(yy2494) } } } - if yyr2468 || yy2arr2468 { + if yyr2484 || yy2arr2484 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym2481 := z.EncBinary() - _ = yym2481 + yym2497 := z.EncBinary() + _ = yym2497 if false { } else { h.encSliceReplicationController(([]ReplicationController)(x.Items), e) @@ -32539,15 +32742,15 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym2482 := z.EncBinary() - _ = yym2482 + yym2498 := z.EncBinary() + _ = yym2498 if false { } else { h.encSliceReplicationController(([]ReplicationController)(x.Items), e) } } } - if yyr2468 || yy2arr2468 { + if yyr2484 || yy2arr2484 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -32560,25 +32763,25 @@ func (x *ReplicationControllerList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2483 := z.DecBinary() - _ = yym2483 + yym2499 := z.DecBinary() + _ = yym2499 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2484 := r.ContainerType() - if yyct2484 == codecSelferValueTypeMap1234 { - yyl2484 := r.ReadMapStart() - if yyl2484 == 0 { + yyct2500 := r.ContainerType() + if yyct2500 == codecSelferValueTypeMap1234 { + yyl2500 := r.ReadMapStart() + if yyl2500 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2484, d) + x.codecDecodeSelfFromMap(yyl2500, d) } - } else if yyct2484 == codecSelferValueTypeArray1234 { - yyl2484 := r.ReadArrayStart() - if yyl2484 == 0 { + } else if yyct2500 == codecSelferValueTypeArray1234 { + yyl2500 := r.ReadArrayStart() + if yyl2500 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2484, d) + x.codecDecodeSelfFromArray(yyl2500, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -32590,12 +32793,12 @@ func (x *ReplicationControllerList) codecDecodeSelfFromMap(l int, d *codec1978.D var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2485Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2485Slc - var yyhl2485 bool = l >= 0 - for yyj2485 := 0; ; yyj2485++ { - if yyhl2485 { - if yyj2485 >= l { + var yys2501Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2501Slc + var yyhl2501 bool = l >= 0 + for yyj2501 := 0; ; yyj2501++ { + if yyhl2501 { + if yyj2501 >= l { break } } else { @@ -32604,10 +32807,10 @@ func (x *ReplicationControllerList) codecDecodeSelfFromMap(l int, d *codec1978.D } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2485Slc = r.DecodeBytes(yys2485Slc, true, true) - yys2485 := string(yys2485Slc) + yys2501Slc = r.DecodeBytes(yys2501Slc, true, true) + yys2501 := string(yys2501Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2485 { + switch yys2501 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -32624,31 +32827,31 @@ func (x *ReplicationControllerList) codecDecodeSelfFromMap(l int, d *codec1978.D if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2488 := &x.ListMeta - yym2489 := z.DecBinary() - _ = yym2489 + yyv2504 := &x.ListMeta + yym2505 := z.DecBinary() + _ = yym2505 if false { - } else if z.HasExtensions() && z.DecExt(yyv2488) { + } else if z.HasExtensions() && z.DecExt(yyv2504) { } else { - z.DecFallback(yyv2488, false) + z.DecFallback(yyv2504, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2490 := &x.Items - yym2491 := z.DecBinary() - _ = yym2491 + yyv2506 := &x.Items + yym2507 := z.DecBinary() + _ = yym2507 if false { } else { - h.decSliceReplicationController((*[]ReplicationController)(yyv2490), d) + h.decSliceReplicationController((*[]ReplicationController)(yyv2506), d) } } default: - z.DecStructFieldNotFound(-1, yys2485) - } // end switch yys2485 - } // end for yyj2485 + z.DecStructFieldNotFound(-1, yys2501) + } // end switch yys2501 + } // end for yyj2501 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -32656,16 +32859,16 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2492 int - var yyb2492 bool - var yyhl2492 bool = l >= 0 - yyj2492++ - if yyhl2492 { - yyb2492 = yyj2492 > l + var yyj2508 int + var yyb2508 bool + var yyhl2508 bool = l >= 0 + yyj2508++ + if yyhl2508 { + yyb2508 = yyj2508 > l } else { - yyb2492 = r.CheckBreak() + yyb2508 = r.CheckBreak() } - if yyb2492 { + if yyb2508 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32675,13 +32878,13 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978 } else { x.Kind = string(r.DecodeString()) } - yyj2492++ - if yyhl2492 { - yyb2492 = yyj2492 > l + yyj2508++ + if yyhl2508 { + yyb2508 = yyj2508 > l } else { - yyb2492 = r.CheckBreak() + yyb2508 = r.CheckBreak() } - if yyb2492 { + if yyb2508 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32691,13 +32894,13 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978 } else { x.APIVersion = string(r.DecodeString()) } - yyj2492++ - if yyhl2492 { - yyb2492 = yyj2492 > l + yyj2508++ + if yyhl2508 { + yyb2508 = yyj2508 > l } else { - yyb2492 = r.CheckBreak() + yyb2508 = r.CheckBreak() } - if yyb2492 { + if yyb2508 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32705,22 +32908,22 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978 if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2495 := &x.ListMeta - yym2496 := z.DecBinary() - _ = yym2496 + yyv2511 := &x.ListMeta + yym2512 := z.DecBinary() + _ = yym2512 if false { - } else if z.HasExtensions() && z.DecExt(yyv2495) { + } else if z.HasExtensions() && z.DecExt(yyv2511) { } else { - z.DecFallback(yyv2495, false) + z.DecFallback(yyv2511, false) } } - yyj2492++ - if yyhl2492 { - yyb2492 = yyj2492 > l + yyj2508++ + if yyhl2508 { + yyb2508 = yyj2508 > l } else { - yyb2492 = r.CheckBreak() + yyb2508 = r.CheckBreak() } - if yyb2492 { + if yyb2508 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -32728,26 +32931,26 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978 if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2497 := &x.Items - yym2498 := z.DecBinary() - _ = yym2498 + yyv2513 := &x.Items + yym2514 := z.DecBinary() + _ = yym2514 if false { } else { - h.decSliceReplicationController((*[]ReplicationController)(yyv2497), d) + h.decSliceReplicationController((*[]ReplicationController)(yyv2513), d) } } for { - yyj2492++ - if yyhl2492 { - yyb2492 = yyj2492 > l + yyj2508++ + if yyhl2508 { + yyb2508 = yyj2508 > l } else { - yyb2492 = r.CheckBreak() + yyb2508 = r.CheckBreak() } - if yyb2492 { + if yyb2508 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2492-1, "") + z.DecStructFieldNotFound(yyj2508-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -32759,37 +32962,37 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2499 := z.EncBinary() - _ = yym2499 + yym2515 := z.EncBinary() + _ = yym2515 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2500 := !z.EncBinary() - yy2arr2500 := z.EncBasicHandle().StructToArray - var yyq2500 [4]bool - _, _, _ = yysep2500, yyq2500, yy2arr2500 - const yyr2500 bool = false - yyq2500[0] = x.Kind != "" - yyq2500[1] = x.APIVersion != "" - yyq2500[2] = true - var yynn2500 int - if yyr2500 || yy2arr2500 { + yysep2516 := !z.EncBinary() + yy2arr2516 := z.EncBasicHandle().StructToArray + var yyq2516 [4]bool + _, _, _ = yysep2516, yyq2516, yy2arr2516 + const yyr2516 bool = false + yyq2516[0] = x.Kind != "" + yyq2516[1] = x.APIVersion != "" + yyq2516[2] = true + var yynn2516 int + if yyr2516 || yy2arr2516 { r.EncodeArrayStart(4) } else { - yynn2500 = 1 - for _, b := range yyq2500 { + yynn2516 = 1 + for _, b := range yyq2516 { if b { - yynn2500++ + yynn2516++ } } - r.EncodeMapStart(yynn2500) - yynn2500 = 0 + r.EncodeMapStart(yynn2516) + yynn2516 = 0 } - if yyr2500 || yy2arr2500 { + if yyr2516 || yy2arr2516 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2500[0] { - yym2502 := z.EncBinary() - _ = yym2502 + if yyq2516[0] { + yym2518 := z.EncBinary() + _ = yym2518 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -32798,23 +33001,23 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2500[0] { + if yyq2516[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2503 := z.EncBinary() - _ = yym2503 + yym2519 := z.EncBinary() + _ = yym2519 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2500 || yy2arr2500 { + if yyr2516 || yy2arr2516 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2500[1] { - yym2505 := z.EncBinary() - _ = yym2505 + if yyq2516[1] { + yym2521 := z.EncBinary() + _ = yym2521 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -32823,54 +33026,54 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2500[1] { + if yyq2516[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2506 := z.EncBinary() - _ = yym2506 + yym2522 := z.EncBinary() + _ = yym2522 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2500 || yy2arr2500 { + if yyr2516 || yy2arr2516 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2500[2] { - yy2508 := &x.ListMeta - yym2509 := z.EncBinary() - _ = yym2509 + if yyq2516[2] { + yy2524 := &x.ListMeta + yym2525 := z.EncBinary() + _ = yym2525 if false { - } else if z.HasExtensions() && z.EncExt(yy2508) { + } else if z.HasExtensions() && z.EncExt(yy2524) { } else { - z.EncFallback(yy2508) + z.EncFallback(yy2524) } } else { r.EncodeNil() } } else { - if yyq2500[2] { + if yyq2516[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2510 := &x.ListMeta - yym2511 := z.EncBinary() - _ = yym2511 + yy2526 := &x.ListMeta + yym2527 := z.EncBinary() + _ = yym2527 if false { - } else if z.HasExtensions() && z.EncExt(yy2510) { + } else if z.HasExtensions() && z.EncExt(yy2526) { } else { - z.EncFallback(yy2510) + z.EncFallback(yy2526) } } } - if yyr2500 || yy2arr2500 { + if yyr2516 || yy2arr2516 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym2513 := z.EncBinary() - _ = yym2513 + yym2529 := z.EncBinary() + _ = yym2529 if false { } else { h.encSliceService(([]Service)(x.Items), e) @@ -32883,15 +33086,15 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym2514 := z.EncBinary() - _ = yym2514 + yym2530 := z.EncBinary() + _ = yym2530 if false { } else { h.encSliceService(([]Service)(x.Items), e) } } } - if yyr2500 || yy2arr2500 { + if yyr2516 || yy2arr2516 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -32904,25 +33107,25 @@ func (x *ServiceList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2515 := z.DecBinary() - _ = yym2515 + yym2531 := z.DecBinary() + _ = yym2531 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2516 := r.ContainerType() - if yyct2516 == codecSelferValueTypeMap1234 { - yyl2516 := r.ReadMapStart() - if yyl2516 == 0 { + yyct2532 := r.ContainerType() + if yyct2532 == codecSelferValueTypeMap1234 { + yyl2532 := r.ReadMapStart() + if yyl2532 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2516, d) + x.codecDecodeSelfFromMap(yyl2532, d) } - } else if yyct2516 == codecSelferValueTypeArray1234 { - yyl2516 := r.ReadArrayStart() - if yyl2516 == 0 { + } else if yyct2532 == codecSelferValueTypeArray1234 { + yyl2532 := r.ReadArrayStart() + if yyl2532 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2516, d) + x.codecDecodeSelfFromArray(yyl2532, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -32934,12 +33137,12 @@ func (x *ServiceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2517Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2517Slc - var yyhl2517 bool = l >= 0 - for yyj2517 := 0; ; yyj2517++ { - if yyhl2517 { - if yyj2517 >= l { + var yys2533Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2533Slc + var yyhl2533 bool = l >= 0 + for yyj2533 := 0; ; yyj2533++ { + if yyhl2533 { + if yyj2533 >= l { break } } else { @@ -32948,10 +33151,10 @@ func (x *ServiceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2517Slc = r.DecodeBytes(yys2517Slc, true, true) - yys2517 := string(yys2517Slc) + yys2533Slc = r.DecodeBytes(yys2533Slc, true, true) + yys2533 := string(yys2533Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2517 { + switch yys2533 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -32968,31 +33171,31 @@ func (x *ServiceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2520 := &x.ListMeta - yym2521 := z.DecBinary() - _ = yym2521 + yyv2536 := &x.ListMeta + yym2537 := z.DecBinary() + _ = yym2537 if false { - } else if z.HasExtensions() && z.DecExt(yyv2520) { + } else if z.HasExtensions() && z.DecExt(yyv2536) { } else { - z.DecFallback(yyv2520, false) + z.DecFallback(yyv2536, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2522 := &x.Items - yym2523 := z.DecBinary() - _ = yym2523 + yyv2538 := &x.Items + yym2539 := z.DecBinary() + _ = yym2539 if false { } else { - h.decSliceService((*[]Service)(yyv2522), d) + h.decSliceService((*[]Service)(yyv2538), d) } } default: - z.DecStructFieldNotFound(-1, yys2517) - } // end switch yys2517 - } // end for yyj2517 + z.DecStructFieldNotFound(-1, yys2533) + } // end switch yys2533 + } // end for yyj2533 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -33000,16 +33203,16 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2524 int - var yyb2524 bool - var yyhl2524 bool = l >= 0 - yyj2524++ - if yyhl2524 { - yyb2524 = yyj2524 > l + var yyj2540 int + var yyb2540 bool + var yyhl2540 bool = l >= 0 + yyj2540++ + if yyhl2540 { + yyb2540 = yyj2540 > l } else { - yyb2524 = r.CheckBreak() + yyb2540 = r.CheckBreak() } - if yyb2524 { + if yyb2540 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -33019,13 +33222,13 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2524++ - if yyhl2524 { - yyb2524 = yyj2524 > l + yyj2540++ + if yyhl2540 { + yyb2540 = yyj2540 > l } else { - yyb2524 = r.CheckBreak() + yyb2540 = r.CheckBreak() } - if yyb2524 { + if yyb2540 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -33035,13 +33238,13 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2524++ - if yyhl2524 { - yyb2524 = yyj2524 > l + yyj2540++ + if yyhl2540 { + yyb2540 = yyj2540 > l } else { - yyb2524 = r.CheckBreak() + yyb2540 = r.CheckBreak() } - if yyb2524 { + if yyb2540 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -33049,22 +33252,22 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2527 := &x.ListMeta - yym2528 := z.DecBinary() - _ = yym2528 + yyv2543 := &x.ListMeta + yym2544 := z.DecBinary() + _ = yym2544 if false { - } else if z.HasExtensions() && z.DecExt(yyv2527) { + } else if z.HasExtensions() && z.DecExt(yyv2543) { } else { - z.DecFallback(yyv2527, false) + z.DecFallback(yyv2543, false) } } - yyj2524++ - if yyhl2524 { - yyb2524 = yyj2524 > l + yyj2540++ + if yyhl2540 { + yyb2540 = yyj2540 > l } else { - yyb2524 = r.CheckBreak() + yyb2540 = r.CheckBreak() } - if yyb2524 { + if yyb2540 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -33072,26 +33275,26 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2529 := &x.Items - yym2530 := z.DecBinary() - _ = yym2530 + yyv2545 := &x.Items + yym2546 := z.DecBinary() + _ = yym2546 if false { } else { - h.decSliceService((*[]Service)(yyv2529), d) + h.decSliceService((*[]Service)(yyv2545), d) } } for { - yyj2524++ - if yyhl2524 { - yyb2524 = yyj2524 > l + yyj2540++ + if yyhl2540 { + yyb2540 = yyj2540 > l } else { - yyb2524 = r.CheckBreak() + yyb2540 = r.CheckBreak() } - if yyb2524 { + if yyb2540 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2524-1, "") + z.DecStructFieldNotFound(yyj2540-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -33100,8 +33303,8 @@ func (x ServiceAffinity) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym2531 := z.EncBinary() - _ = yym2531 + yym2547 := z.EncBinary() + _ = yym2547 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -33113,8 +33316,8 @@ func (x *ServiceAffinity) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2532 := z.DecBinary() - _ = yym2532 + yym2548 := z.DecBinary() + _ = yym2548 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -33126,8 +33329,8 @@ func (x ServiceType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym2533 := z.EncBinary() - _ = yym2533 + yym2549 := z.EncBinary() + _ = yym2549 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -33139,8 +33342,8 @@ func (x *ServiceType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2534 := z.DecBinary() - _ = yym2534 + yym2550 := z.DecBinary() + _ = yym2550 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -33155,48 +33358,48 @@ func (x *ServiceStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2535 := z.EncBinary() - _ = yym2535 + yym2551 := z.EncBinary() + _ = yym2551 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2536 := !z.EncBinary() - yy2arr2536 := z.EncBasicHandle().StructToArray - var yyq2536 [1]bool - _, _, _ = yysep2536, yyq2536, yy2arr2536 - const yyr2536 bool = false - yyq2536[0] = true - var yynn2536 int - if yyr2536 || yy2arr2536 { + yysep2552 := !z.EncBinary() + yy2arr2552 := z.EncBasicHandle().StructToArray + var yyq2552 [1]bool + _, _, _ = yysep2552, yyq2552, yy2arr2552 + const yyr2552 bool = false + yyq2552[0] = true + var yynn2552 int + if yyr2552 || yy2arr2552 { r.EncodeArrayStart(1) } else { - yynn2536 = 0 - for _, b := range yyq2536 { + yynn2552 = 0 + for _, b := range yyq2552 { if b { - yynn2536++ + yynn2552++ } } - r.EncodeMapStart(yynn2536) - yynn2536 = 0 + r.EncodeMapStart(yynn2552) + yynn2552 = 0 } - if yyr2536 || yy2arr2536 { + if yyr2552 || yy2arr2552 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2536[0] { - yy2538 := &x.LoadBalancer - yy2538.CodecEncodeSelf(e) + if yyq2552[0] { + yy2554 := &x.LoadBalancer + yy2554.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2536[0] { + if yyq2552[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("loadBalancer")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2539 := &x.LoadBalancer - yy2539.CodecEncodeSelf(e) + yy2555 := &x.LoadBalancer + yy2555.CodecEncodeSelf(e) } } - if yyr2536 || yy2arr2536 { + if yyr2552 || yy2arr2552 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -33209,25 +33412,25 @@ func (x *ServiceStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2540 := z.DecBinary() - _ = yym2540 + yym2556 := z.DecBinary() + _ = yym2556 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2541 := r.ContainerType() - if yyct2541 == codecSelferValueTypeMap1234 { - yyl2541 := r.ReadMapStart() - if yyl2541 == 0 { + yyct2557 := r.ContainerType() + if yyct2557 == codecSelferValueTypeMap1234 { + yyl2557 := r.ReadMapStart() + if yyl2557 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2541, d) + x.codecDecodeSelfFromMap(yyl2557, d) } - } else if yyct2541 == codecSelferValueTypeArray1234 { - yyl2541 := r.ReadArrayStart() - if yyl2541 == 0 { + } else if yyct2557 == codecSelferValueTypeArray1234 { + yyl2557 := r.ReadArrayStart() + if yyl2557 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2541, d) + x.codecDecodeSelfFromArray(yyl2557, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -33239,12 +33442,12 @@ func (x *ServiceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2542Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2542Slc - var yyhl2542 bool = l >= 0 - for yyj2542 := 0; ; yyj2542++ { - if yyhl2542 { - if yyj2542 >= l { + var yys2558Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2558Slc + var yyhl2558 bool = l >= 0 + for yyj2558 := 0; ; yyj2558++ { + if yyhl2558 { + if yyj2558 >= l { break } } else { @@ -33253,21 +33456,21 @@ func (x *ServiceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2542Slc = r.DecodeBytes(yys2542Slc, true, true) - yys2542 := string(yys2542Slc) + yys2558Slc = r.DecodeBytes(yys2558Slc, true, true) + yys2558 := string(yys2558Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2542 { + switch yys2558 { case "loadBalancer": if r.TryDecodeAsNil() { x.LoadBalancer = LoadBalancerStatus{} } else { - yyv2543 := &x.LoadBalancer - yyv2543.CodecDecodeSelf(d) + yyv2559 := &x.LoadBalancer + yyv2559.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2542) - } // end switch yys2542 - } // end for yyj2542 + z.DecStructFieldNotFound(-1, yys2558) + } // end switch yys2558 + } // end for yyj2558 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -33275,16 +33478,16 @@ func (x *ServiceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2544 int - var yyb2544 bool - var yyhl2544 bool = l >= 0 - yyj2544++ - if yyhl2544 { - yyb2544 = yyj2544 > l + var yyj2560 int + var yyb2560 bool + var yyhl2560 bool = l >= 0 + yyj2560++ + if yyhl2560 { + yyb2560 = yyj2560 > l } else { - yyb2544 = r.CheckBreak() + yyb2560 = r.CheckBreak() } - if yyb2544 { + if yyb2560 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -33292,21 +33495,21 @@ func (x *ServiceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LoadBalancer = LoadBalancerStatus{} } else { - yyv2545 := &x.LoadBalancer - yyv2545.CodecDecodeSelf(d) + yyv2561 := &x.LoadBalancer + yyv2561.CodecDecodeSelf(d) } for { - yyj2544++ - if yyhl2544 { - yyb2544 = yyj2544 > l + yyj2560++ + if yyhl2560 { + yyb2560 = yyj2560 > l } else { - yyb2544 = r.CheckBreak() + yyb2560 = r.CheckBreak() } - if yyb2544 { + if yyb2560 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2544-1, "") + z.DecStructFieldNotFound(yyj2560-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -33318,38 +33521,38 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2546 := z.EncBinary() - _ = yym2546 + yym2562 := z.EncBinary() + _ = yym2562 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2547 := !z.EncBinary() - yy2arr2547 := z.EncBasicHandle().StructToArray - var yyq2547 [1]bool - _, _, _ = yysep2547, yyq2547, yy2arr2547 - const yyr2547 bool = false - yyq2547[0] = len(x.Ingress) != 0 - var yynn2547 int - if yyr2547 || yy2arr2547 { + yysep2563 := !z.EncBinary() + yy2arr2563 := z.EncBasicHandle().StructToArray + var yyq2563 [1]bool + _, _, _ = yysep2563, yyq2563, yy2arr2563 + const yyr2563 bool = false + yyq2563[0] = len(x.Ingress) != 0 + var yynn2563 int + if yyr2563 || yy2arr2563 { r.EncodeArrayStart(1) } else { - yynn2547 = 0 - for _, b := range yyq2547 { + yynn2563 = 0 + for _, b := range yyq2563 { if b { - yynn2547++ + yynn2563++ } } - r.EncodeMapStart(yynn2547) - yynn2547 = 0 + r.EncodeMapStart(yynn2563) + yynn2563 = 0 } - if yyr2547 || yy2arr2547 { + if yyr2563 || yy2arr2563 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2547[0] { + if yyq2563[0] { if x.Ingress == nil { r.EncodeNil() } else { - yym2549 := z.EncBinary() - _ = yym2549 + yym2565 := z.EncBinary() + _ = yym2565 if false { } else { h.encSliceLoadBalancerIngress(([]LoadBalancerIngress)(x.Ingress), e) @@ -33359,15 +33562,15 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2547[0] { + if yyq2563[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("ingress")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.Ingress == nil { r.EncodeNil() } else { - yym2550 := z.EncBinary() - _ = yym2550 + yym2566 := z.EncBinary() + _ = yym2566 if false { } else { h.encSliceLoadBalancerIngress(([]LoadBalancerIngress)(x.Ingress), e) @@ -33375,7 +33578,7 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2547 || yy2arr2547 { + if yyr2563 || yy2arr2563 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -33385,213 +33588,6 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) { } func (x *LoadBalancerStatus) CodecDecodeSelf(d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - yym2551 := z.DecBinary() - _ = yym2551 - if false { - } else if z.HasExtensions() && z.DecExt(x) { - } else { - yyct2552 := r.ContainerType() - if yyct2552 == codecSelferValueTypeMap1234 { - yyl2552 := r.ReadMapStart() - if yyl2552 == 0 { - z.DecSendContainerState(codecSelfer_containerMapEnd1234) - } else { - x.codecDecodeSelfFromMap(yyl2552, d) - } - } else if yyct2552 == codecSelferValueTypeArray1234 { - yyl2552 := r.ReadArrayStart() - if yyl2552 == 0 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - x.codecDecodeSelfFromArray(yyl2552, d) - } - } else { - panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) - } - } -} - -func (x *LoadBalancerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yys2553Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2553Slc - var yyhl2553 bool = l >= 0 - for yyj2553 := 0; ; yyj2553++ { - if yyhl2553 { - if yyj2553 >= l { - break - } - } else { - if r.CheckBreak() { - break - } - } - z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2553Slc = r.DecodeBytes(yys2553Slc, true, true) - yys2553 := string(yys2553Slc) - z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2553 { - case "ingress": - if r.TryDecodeAsNil() { - x.Ingress = nil - } else { - yyv2554 := &x.Ingress - yym2555 := z.DecBinary() - _ = yym2555 - if false { - } else { - h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2554), d) - } - } - default: - z.DecStructFieldNotFound(-1, yys2553) - } // end switch yys2553 - } // end for yyj2553 - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x *LoadBalancerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yyj2556 int - var yyb2556 bool - var yyhl2556 bool = l >= 0 - yyj2556++ - if yyhl2556 { - yyb2556 = yyj2556 > l - } else { - yyb2556 = r.CheckBreak() - } - if yyb2556 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Ingress = nil - } else { - yyv2557 := &x.Ingress - yym2558 := z.DecBinary() - _ = yym2558 - if false { - } else { - h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2557), d) - } - } - for { - yyj2556++ - if yyhl2556 { - yyb2556 = yyj2556 > l - } else { - yyb2556 = r.CheckBreak() - } - if yyb2556 { - break - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2556-1, "") - } - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x *LoadBalancerIngress) CodecEncodeSelf(e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - if x == nil { - r.EncodeNil() - } else { - yym2559 := z.EncBinary() - _ = yym2559 - if false { - } else if z.HasExtensions() && z.EncExt(x) { - } else { - yysep2560 := !z.EncBinary() - yy2arr2560 := z.EncBasicHandle().StructToArray - var yyq2560 [2]bool - _, _, _ = yysep2560, yyq2560, yy2arr2560 - const yyr2560 bool = false - yyq2560[0] = x.IP != "" - yyq2560[1] = x.Hostname != "" - var yynn2560 int - if yyr2560 || yy2arr2560 { - r.EncodeArrayStart(2) - } else { - yynn2560 = 0 - for _, b := range yyq2560 { - if b { - yynn2560++ - } - } - r.EncodeMapStart(yynn2560) - yynn2560 = 0 - } - if yyr2560 || yy2arr2560 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2560[0] { - yym2562 := z.EncBinary() - _ = yym2562 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.IP)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq2560[0] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("ip")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2563 := z.EncBinary() - _ = yym2563 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.IP)) - } - } - } - if yyr2560 || yy2arr2560 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2560[1] { - yym2565 := z.EncBinary() - _ = yym2565 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Hostname)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq2560[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("hostname")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2566 := z.EncBinary() - _ = yym2566 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Hostname)) - } - } - } - if yyr2560 || yy2arr2560 { - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - z.EncSendContainerState(codecSelfer_containerMapEnd1234) - } - } - } -} - -func (x *LoadBalancerIngress) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r @@ -33621,7 +33617,7 @@ func (x *LoadBalancerIngress) CodecDecodeSelf(d *codec1978.Decoder) { } } -func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { +func (x *LoadBalancerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r @@ -33643,17 +33639,17 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder yys2569 := string(yys2569Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) switch yys2569 { - case "ip": + case "ingress": if r.TryDecodeAsNil() { - x.IP = "" + x.Ingress = nil } else { - x.IP = string(r.DecodeString()) - } - case "hostname": - if r.TryDecodeAsNil() { - x.Hostname = "" - } else { - x.Hostname = string(r.DecodeString()) + yyv2570 := &x.Ingress + yym2571 := z.DecBinary() + _ = yym2571 + if false { + } else { + h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2570), d) + } } default: z.DecStructFieldNotFound(-1, yys2569) @@ -33662,7 +33658,7 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder z.DecSendContainerState(codecSelfer_containerMapEnd1234) } -func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { +func (x *LoadBalancerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r @@ -33681,25 +33677,15 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decod } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.IP = "" + x.Ingress = nil } else { - x.IP = string(r.DecodeString()) - } - yyj2572++ - if yyhl2572 { - yyb2572 = yyj2572 > l - } else { - yyb2572 = r.CheckBreak() - } - if yyb2572 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Hostname = "" - } else { - x.Hostname = string(r.DecodeString()) + yyv2573 := &x.Ingress + yym2574 := z.DecBinary() + _ = yym2574 + if false { + } else { + h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2573), d) + } } for { yyj2572++ @@ -33717,7 +33703,7 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decod z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } -func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) { +func (x *LoadBalancerIngress) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -33731,20 +33717,16 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) { } else { yysep2576 := !z.EncBinary() yy2arr2576 := z.EncBasicHandle().StructToArray - var yyq2576 [9]bool + var yyq2576 [2]bool _, _, _ = yysep2576, yyq2576, yy2arr2576 const yyr2576 bool = false - yyq2576[0] = x.Type != "" - yyq2576[3] = x.ClusterIP != "" - yyq2576[5] = len(x.ExternalIPs) != 0 - yyq2576[6] = x.LoadBalancerIP != "" - yyq2576[7] = x.SessionAffinity != "" - yyq2576[8] = len(x.LoadBalancerSourceRanges) != 0 + yyq2576[0] = x.IP != "" + yyq2576[1] = x.Hostname != "" var yynn2576 int if yyr2576 || yy2arr2576 { - r.EncodeArrayStart(9) + r.EncodeArrayStart(2) } else { - yynn2576 = 3 + yynn2576 = 0 for _, b := range yyq2576 { if b { yynn2576++ @@ -33756,219 +33738,50 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) { if yyr2576 || yy2arr2576 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if yyq2576[0] { - x.Type.CodecEncodeSelf(e) + yym2578 := z.EncBinary() + _ = yym2578 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.IP)) + } } else { r.EncodeString(codecSelferC_UTF81234, "") } } else { if yyq2576[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("type")) + r.EncodeString(codecSelferC_UTF81234, string("ip")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - x.Type.CodecEncodeSelf(e) - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if x.Ports == nil { - r.EncodeNil() - } else { yym2579 := z.EncBinary() _ = yym2579 if false { } else { - h.encSliceServicePort(([]ServicePort)(x.Ports), e) - } - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("ports")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Ports == nil { - r.EncodeNil() - } else { - yym2580 := z.EncBinary() - _ = yym2580 - if false { - } else { - h.encSliceServicePort(([]ServicePort)(x.Ports), e) + r.EncodeString(codecSelferC_UTF81234, string(x.IP)) } } } if yyr2576 || yy2arr2576 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if x.Selector == nil { - r.EncodeNil() + if yyq2576[1] { + yym2581 := z.EncBinary() + _ = yym2581 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Hostname)) + } } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2576[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hostname")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) yym2582 := z.EncBinary() _ = yym2582 if false { } else { - z.F.EncMapStringStringV(x.Selector, false, e) - } - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("selector")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Selector == nil { - r.EncodeNil() - } else { - yym2583 := z.EncBinary() - _ = yym2583 - if false { - } else { - z.F.EncMapStringStringV(x.Selector, false, e) - } - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2576[3] { - yym2585 := z.EncBinary() - _ = yym2585 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.ClusterIP)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq2576[3] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("clusterIP")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2586 := z.EncBinary() - _ = yym2586 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.ClusterIP)) - } - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2588 := z.EncBinary() - _ = yym2588 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.ExternalName)) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("ExternalName")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2589 := z.EncBinary() - _ = yym2589 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.ExternalName)) - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2576[5] { - if x.ExternalIPs == nil { - r.EncodeNil() - } else { - yym2591 := z.EncBinary() - _ = yym2591 - if false { - } else { - z.F.EncSliceStringV(x.ExternalIPs, false, e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq2576[5] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("externalIPs")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.ExternalIPs == nil { - r.EncodeNil() - } else { - yym2592 := z.EncBinary() - _ = yym2592 - if false { - } else { - z.F.EncSliceStringV(x.ExternalIPs, false, e) - } - } - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2576[6] { - yym2594 := z.EncBinary() - _ = yym2594 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.LoadBalancerIP)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq2576[6] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("loadBalancerIP")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2595 := z.EncBinary() - _ = yym2595 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.LoadBalancerIP)) - } - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2576[7] { - x.SessionAffinity.CodecEncodeSelf(e) - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq2576[7] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("sessionAffinity")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - x.SessionAffinity.CodecEncodeSelf(e) - } - } - if yyr2576 || yy2arr2576 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2576[8] { - if x.LoadBalancerSourceRanges == nil { - r.EncodeNil() - } else { - yym2598 := z.EncBinary() - _ = yym2598 - if false { - } else { - z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq2576[8] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("loadBalancerSourceRanges")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.LoadBalancerSourceRanges == nil { - r.EncodeNil() - } else { - yym2599 := z.EncBinary() - _ = yym2599 - if false { - } else { - z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e) - } + r.EncodeString(codecSelferC_UTF81234, string(x.Hostname)) } } } @@ -33981,29 +33794,419 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) { } } +func (x *LoadBalancerIngress) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym2583 := z.DecBinary() + _ = yym2583 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2584 := r.ContainerType() + if yyct2584 == codecSelferValueTypeMap1234 { + yyl2584 := r.ReadMapStart() + if yyl2584 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl2584, d) + } + } else if yyct2584 == codecSelferValueTypeArray1234 { + yyl2584 := r.ReadArrayStart() + if yyl2584 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl2584, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys2585Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2585Slc + var yyhl2585 bool = l >= 0 + for yyj2585 := 0; ; yyj2585++ { + if yyhl2585 { + if yyj2585 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys2585Slc = r.DecodeBytes(yys2585Slc, true, true) + yys2585 := string(yys2585Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys2585 { + case "ip": + if r.TryDecodeAsNil() { + x.IP = "" + } else { + x.IP = string(r.DecodeString()) + } + case "hostname": + if r.TryDecodeAsNil() { + x.Hostname = "" + } else { + x.Hostname = string(r.DecodeString()) + } + default: + z.DecStructFieldNotFound(-1, yys2585) + } // end switch yys2585 + } // end for yyj2585 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj2588 int + var yyb2588 bool + var yyhl2588 bool = l >= 0 + yyj2588++ + if yyhl2588 { + yyb2588 = yyj2588 > l + } else { + yyb2588 = r.CheckBreak() + } + if yyb2588 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.IP = "" + } else { + x.IP = string(r.DecodeString()) + } + yyj2588++ + if yyhl2588 { + yyb2588 = yyj2588 > l + } else { + yyb2588 = r.CheckBreak() + } + if yyb2588 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Hostname = "" + } else { + x.Hostname = string(r.DecodeString()) + } + for { + yyj2588++ + if yyhl2588 { + yyb2588 = yyj2588 > l + } else { + yyb2588 = r.CheckBreak() + } + if yyb2588 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj2588-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym2591 := z.EncBinary() + _ = yym2591 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2592 := !z.EncBinary() + yy2arr2592 := z.EncBasicHandle().StructToArray + var yyq2592 [9]bool + _, _, _ = yysep2592, yyq2592, yy2arr2592 + const yyr2592 bool = false + yyq2592[0] = x.Type != "" + yyq2592[3] = x.ClusterIP != "" + yyq2592[5] = len(x.ExternalIPs) != 0 + yyq2592[6] = x.LoadBalancerIP != "" + yyq2592[7] = x.SessionAffinity != "" + yyq2592[8] = len(x.LoadBalancerSourceRanges) != 0 + var yynn2592 int + if yyr2592 || yy2arr2592 { + r.EncodeArrayStart(9) + } else { + yynn2592 = 3 + for _, b := range yyq2592 { + if b { + yynn2592++ + } + } + r.EncodeMapStart(yynn2592) + yynn2592 = 0 + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2592[0] { + x.Type.CodecEncodeSelf(e) + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2592[0] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("type")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + x.Type.CodecEncodeSelf(e) + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if x.Ports == nil { + r.EncodeNil() + } else { + yym2595 := z.EncBinary() + _ = yym2595 + if false { + } else { + h.encSliceServicePort(([]ServicePort)(x.Ports), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("ports")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Ports == nil { + r.EncodeNil() + } else { + yym2596 := z.EncBinary() + _ = yym2596 + if false { + } else { + h.encSliceServicePort(([]ServicePort)(x.Ports), e) + } + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if x.Selector == nil { + r.EncodeNil() + } else { + yym2598 := z.EncBinary() + _ = yym2598 + if false { + } else { + z.F.EncMapStringStringV(x.Selector, false, e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("selector")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Selector == nil { + r.EncodeNil() + } else { + yym2599 := z.EncBinary() + _ = yym2599 + if false { + } else { + z.F.EncMapStringStringV(x.Selector, false, e) + } + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2592[3] { + yym2601 := z.EncBinary() + _ = yym2601 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterIP)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2592[3] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("clusterIP")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym2602 := z.EncBinary() + _ = yym2602 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ClusterIP)) + } + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym2604 := z.EncBinary() + _ = yym2604 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ExternalName)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("ExternalName")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym2605 := z.EncBinary() + _ = yym2605 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ExternalName)) + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2592[5] { + if x.ExternalIPs == nil { + r.EncodeNil() + } else { + yym2607 := z.EncBinary() + _ = yym2607 + if false { + } else { + z.F.EncSliceStringV(x.ExternalIPs, false, e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq2592[5] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("externalIPs")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.ExternalIPs == nil { + r.EncodeNil() + } else { + yym2608 := z.EncBinary() + _ = yym2608 + if false { + } else { + z.F.EncSliceStringV(x.ExternalIPs, false, e) + } + } + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2592[6] { + yym2610 := z.EncBinary() + _ = yym2610 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.LoadBalancerIP)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2592[6] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("loadBalancerIP")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym2611 := z.EncBinary() + _ = yym2611 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.LoadBalancerIP)) + } + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2592[7] { + x.SessionAffinity.CodecEncodeSelf(e) + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq2592[7] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("sessionAffinity")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + x.SessionAffinity.CodecEncodeSelf(e) + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq2592[8] { + if x.LoadBalancerSourceRanges == nil { + r.EncodeNil() + } else { + yym2614 := z.EncBinary() + _ = yym2614 + if false { + } else { + z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq2592[8] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("loadBalancerSourceRanges")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.LoadBalancerSourceRanges == nil { + r.EncodeNil() + } else { + yym2615 := z.EncBinary() + _ = yym2615 + if false { + } else { + z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e) + } + } + } + } + if yyr2592 || yy2arr2592 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + func (x *ServiceSpec) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2600 := z.DecBinary() - _ = yym2600 + yym2616 := z.DecBinary() + _ = yym2616 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2601 := r.ContainerType() - if yyct2601 == codecSelferValueTypeMap1234 { - yyl2601 := r.ReadMapStart() - if yyl2601 == 0 { + yyct2617 := r.ContainerType() + if yyct2617 == codecSelferValueTypeMap1234 { + yyl2617 := r.ReadMapStart() + if yyl2617 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2601, d) + x.codecDecodeSelfFromMap(yyl2617, d) } - } else if yyct2601 == codecSelferValueTypeArray1234 { - yyl2601 := r.ReadArrayStart() - if yyl2601 == 0 { + } else if yyct2617 == codecSelferValueTypeArray1234 { + yyl2617 := r.ReadArrayStart() + if yyl2617 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2601, d) + x.codecDecodeSelfFromArray(yyl2617, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -34015,12 +34218,12 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2602Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2602Slc - var yyhl2602 bool = l >= 0 - for yyj2602 := 0; ; yyj2602++ { - if yyhl2602 { - if yyj2602 >= l { + var yys2618Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2618Slc + var yyhl2618 bool = l >= 0 + for yyj2618 := 0; ; yyj2618++ { + if yyhl2618 { + if yyj2618 >= l { break } } else { @@ -34029,10 +34232,10 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2602Slc = r.DecodeBytes(yys2602Slc, true, true) - yys2602 := string(yys2602Slc) + yys2618Slc = r.DecodeBytes(yys2618Slc, true, true) + yys2618 := string(yys2618Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2602 { + switch yys2618 { case "type": if r.TryDecodeAsNil() { x.Type = "" @@ -34043,24 +34246,24 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Ports = nil } else { - yyv2604 := &x.Ports - yym2605 := z.DecBinary() - _ = yym2605 + yyv2620 := &x.Ports + yym2621 := z.DecBinary() + _ = yym2621 if false { } else { - h.decSliceServicePort((*[]ServicePort)(yyv2604), d) + h.decSliceServicePort((*[]ServicePort)(yyv2620), d) } } case "selector": if r.TryDecodeAsNil() { x.Selector = nil } else { - yyv2606 := &x.Selector - yym2607 := z.DecBinary() - _ = yym2607 + yyv2622 := &x.Selector + yym2623 := z.DecBinary() + _ = yym2623 if false { } else { - z.F.DecMapStringStringX(yyv2606, false, d) + z.F.DecMapStringStringX(yyv2622, false, d) } } case "clusterIP": @@ -34079,12 +34282,12 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ExternalIPs = nil } else { - yyv2610 := &x.ExternalIPs - yym2611 := z.DecBinary() - _ = yym2611 + yyv2626 := &x.ExternalIPs + yym2627 := z.DecBinary() + _ = yym2627 if false { } else { - z.F.DecSliceStringX(yyv2610, false, d) + z.F.DecSliceStringX(yyv2626, false, d) } } case "loadBalancerIP": @@ -34103,18 +34306,18 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LoadBalancerSourceRanges = nil } else { - yyv2614 := &x.LoadBalancerSourceRanges - yym2615 := z.DecBinary() - _ = yym2615 + yyv2630 := &x.LoadBalancerSourceRanges + yym2631 := z.DecBinary() + _ = yym2631 if false { } else { - z.F.DecSliceStringX(yyv2614, false, d) + z.F.DecSliceStringX(yyv2630, false, d) } } default: - z.DecStructFieldNotFound(-1, yys2602) - } // end switch yys2602 - } // end for yyj2602 + z.DecStructFieldNotFound(-1, yys2618) + } // end switch yys2618 + } // end for yyj2618 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -34122,16 +34325,16 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2616 int - var yyb2616 bool - var yyhl2616 bool = l >= 0 - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + var yyj2632 int + var yyb2632 bool + var yyhl2632 bool = l >= 0 + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34141,13 +34344,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Type = ServiceType(r.DecodeString()) } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34155,21 +34358,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Ports = nil } else { - yyv2618 := &x.Ports - yym2619 := z.DecBinary() - _ = yym2619 + yyv2634 := &x.Ports + yym2635 := z.DecBinary() + _ = yym2635 if false { } else { - h.decSliceServicePort((*[]ServicePort)(yyv2618), d) + h.decSliceServicePort((*[]ServicePort)(yyv2634), d) } } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34177,21 +34380,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Selector = nil } else { - yyv2620 := &x.Selector - yym2621 := z.DecBinary() - _ = yym2621 + yyv2636 := &x.Selector + yym2637 := z.DecBinary() + _ = yym2637 if false { } else { - z.F.DecMapStringStringX(yyv2620, false, d) + z.F.DecMapStringStringX(yyv2636, false, d) } } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34201,13 +34404,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.ClusterIP = string(r.DecodeString()) } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34217,13 +34420,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.ExternalName = string(r.DecodeString()) } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34231,21 +34434,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ExternalIPs = nil } else { - yyv2624 := &x.ExternalIPs - yym2625 := z.DecBinary() - _ = yym2625 + yyv2640 := &x.ExternalIPs + yym2641 := z.DecBinary() + _ = yym2641 if false { } else { - z.F.DecSliceStringX(yyv2624, false, d) + z.F.DecSliceStringX(yyv2640, false, d) } } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34255,13 +34458,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.LoadBalancerIP = string(r.DecodeString()) } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34271,13 +34474,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.SessionAffinity = ServiceAffinity(r.DecodeString()) } - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34285,26 +34488,26 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LoadBalancerSourceRanges = nil } else { - yyv2628 := &x.LoadBalancerSourceRanges - yym2629 := z.DecBinary() - _ = yym2629 + yyv2644 := &x.LoadBalancerSourceRanges + yym2645 := z.DecBinary() + _ = yym2645 if false { } else { - z.F.DecSliceStringX(yyv2628, false, d) + z.F.DecSliceStringX(yyv2644, false, d) } } for { - yyj2616++ - if yyhl2616 { - yyb2616 = yyj2616 > l + yyj2632++ + if yyhl2632 { + yyb2632 = yyj2632 > l } else { - yyb2616 = r.CheckBreak() + yyb2632 = r.CheckBreak() } - if yyb2616 { + if yyb2632 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2616-1, "") + z.DecStructFieldNotFound(yyj2632-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -34316,33 +34519,33 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2630 := z.EncBinary() - _ = yym2630 + yym2646 := z.EncBinary() + _ = yym2646 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2631 := !z.EncBinary() - yy2arr2631 := z.EncBasicHandle().StructToArray - var yyq2631 [5]bool - _, _, _ = yysep2631, yyq2631, yy2arr2631 - const yyr2631 bool = false - var yynn2631 int - if yyr2631 || yy2arr2631 { + yysep2647 := !z.EncBinary() + yy2arr2647 := z.EncBasicHandle().StructToArray + var yyq2647 [5]bool + _, _, _ = yysep2647, yyq2647, yy2arr2647 + const yyr2647 bool = false + var yynn2647 int + if yyr2647 || yy2arr2647 { r.EncodeArrayStart(5) } else { - yynn2631 = 5 - for _, b := range yyq2631 { + yynn2647 = 5 + for _, b := range yyq2647 { if b { - yynn2631++ + yynn2647++ } } - r.EncodeMapStart(yynn2631) - yynn2631 = 0 + r.EncodeMapStart(yynn2647) + yynn2647 = 0 } - if yyr2631 || yy2arr2631 { + if yyr2647 || yy2arr2647 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2633 := z.EncBinary() - _ = yym2633 + yym2649 := z.EncBinary() + _ = yym2649 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) @@ -34351,14 +34554,14 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("name")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2634 := z.EncBinary() - _ = yym2634 + yym2650 := z.EncBinary() + _ = yym2650 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) } } - if yyr2631 || yy2arr2631 { + if yyr2647 || yy2arr2647 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Protocol.CodecEncodeSelf(e) } else { @@ -34367,10 +34570,10 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Protocol.CodecEncodeSelf(e) } - if yyr2631 || yy2arr2631 { + if yyr2647 || yy2arr2647 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2637 := z.EncBinary() - _ = yym2637 + yym2653 := z.EncBinary() + _ = yym2653 if false { } else { r.EncodeInt(int64(x.Port)) @@ -34379,44 +34582,44 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("port")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2638 := z.EncBinary() - _ = yym2638 + yym2654 := z.EncBinary() + _ = yym2654 if false { } else { r.EncodeInt(int64(x.Port)) } } - if yyr2631 || yy2arr2631 { + if yyr2647 || yy2arr2647 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy2640 := &x.TargetPort - yym2641 := z.EncBinary() - _ = yym2641 + yy2656 := &x.TargetPort + yym2657 := z.EncBinary() + _ = yym2657 if false { - } else if z.HasExtensions() && z.EncExt(yy2640) { - } else if !yym2641 && z.IsJSONHandle() { - z.EncJSONMarshal(yy2640) + } else if z.HasExtensions() && z.EncExt(yy2656) { + } else if !yym2657 && z.IsJSONHandle() { + z.EncJSONMarshal(yy2656) } else { - z.EncFallback(yy2640) + z.EncFallback(yy2656) } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("targetPort")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2642 := &x.TargetPort - yym2643 := z.EncBinary() - _ = yym2643 + yy2658 := &x.TargetPort + yym2659 := z.EncBinary() + _ = yym2659 if false { - } else if z.HasExtensions() && z.EncExt(yy2642) { - } else if !yym2643 && z.IsJSONHandle() { - z.EncJSONMarshal(yy2642) + } else if z.HasExtensions() && z.EncExt(yy2658) { + } else if !yym2659 && z.IsJSONHandle() { + z.EncJSONMarshal(yy2658) } else { - z.EncFallback(yy2642) + z.EncFallback(yy2658) } } - if yyr2631 || yy2arr2631 { + if yyr2647 || yy2arr2647 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2645 := z.EncBinary() - _ = yym2645 + yym2661 := z.EncBinary() + _ = yym2661 if false { } else { r.EncodeInt(int64(x.NodePort)) @@ -34425,14 +34628,14 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("nodePort")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2646 := z.EncBinary() - _ = yym2646 + yym2662 := z.EncBinary() + _ = yym2662 if false { } else { r.EncodeInt(int64(x.NodePort)) } } - if yyr2631 || yy2arr2631 { + if yyr2647 || yy2arr2647 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -34445,25 +34648,25 @@ func (x *ServicePort) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2647 := z.DecBinary() - _ = yym2647 + yym2663 := z.DecBinary() + _ = yym2663 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2648 := r.ContainerType() - if yyct2648 == codecSelferValueTypeMap1234 { - yyl2648 := r.ReadMapStart() - if yyl2648 == 0 { + yyct2664 := r.ContainerType() + if yyct2664 == codecSelferValueTypeMap1234 { + yyl2664 := r.ReadMapStart() + if yyl2664 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2648, d) + x.codecDecodeSelfFromMap(yyl2664, d) } - } else if yyct2648 == codecSelferValueTypeArray1234 { - yyl2648 := r.ReadArrayStart() - if yyl2648 == 0 { + } else if yyct2664 == codecSelferValueTypeArray1234 { + yyl2664 := r.ReadArrayStart() + if yyl2664 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2648, d) + x.codecDecodeSelfFromArray(yyl2664, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -34475,12 +34678,12 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2649Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2649Slc - var yyhl2649 bool = l >= 0 - for yyj2649 := 0; ; yyj2649++ { - if yyhl2649 { - if yyj2649 >= l { + var yys2665Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2665Slc + var yyhl2665 bool = l >= 0 + for yyj2665 := 0; ; yyj2665++ { + if yyhl2665 { + if yyj2665 >= l { break } } else { @@ -34489,10 +34692,10 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2649Slc = r.DecodeBytes(yys2649Slc, true, true) - yys2649 := string(yys2649Slc) + yys2665Slc = r.DecodeBytes(yys2665Slc, true, true) + yys2665 := string(yys2665Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2649 { + switch yys2665 { case "name": if r.TryDecodeAsNil() { x.Name = "" @@ -34515,15 +34718,15 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.TargetPort = pkg4_intstr.IntOrString{} } else { - yyv2653 := &x.TargetPort - yym2654 := z.DecBinary() - _ = yym2654 + yyv2669 := &x.TargetPort + yym2670 := z.DecBinary() + _ = yym2670 if false { - } else if z.HasExtensions() && z.DecExt(yyv2653) { - } else if !yym2654 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv2653) + } else if z.HasExtensions() && z.DecExt(yyv2669) { + } else if !yym2670 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv2669) } else { - z.DecFallback(yyv2653, false) + z.DecFallback(yyv2669, false) } } case "nodePort": @@ -34533,9 +34736,9 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.NodePort = int32(r.DecodeInt(32)) } default: - z.DecStructFieldNotFound(-1, yys2649) - } // end switch yys2649 - } // end for yyj2649 + z.DecStructFieldNotFound(-1, yys2665) + } // end switch yys2665 + } // end for yyj2665 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -34543,16 +34746,16 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2656 int - var yyb2656 bool - var yyhl2656 bool = l >= 0 - yyj2656++ - if yyhl2656 { - yyb2656 = yyj2656 > l + var yyj2672 int + var yyb2672 bool + var yyhl2672 bool = l >= 0 + yyj2672++ + if yyhl2672 { + yyb2672 = yyj2672 > l } else { - yyb2656 = r.CheckBreak() + yyb2672 = r.CheckBreak() } - if yyb2656 { + if yyb2672 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34562,13 +34765,13 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Name = string(r.DecodeString()) } - yyj2656++ - if yyhl2656 { - yyb2656 = yyj2656 > l + yyj2672++ + if yyhl2672 { + yyb2672 = yyj2672 > l } else { - yyb2656 = r.CheckBreak() + yyb2672 = r.CheckBreak() } - if yyb2656 { + if yyb2672 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34578,13 +34781,13 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Protocol = Protocol(r.DecodeString()) } - yyj2656++ - if yyhl2656 { - yyb2656 = yyj2656 > l + yyj2672++ + if yyhl2672 { + yyb2672 = yyj2672 > l } else { - yyb2656 = r.CheckBreak() + yyb2672 = r.CheckBreak() } - if yyb2656 { + if yyb2672 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34594,13 +34797,13 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Port = int32(r.DecodeInt(32)) } - yyj2656++ - if yyhl2656 { - yyb2656 = yyj2656 > l + yyj2672++ + if yyhl2672 { + yyb2672 = yyj2672 > l } else { - yyb2656 = r.CheckBreak() + yyb2672 = r.CheckBreak() } - if yyb2656 { + if yyb2672 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34608,24 +34811,24 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.TargetPort = pkg4_intstr.IntOrString{} } else { - yyv2660 := &x.TargetPort - yym2661 := z.DecBinary() - _ = yym2661 + yyv2676 := &x.TargetPort + yym2677 := z.DecBinary() + _ = yym2677 if false { - } else if z.HasExtensions() && z.DecExt(yyv2660) { - } else if !yym2661 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv2660) + } else if z.HasExtensions() && z.DecExt(yyv2676) { + } else if !yym2677 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv2676) } else { - z.DecFallback(yyv2660, false) + z.DecFallback(yyv2676, false) } } - yyj2656++ - if yyhl2656 { - yyb2656 = yyj2656 > l + yyj2672++ + if yyhl2672 { + yyb2672 = yyj2672 > l } else { - yyb2656 = r.CheckBreak() + yyb2672 = r.CheckBreak() } - if yyb2656 { + if yyb2672 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34636,17 +34839,17 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.NodePort = int32(r.DecodeInt(32)) } for { - yyj2656++ - if yyhl2656 { - yyb2656 = yyj2656 > l + yyj2672++ + if yyhl2672 { + yyb2672 = yyj2672 > l } else { - yyb2656 = r.CheckBreak() + yyb2672 = r.CheckBreak() } - if yyb2656 { + if yyb2672 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2656-1, "") + z.DecStructFieldNotFound(yyj2672-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -34658,39 +34861,39 @@ func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2663 := z.EncBinary() - _ = yym2663 + yym2679 := z.EncBinary() + _ = yym2679 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2664 := !z.EncBinary() - yy2arr2664 := z.EncBasicHandle().StructToArray - var yyq2664 [5]bool - _, _, _ = yysep2664, yyq2664, yy2arr2664 - const yyr2664 bool = false - yyq2664[0] = x.Kind != "" - yyq2664[1] = x.APIVersion != "" - yyq2664[2] = true - yyq2664[3] = true - yyq2664[4] = true - var yynn2664 int - if yyr2664 || yy2arr2664 { + yysep2680 := !z.EncBinary() + yy2arr2680 := z.EncBasicHandle().StructToArray + var yyq2680 [5]bool + _, _, _ = yysep2680, yyq2680, yy2arr2680 + const yyr2680 bool = false + yyq2680[0] = x.Kind != "" + yyq2680[1] = x.APIVersion != "" + yyq2680[2] = true + yyq2680[3] = true + yyq2680[4] = true + var yynn2680 int + if yyr2680 || yy2arr2680 { r.EncodeArrayStart(5) } else { - yynn2664 = 0 - for _, b := range yyq2664 { + yynn2680 = 0 + for _, b := range yyq2680 { if b { - yynn2664++ + yynn2680++ } } - r.EncodeMapStart(yynn2664) - yynn2664 = 0 + r.EncodeMapStart(yynn2680) + yynn2680 = 0 } - if yyr2664 || yy2arr2664 { + if yyr2680 || yy2arr2680 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2664[0] { - yym2666 := z.EncBinary() - _ = yym2666 + if yyq2680[0] { + yym2682 := z.EncBinary() + _ = yym2682 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -34699,23 +34902,23 @@ func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2664[0] { + if yyq2680[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2667 := z.EncBinary() - _ = yym2667 + yym2683 := z.EncBinary() + _ = yym2683 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2664 || yy2arr2664 { + if yyr2680 || yy2arr2680 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2664[1] { - yym2669 := z.EncBinary() - _ = yym2669 + if yyq2680[1] { + yym2685 := z.EncBinary() + _ = yym2685 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -34724,70 +34927,70 @@ func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2664[1] { + if yyq2680[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2670 := z.EncBinary() - _ = yym2670 + yym2686 := z.EncBinary() + _ = yym2686 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2664 || yy2arr2664 { + if yyr2680 || yy2arr2680 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2664[2] { - yy2672 := &x.ObjectMeta - yy2672.CodecEncodeSelf(e) + if yyq2680[2] { + yy2688 := &x.ObjectMeta + yy2688.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2664[2] { + if yyq2680[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2673 := &x.ObjectMeta - yy2673.CodecEncodeSelf(e) + yy2689 := &x.ObjectMeta + yy2689.CodecEncodeSelf(e) } } - if yyr2664 || yy2arr2664 { + if yyr2680 || yy2arr2680 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2664[3] { - yy2675 := &x.Spec - yy2675.CodecEncodeSelf(e) + if yyq2680[3] { + yy2691 := &x.Spec + yy2691.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2664[3] { + if yyq2680[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2676 := &x.Spec - yy2676.CodecEncodeSelf(e) + yy2692 := &x.Spec + yy2692.CodecEncodeSelf(e) } } - if yyr2664 || yy2arr2664 { + if yyr2680 || yy2arr2680 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2664[4] { - yy2678 := &x.Status - yy2678.CodecEncodeSelf(e) + if yyq2680[4] { + yy2694 := &x.Status + yy2694.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2664[4] { + if yyq2680[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2679 := &x.Status - yy2679.CodecEncodeSelf(e) + yy2695 := &x.Status + yy2695.CodecEncodeSelf(e) } } - if yyr2664 || yy2arr2664 { + if yyr2680 || yy2arr2680 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -34800,25 +35003,25 @@ func (x *Service) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2680 := z.DecBinary() - _ = yym2680 + yym2696 := z.DecBinary() + _ = yym2696 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2681 := r.ContainerType() - if yyct2681 == codecSelferValueTypeMap1234 { - yyl2681 := r.ReadMapStart() - if yyl2681 == 0 { + yyct2697 := r.ContainerType() + if yyct2697 == codecSelferValueTypeMap1234 { + yyl2697 := r.ReadMapStart() + if yyl2697 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2681, d) + x.codecDecodeSelfFromMap(yyl2697, d) } - } else if yyct2681 == codecSelferValueTypeArray1234 { - yyl2681 := r.ReadArrayStart() - if yyl2681 == 0 { + } else if yyct2697 == codecSelferValueTypeArray1234 { + yyl2697 := r.ReadArrayStart() + if yyl2697 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2681, d) + x.codecDecodeSelfFromArray(yyl2697, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -34830,12 +35033,12 @@ func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2682Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2682Slc - var yyhl2682 bool = l >= 0 - for yyj2682 := 0; ; yyj2682++ { - if yyhl2682 { - if yyj2682 >= l { + var yys2698Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2698Slc + var yyhl2698 bool = l >= 0 + for yyj2698 := 0; ; yyj2698++ { + if yyhl2698 { + if yyj2698 >= l { break } } else { @@ -34844,10 +35047,10 @@ func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2682Slc = r.DecodeBytes(yys2682Slc, true, true) - yys2682 := string(yys2682Slc) + yys2698Slc = r.DecodeBytes(yys2698Slc, true, true) + yys2698 := string(yys2698Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2682 { + switch yys2698 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -34864,27 +35067,27 @@ func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2685 := &x.ObjectMeta - yyv2685.CodecDecodeSelf(d) + yyv2701 := &x.ObjectMeta + yyv2701.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = ServiceSpec{} } else { - yyv2686 := &x.Spec - yyv2686.CodecDecodeSelf(d) + yyv2702 := &x.Spec + yyv2702.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = ServiceStatus{} } else { - yyv2687 := &x.Status - yyv2687.CodecDecodeSelf(d) + yyv2703 := &x.Status + yyv2703.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2682) - } // end switch yys2682 - } // end for yyj2682 + z.DecStructFieldNotFound(-1, yys2698) + } // end switch yys2698 + } // end for yyj2698 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -34892,16 +35095,16 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2688 int - var yyb2688 bool - var yyhl2688 bool = l >= 0 - yyj2688++ - if yyhl2688 { - yyb2688 = yyj2688 > l + var yyj2704 int + var yyb2704 bool + var yyhl2704 bool = l >= 0 + yyj2704++ + if yyhl2704 { + yyb2704 = yyj2704 > l } else { - yyb2688 = r.CheckBreak() + yyb2704 = r.CheckBreak() } - if yyb2688 { + if yyb2704 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34911,13 +35114,13 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2688++ - if yyhl2688 { - yyb2688 = yyj2688 > l + yyj2704++ + if yyhl2704 { + yyb2704 = yyj2704 > l } else { - yyb2688 = r.CheckBreak() + yyb2704 = r.CheckBreak() } - if yyb2688 { + if yyb2704 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34927,13 +35130,13 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2688++ - if yyhl2688 { - yyb2688 = yyj2688 > l + yyj2704++ + if yyhl2704 { + yyb2704 = yyj2704 > l } else { - yyb2688 = r.CheckBreak() + yyb2704 = r.CheckBreak() } - if yyb2688 { + if yyb2704 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34941,16 +35144,16 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2691 := &x.ObjectMeta - yyv2691.CodecDecodeSelf(d) + yyv2707 := &x.ObjectMeta + yyv2707.CodecDecodeSelf(d) } - yyj2688++ - if yyhl2688 { - yyb2688 = yyj2688 > l + yyj2704++ + if yyhl2704 { + yyb2704 = yyj2704 > l } else { - yyb2688 = r.CheckBreak() + yyb2704 = r.CheckBreak() } - if yyb2688 { + if yyb2704 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34958,16 +35161,16 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Spec = ServiceSpec{} } else { - yyv2692 := &x.Spec - yyv2692.CodecDecodeSelf(d) + yyv2708 := &x.Spec + yyv2708.CodecDecodeSelf(d) } - yyj2688++ - if yyhl2688 { - yyb2688 = yyj2688 > l + yyj2704++ + if yyhl2704 { + yyb2704 = yyj2704 > l } else { - yyb2688 = r.CheckBreak() + yyb2704 = r.CheckBreak() } - if yyb2688 { + if yyb2704 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -34975,21 +35178,21 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Status = ServiceStatus{} } else { - yyv2693 := &x.Status - yyv2693.CodecDecodeSelf(d) + yyv2709 := &x.Status + yyv2709.CodecDecodeSelf(d) } for { - yyj2688++ - if yyhl2688 { - yyb2688 = yyj2688 > l + yyj2704++ + if yyhl2704 { + yyb2704 = yyj2704 > l } else { - yyb2688 = r.CheckBreak() + yyb2704 = r.CheckBreak() } - if yyb2688 { + if yyb2704 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2688-1, "") + z.DecStructFieldNotFound(yyj2704-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -35001,38 +35204,38 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2694 := z.EncBinary() - _ = yym2694 + yym2710 := z.EncBinary() + _ = yym2710 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2695 := !z.EncBinary() - yy2arr2695 := z.EncBasicHandle().StructToArray - var yyq2695 [5]bool - _, _, _ = yysep2695, yyq2695, yy2arr2695 - const yyr2695 bool = false - yyq2695[0] = x.Kind != "" - yyq2695[1] = x.APIVersion != "" - yyq2695[2] = true - yyq2695[4] = len(x.ImagePullSecrets) != 0 - var yynn2695 int - if yyr2695 || yy2arr2695 { + yysep2711 := !z.EncBinary() + yy2arr2711 := z.EncBasicHandle().StructToArray + var yyq2711 [5]bool + _, _, _ = yysep2711, yyq2711, yy2arr2711 + const yyr2711 bool = false + yyq2711[0] = x.Kind != "" + yyq2711[1] = x.APIVersion != "" + yyq2711[2] = true + yyq2711[4] = len(x.ImagePullSecrets) != 0 + var yynn2711 int + if yyr2711 || yy2arr2711 { r.EncodeArrayStart(5) } else { - yynn2695 = 1 - for _, b := range yyq2695 { + yynn2711 = 1 + for _, b := range yyq2711 { if b { - yynn2695++ + yynn2711++ } } - r.EncodeMapStart(yynn2695) - yynn2695 = 0 + r.EncodeMapStart(yynn2711) + yynn2711 = 0 } - if yyr2695 || yy2arr2695 { + if yyr2711 || yy2arr2711 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2695[0] { - yym2697 := z.EncBinary() - _ = yym2697 + if yyq2711[0] { + yym2713 := z.EncBinary() + _ = yym2713 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -35041,23 +35244,23 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2695[0] { + if yyq2711[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2698 := z.EncBinary() - _ = yym2698 + yym2714 := z.EncBinary() + _ = yym2714 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2695 || yy2arr2695 { + if yyr2711 || yy2arr2711 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2695[1] { - yym2700 := z.EncBinary() - _ = yym2700 + if yyq2711[1] { + yym2716 := z.EncBinary() + _ = yym2716 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -35066,42 +35269,42 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2695[1] { + if yyq2711[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2701 := z.EncBinary() - _ = yym2701 + yym2717 := z.EncBinary() + _ = yym2717 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2695 || yy2arr2695 { + if yyr2711 || yy2arr2711 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2695[2] { - yy2703 := &x.ObjectMeta - yy2703.CodecEncodeSelf(e) + if yyq2711[2] { + yy2719 := &x.ObjectMeta + yy2719.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2695[2] { + if yyq2711[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2704 := &x.ObjectMeta - yy2704.CodecEncodeSelf(e) + yy2720 := &x.ObjectMeta + yy2720.CodecEncodeSelf(e) } } - if yyr2695 || yy2arr2695 { + if yyr2711 || yy2arr2711 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Secrets == nil { r.EncodeNil() } else { - yym2706 := z.EncBinary() - _ = yym2706 + yym2722 := z.EncBinary() + _ = yym2722 if false { } else { h.encSliceObjectReference(([]ObjectReference)(x.Secrets), e) @@ -35114,22 +35317,22 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) { if x.Secrets == nil { r.EncodeNil() } else { - yym2707 := z.EncBinary() - _ = yym2707 + yym2723 := z.EncBinary() + _ = yym2723 if false { } else { h.encSliceObjectReference(([]ObjectReference)(x.Secrets), e) } } } - if yyr2695 || yy2arr2695 { + if yyr2711 || yy2arr2711 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2695[4] { + if yyq2711[4] { if x.ImagePullSecrets == nil { r.EncodeNil() } else { - yym2709 := z.EncBinary() - _ = yym2709 + yym2725 := z.EncBinary() + _ = yym2725 if false { } else { h.encSliceLocalObjectReference(([]LocalObjectReference)(x.ImagePullSecrets), e) @@ -35139,15 +35342,15 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq2695[4] { + if yyq2711[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("imagePullSecrets")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.ImagePullSecrets == nil { r.EncodeNil() } else { - yym2710 := z.EncBinary() - _ = yym2710 + yym2726 := z.EncBinary() + _ = yym2726 if false { } else { h.encSliceLocalObjectReference(([]LocalObjectReference)(x.ImagePullSecrets), e) @@ -35155,7 +35358,7 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr2695 || yy2arr2695 { + if yyr2711 || yy2arr2711 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -35168,25 +35371,25 @@ func (x *ServiceAccount) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2711 := z.DecBinary() - _ = yym2711 + yym2727 := z.DecBinary() + _ = yym2727 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2712 := r.ContainerType() - if yyct2712 == codecSelferValueTypeMap1234 { - yyl2712 := r.ReadMapStart() - if yyl2712 == 0 { + yyct2728 := r.ContainerType() + if yyct2728 == codecSelferValueTypeMap1234 { + yyl2728 := r.ReadMapStart() + if yyl2728 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2712, d) + x.codecDecodeSelfFromMap(yyl2728, d) } - } else if yyct2712 == codecSelferValueTypeArray1234 { - yyl2712 := r.ReadArrayStart() - if yyl2712 == 0 { + } else if yyct2728 == codecSelferValueTypeArray1234 { + yyl2728 := r.ReadArrayStart() + if yyl2728 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2712, d) + x.codecDecodeSelfFromArray(yyl2728, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -35198,12 +35401,12 @@ func (x *ServiceAccount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2713Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2713Slc - var yyhl2713 bool = l >= 0 - for yyj2713 := 0; ; yyj2713++ { - if yyhl2713 { - if yyj2713 >= l { + var yys2729Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2729Slc + var yyhl2729 bool = l >= 0 + for yyj2729 := 0; ; yyj2729++ { + if yyhl2729 { + if yyj2729 >= l { break } } else { @@ -35212,10 +35415,10 @@ func (x *ServiceAccount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2713Slc = r.DecodeBytes(yys2713Slc, true, true) - yys2713 := string(yys2713Slc) + yys2729Slc = r.DecodeBytes(yys2729Slc, true, true) + yys2729 := string(yys2729Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2713 { + switch yys2729 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -35232,37 +35435,37 @@ func (x *ServiceAccount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2716 := &x.ObjectMeta - yyv2716.CodecDecodeSelf(d) + yyv2732 := &x.ObjectMeta + yyv2732.CodecDecodeSelf(d) } case "secrets": if r.TryDecodeAsNil() { x.Secrets = nil } else { - yyv2717 := &x.Secrets - yym2718 := z.DecBinary() - _ = yym2718 + yyv2733 := &x.Secrets + yym2734 := z.DecBinary() + _ = yym2734 if false { } else { - h.decSliceObjectReference((*[]ObjectReference)(yyv2717), d) + h.decSliceObjectReference((*[]ObjectReference)(yyv2733), d) } } case "imagePullSecrets": if r.TryDecodeAsNil() { x.ImagePullSecrets = nil } else { - yyv2719 := &x.ImagePullSecrets - yym2720 := z.DecBinary() - _ = yym2720 + yyv2735 := &x.ImagePullSecrets + yym2736 := z.DecBinary() + _ = yym2736 if false { } else { - h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2719), d) + h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2735), d) } } default: - z.DecStructFieldNotFound(-1, yys2713) - } // end switch yys2713 - } // end for yyj2713 + z.DecStructFieldNotFound(-1, yys2729) + } // end switch yys2729 + } // end for yyj2729 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -35270,16 +35473,16 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2721 int - var yyb2721 bool - var yyhl2721 bool = l >= 0 - yyj2721++ - if yyhl2721 { - yyb2721 = yyj2721 > l + var yyj2737 int + var yyb2737 bool + var yyhl2737 bool = l >= 0 + yyj2737++ + if yyhl2737 { + yyb2737 = yyj2737 > l } else { - yyb2721 = r.CheckBreak() + yyb2737 = r.CheckBreak() } - if yyb2721 { + if yyb2737 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35289,13 +35492,13 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2721++ - if yyhl2721 { - yyb2721 = yyj2721 > l + yyj2737++ + if yyhl2737 { + yyb2737 = yyj2737 > l } else { - yyb2721 = r.CheckBreak() + yyb2737 = r.CheckBreak() } - if yyb2721 { + if yyb2737 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35305,13 +35508,13 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2721++ - if yyhl2721 { - yyb2721 = yyj2721 > l + yyj2737++ + if yyhl2737 { + yyb2737 = yyj2737 > l } else { - yyb2721 = r.CheckBreak() + yyb2737 = r.CheckBreak() } - if yyb2721 { + if yyb2737 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35319,16 +35522,16 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2724 := &x.ObjectMeta - yyv2724.CodecDecodeSelf(d) + yyv2740 := &x.ObjectMeta + yyv2740.CodecDecodeSelf(d) } - yyj2721++ - if yyhl2721 { - yyb2721 = yyj2721 > l + yyj2737++ + if yyhl2737 { + yyb2737 = yyj2737 > l } else { - yyb2721 = r.CheckBreak() + yyb2737 = r.CheckBreak() } - if yyb2721 { + if yyb2737 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35336,21 +35539,21 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Secrets = nil } else { - yyv2725 := &x.Secrets - yym2726 := z.DecBinary() - _ = yym2726 + yyv2741 := &x.Secrets + yym2742 := z.DecBinary() + _ = yym2742 if false { } else { - h.decSliceObjectReference((*[]ObjectReference)(yyv2725), d) + h.decSliceObjectReference((*[]ObjectReference)(yyv2741), d) } } - yyj2721++ - if yyhl2721 { - yyb2721 = yyj2721 > l + yyj2737++ + if yyhl2737 { + yyb2737 = yyj2737 > l } else { - yyb2721 = r.CheckBreak() + yyb2737 = r.CheckBreak() } - if yyb2721 { + if yyb2737 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35358,26 +35561,26 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ImagePullSecrets = nil } else { - yyv2727 := &x.ImagePullSecrets - yym2728 := z.DecBinary() - _ = yym2728 + yyv2743 := &x.ImagePullSecrets + yym2744 := z.DecBinary() + _ = yym2744 if false { } else { - h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2727), d) + h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2743), d) } } for { - yyj2721++ - if yyhl2721 { - yyb2721 = yyj2721 > l + yyj2737++ + if yyhl2737 { + yyb2737 = yyj2737 > l } else { - yyb2721 = r.CheckBreak() + yyb2737 = r.CheckBreak() } - if yyb2721 { + if yyb2737 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2721-1, "") + z.DecStructFieldNotFound(yyj2737-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -35389,37 +35592,37 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2729 := z.EncBinary() - _ = yym2729 + yym2745 := z.EncBinary() + _ = yym2745 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2730 := !z.EncBinary() - yy2arr2730 := z.EncBasicHandle().StructToArray - var yyq2730 [4]bool - _, _, _ = yysep2730, yyq2730, yy2arr2730 - const yyr2730 bool = false - yyq2730[0] = x.Kind != "" - yyq2730[1] = x.APIVersion != "" - yyq2730[2] = true - var yynn2730 int - if yyr2730 || yy2arr2730 { + yysep2746 := !z.EncBinary() + yy2arr2746 := z.EncBasicHandle().StructToArray + var yyq2746 [4]bool + _, _, _ = yysep2746, yyq2746, yy2arr2746 + const yyr2746 bool = false + yyq2746[0] = x.Kind != "" + yyq2746[1] = x.APIVersion != "" + yyq2746[2] = true + var yynn2746 int + if yyr2746 || yy2arr2746 { r.EncodeArrayStart(4) } else { - yynn2730 = 1 - for _, b := range yyq2730 { + yynn2746 = 1 + for _, b := range yyq2746 { if b { - yynn2730++ + yynn2746++ } } - r.EncodeMapStart(yynn2730) - yynn2730 = 0 + r.EncodeMapStart(yynn2746) + yynn2746 = 0 } - if yyr2730 || yy2arr2730 { + if yyr2746 || yy2arr2746 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2730[0] { - yym2732 := z.EncBinary() - _ = yym2732 + if yyq2746[0] { + yym2748 := z.EncBinary() + _ = yym2748 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -35428,23 +35631,23 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2730[0] { + if yyq2746[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2733 := z.EncBinary() - _ = yym2733 + yym2749 := z.EncBinary() + _ = yym2749 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2730 || yy2arr2730 { + if yyr2746 || yy2arr2746 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2730[1] { - yym2735 := z.EncBinary() - _ = yym2735 + if yyq2746[1] { + yym2751 := z.EncBinary() + _ = yym2751 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -35453,54 +35656,54 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2730[1] { + if yyq2746[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2736 := z.EncBinary() - _ = yym2736 + yym2752 := z.EncBinary() + _ = yym2752 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2730 || yy2arr2730 { + if yyr2746 || yy2arr2746 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2730[2] { - yy2738 := &x.ListMeta - yym2739 := z.EncBinary() - _ = yym2739 + if yyq2746[2] { + yy2754 := &x.ListMeta + yym2755 := z.EncBinary() + _ = yym2755 if false { - } else if z.HasExtensions() && z.EncExt(yy2738) { + } else if z.HasExtensions() && z.EncExt(yy2754) { } else { - z.EncFallback(yy2738) + z.EncFallback(yy2754) } } else { r.EncodeNil() } } else { - if yyq2730[2] { + if yyq2746[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2740 := &x.ListMeta - yym2741 := z.EncBinary() - _ = yym2741 + yy2756 := &x.ListMeta + yym2757 := z.EncBinary() + _ = yym2757 if false { - } else if z.HasExtensions() && z.EncExt(yy2740) { + } else if z.HasExtensions() && z.EncExt(yy2756) { } else { - z.EncFallback(yy2740) + z.EncFallback(yy2756) } } } - if yyr2730 || yy2arr2730 { + if yyr2746 || yy2arr2746 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym2743 := z.EncBinary() - _ = yym2743 + yym2759 := z.EncBinary() + _ = yym2759 if false { } else { h.encSliceServiceAccount(([]ServiceAccount)(x.Items), e) @@ -35513,15 +35716,15 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym2744 := z.EncBinary() - _ = yym2744 + yym2760 := z.EncBinary() + _ = yym2760 if false { } else { h.encSliceServiceAccount(([]ServiceAccount)(x.Items), e) } } } - if yyr2730 || yy2arr2730 { + if yyr2746 || yy2arr2746 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -35534,25 +35737,25 @@ func (x *ServiceAccountList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2745 := z.DecBinary() - _ = yym2745 + yym2761 := z.DecBinary() + _ = yym2761 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2746 := r.ContainerType() - if yyct2746 == codecSelferValueTypeMap1234 { - yyl2746 := r.ReadMapStart() - if yyl2746 == 0 { + yyct2762 := r.ContainerType() + if yyct2762 == codecSelferValueTypeMap1234 { + yyl2762 := r.ReadMapStart() + if yyl2762 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2746, d) + x.codecDecodeSelfFromMap(yyl2762, d) } - } else if yyct2746 == codecSelferValueTypeArray1234 { - yyl2746 := r.ReadArrayStart() - if yyl2746 == 0 { + } else if yyct2762 == codecSelferValueTypeArray1234 { + yyl2762 := r.ReadArrayStart() + if yyl2762 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2746, d) + x.codecDecodeSelfFromArray(yyl2762, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -35564,12 +35767,12 @@ func (x *ServiceAccountList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2747Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2747Slc - var yyhl2747 bool = l >= 0 - for yyj2747 := 0; ; yyj2747++ { - if yyhl2747 { - if yyj2747 >= l { + var yys2763Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2763Slc + var yyhl2763 bool = l >= 0 + for yyj2763 := 0; ; yyj2763++ { + if yyhl2763 { + if yyj2763 >= l { break } } else { @@ -35578,10 +35781,10 @@ func (x *ServiceAccountList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2747Slc = r.DecodeBytes(yys2747Slc, true, true) - yys2747 := string(yys2747Slc) + yys2763Slc = r.DecodeBytes(yys2763Slc, true, true) + yys2763 := string(yys2763Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2747 { + switch yys2763 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -35598,31 +35801,31 @@ func (x *ServiceAccountList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2750 := &x.ListMeta - yym2751 := z.DecBinary() - _ = yym2751 + yyv2766 := &x.ListMeta + yym2767 := z.DecBinary() + _ = yym2767 if false { - } else if z.HasExtensions() && z.DecExt(yyv2750) { + } else if z.HasExtensions() && z.DecExt(yyv2766) { } else { - z.DecFallback(yyv2750, false) + z.DecFallback(yyv2766, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2752 := &x.Items - yym2753 := z.DecBinary() - _ = yym2753 + yyv2768 := &x.Items + yym2769 := z.DecBinary() + _ = yym2769 if false { } else { - h.decSliceServiceAccount((*[]ServiceAccount)(yyv2752), d) + h.decSliceServiceAccount((*[]ServiceAccount)(yyv2768), d) } } default: - z.DecStructFieldNotFound(-1, yys2747) - } // end switch yys2747 - } // end for yyj2747 + z.DecStructFieldNotFound(-1, yys2763) + } // end switch yys2763 + } // end for yyj2763 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -35630,16 +35833,16 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2754 int - var yyb2754 bool - var yyhl2754 bool = l >= 0 - yyj2754++ - if yyhl2754 { - yyb2754 = yyj2754 > l + var yyj2770 int + var yyb2770 bool + var yyhl2770 bool = l >= 0 + yyj2770++ + if yyhl2770 { + yyb2770 = yyj2770 > l } else { - yyb2754 = r.CheckBreak() + yyb2770 = r.CheckBreak() } - if yyb2754 { + if yyb2770 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35649,13 +35852,13 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.Kind = string(r.DecodeString()) } - yyj2754++ - if yyhl2754 { - yyb2754 = yyj2754 > l + yyj2770++ + if yyhl2770 { + yyb2770 = yyj2770 > l } else { - yyb2754 = r.CheckBreak() + yyb2770 = r.CheckBreak() } - if yyb2754 { + if yyb2770 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35665,13 +35868,13 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.APIVersion = string(r.DecodeString()) } - yyj2754++ - if yyhl2754 { - yyb2754 = yyj2754 > l + yyj2770++ + if yyhl2770 { + yyb2770 = yyj2770 > l } else { - yyb2754 = r.CheckBreak() + yyb2770 = r.CheckBreak() } - if yyb2754 { + if yyb2770 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35679,22 +35882,22 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2757 := &x.ListMeta - yym2758 := z.DecBinary() - _ = yym2758 + yyv2773 := &x.ListMeta + yym2774 := z.DecBinary() + _ = yym2774 if false { - } else if z.HasExtensions() && z.DecExt(yyv2757) { + } else if z.HasExtensions() && z.DecExt(yyv2773) { } else { - z.DecFallback(yyv2757, false) + z.DecFallback(yyv2773, false) } } - yyj2754++ - if yyhl2754 { - yyb2754 = yyj2754 > l + yyj2770++ + if yyhl2770 { + yyb2770 = yyj2770 > l } else { - yyb2754 = r.CheckBreak() + yyb2770 = r.CheckBreak() } - if yyb2754 { + if yyb2770 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35702,26 +35905,26 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2759 := &x.Items - yym2760 := z.DecBinary() - _ = yym2760 + yyv2775 := &x.Items + yym2776 := z.DecBinary() + _ = yym2776 if false { } else { - h.decSliceServiceAccount((*[]ServiceAccount)(yyv2759), d) + h.decSliceServiceAccount((*[]ServiceAccount)(yyv2775), d) } } for { - yyj2754++ - if yyhl2754 { - yyb2754 = yyj2754 > l + yyj2770++ + if yyhl2770 { + yyb2770 = yyj2770 > l } else { - yyb2754 = r.CheckBreak() + yyb2770 = r.CheckBreak() } - if yyb2754 { + if yyb2770 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2754-1, "") + z.DecStructFieldNotFound(yyj2770-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -35733,37 +35936,37 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2761 := z.EncBinary() - _ = yym2761 + yym2777 := z.EncBinary() + _ = yym2777 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2762 := !z.EncBinary() - yy2arr2762 := z.EncBasicHandle().StructToArray - var yyq2762 [4]bool - _, _, _ = yysep2762, yyq2762, yy2arr2762 - const yyr2762 bool = false - yyq2762[0] = x.Kind != "" - yyq2762[1] = x.APIVersion != "" - yyq2762[2] = true - var yynn2762 int - if yyr2762 || yy2arr2762 { + yysep2778 := !z.EncBinary() + yy2arr2778 := z.EncBasicHandle().StructToArray + var yyq2778 [4]bool + _, _, _ = yysep2778, yyq2778, yy2arr2778 + const yyr2778 bool = false + yyq2778[0] = x.Kind != "" + yyq2778[1] = x.APIVersion != "" + yyq2778[2] = true + var yynn2778 int + if yyr2778 || yy2arr2778 { r.EncodeArrayStart(4) } else { - yynn2762 = 1 - for _, b := range yyq2762 { + yynn2778 = 1 + for _, b := range yyq2778 { if b { - yynn2762++ + yynn2778++ } } - r.EncodeMapStart(yynn2762) - yynn2762 = 0 + r.EncodeMapStart(yynn2778) + yynn2778 = 0 } - if yyr2762 || yy2arr2762 { + if yyr2778 || yy2arr2778 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2762[0] { - yym2764 := z.EncBinary() - _ = yym2764 + if yyq2778[0] { + yym2780 := z.EncBinary() + _ = yym2780 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -35772,23 +35975,23 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2762[0] { + if yyq2778[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2765 := z.EncBinary() - _ = yym2765 + yym2781 := z.EncBinary() + _ = yym2781 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2762 || yy2arr2762 { + if yyr2778 || yy2arr2778 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2762[1] { - yym2767 := z.EncBinary() - _ = yym2767 + if yyq2778[1] { + yym2783 := z.EncBinary() + _ = yym2783 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -35797,42 +36000,42 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2762[1] { + if yyq2778[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2768 := z.EncBinary() - _ = yym2768 + yym2784 := z.EncBinary() + _ = yym2784 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2762 || yy2arr2762 { + if yyr2778 || yy2arr2778 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2762[2] { - yy2770 := &x.ObjectMeta - yy2770.CodecEncodeSelf(e) + if yyq2778[2] { + yy2786 := &x.ObjectMeta + yy2786.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2762[2] { + if yyq2778[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2771 := &x.ObjectMeta - yy2771.CodecEncodeSelf(e) + yy2787 := &x.ObjectMeta + yy2787.CodecEncodeSelf(e) } } - if yyr2762 || yy2arr2762 { + if yyr2778 || yy2arr2778 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Subsets == nil { r.EncodeNil() } else { - yym2773 := z.EncBinary() - _ = yym2773 + yym2789 := z.EncBinary() + _ = yym2789 if false { } else { h.encSliceEndpointSubset(([]EndpointSubset)(x.Subsets), e) @@ -35845,15 +36048,15 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) { if x.Subsets == nil { r.EncodeNil() } else { - yym2774 := z.EncBinary() - _ = yym2774 + yym2790 := z.EncBinary() + _ = yym2790 if false { } else { h.encSliceEndpointSubset(([]EndpointSubset)(x.Subsets), e) } } } - if yyr2762 || yy2arr2762 { + if yyr2778 || yy2arr2778 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -35866,25 +36069,25 @@ func (x *Endpoints) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2775 := z.DecBinary() - _ = yym2775 + yym2791 := z.DecBinary() + _ = yym2791 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2776 := r.ContainerType() - if yyct2776 == codecSelferValueTypeMap1234 { - yyl2776 := r.ReadMapStart() - if yyl2776 == 0 { + yyct2792 := r.ContainerType() + if yyct2792 == codecSelferValueTypeMap1234 { + yyl2792 := r.ReadMapStart() + if yyl2792 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2776, d) + x.codecDecodeSelfFromMap(yyl2792, d) } - } else if yyct2776 == codecSelferValueTypeArray1234 { - yyl2776 := r.ReadArrayStart() - if yyl2776 == 0 { + } else if yyct2792 == codecSelferValueTypeArray1234 { + yyl2792 := r.ReadArrayStart() + if yyl2792 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2776, d) + x.codecDecodeSelfFromArray(yyl2792, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -35896,12 +36099,12 @@ func (x *Endpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2777Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2777Slc - var yyhl2777 bool = l >= 0 - for yyj2777 := 0; ; yyj2777++ { - if yyhl2777 { - if yyj2777 >= l { + var yys2793Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2793Slc + var yyhl2793 bool = l >= 0 + for yyj2793 := 0; ; yyj2793++ { + if yyhl2793 { + if yyj2793 >= l { break } } else { @@ -35910,10 +36113,10 @@ func (x *Endpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2777Slc = r.DecodeBytes(yys2777Slc, true, true) - yys2777 := string(yys2777Slc) + yys2793Slc = r.DecodeBytes(yys2793Slc, true, true) + yys2793 := string(yys2793Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2777 { + switch yys2793 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -35930,25 +36133,25 @@ func (x *Endpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2780 := &x.ObjectMeta - yyv2780.CodecDecodeSelf(d) + yyv2796 := &x.ObjectMeta + yyv2796.CodecDecodeSelf(d) } case "Subsets": if r.TryDecodeAsNil() { x.Subsets = nil } else { - yyv2781 := &x.Subsets - yym2782 := z.DecBinary() - _ = yym2782 + yyv2797 := &x.Subsets + yym2798 := z.DecBinary() + _ = yym2798 if false { } else { - h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2781), d) + h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2797), d) } } default: - z.DecStructFieldNotFound(-1, yys2777) - } // end switch yys2777 - } // end for yyj2777 + z.DecStructFieldNotFound(-1, yys2793) + } // end switch yys2793 + } // end for yyj2793 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -35956,16 +36159,16 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2783 int - var yyb2783 bool - var yyhl2783 bool = l >= 0 - yyj2783++ - if yyhl2783 { - yyb2783 = yyj2783 > l + var yyj2799 int + var yyb2799 bool + var yyhl2799 bool = l >= 0 + yyj2799++ + if yyhl2799 { + yyb2799 = yyj2799 > l } else { - yyb2783 = r.CheckBreak() + yyb2799 = r.CheckBreak() } - if yyb2783 { + if yyb2799 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35975,13 +36178,13 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2783++ - if yyhl2783 { - yyb2783 = yyj2783 > l + yyj2799++ + if yyhl2799 { + yyb2799 = yyj2799 > l } else { - yyb2783 = r.CheckBreak() + yyb2799 = r.CheckBreak() } - if yyb2783 { + if yyb2799 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -35991,13 +36194,13 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2783++ - if yyhl2783 { - yyb2783 = yyj2783 > l + yyj2799++ + if yyhl2799 { + yyb2799 = yyj2799 > l } else { - yyb2783 = r.CheckBreak() + yyb2799 = r.CheckBreak() } - if yyb2783 { + if yyb2799 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36005,16 +36208,16 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv2786 := &x.ObjectMeta - yyv2786.CodecDecodeSelf(d) + yyv2802 := &x.ObjectMeta + yyv2802.CodecDecodeSelf(d) } - yyj2783++ - if yyhl2783 { - yyb2783 = yyj2783 > l + yyj2799++ + if yyhl2799 { + yyb2799 = yyj2799 > l } else { - yyb2783 = r.CheckBreak() + yyb2799 = r.CheckBreak() } - if yyb2783 { + if yyb2799 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36022,26 +36225,26 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Subsets = nil } else { - yyv2787 := &x.Subsets - yym2788 := z.DecBinary() - _ = yym2788 + yyv2803 := &x.Subsets + yym2804 := z.DecBinary() + _ = yym2804 if false { } else { - h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2787), d) + h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2803), d) } } for { - yyj2783++ - if yyhl2783 { - yyb2783 = yyj2783 > l + yyj2799++ + if yyhl2799 { + yyb2799 = yyj2799 > l } else { - yyb2783 = r.CheckBreak() + yyb2799 = r.CheckBreak() } - if yyb2783 { + if yyb2799 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2783-1, "") + z.DecStructFieldNotFound(yyj2799-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -36053,36 +36256,36 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2789 := z.EncBinary() - _ = yym2789 + yym2805 := z.EncBinary() + _ = yym2805 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2790 := !z.EncBinary() - yy2arr2790 := z.EncBasicHandle().StructToArray - var yyq2790 [3]bool - _, _, _ = yysep2790, yyq2790, yy2arr2790 - const yyr2790 bool = false - var yynn2790 int - if yyr2790 || yy2arr2790 { + yysep2806 := !z.EncBinary() + yy2arr2806 := z.EncBasicHandle().StructToArray + var yyq2806 [3]bool + _, _, _ = yysep2806, yyq2806, yy2arr2806 + const yyr2806 bool = false + var yynn2806 int + if yyr2806 || yy2arr2806 { r.EncodeArrayStart(3) } else { - yynn2790 = 3 - for _, b := range yyq2790 { + yynn2806 = 3 + for _, b := range yyq2806 { if b { - yynn2790++ + yynn2806++ } } - r.EncodeMapStart(yynn2790) - yynn2790 = 0 + r.EncodeMapStart(yynn2806) + yynn2806 = 0 } - if yyr2790 || yy2arr2790 { + if yyr2806 || yy2arr2806 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Addresses == nil { r.EncodeNil() } else { - yym2792 := z.EncBinary() - _ = yym2792 + yym2808 := z.EncBinary() + _ = yym2808 if false { } else { h.encSliceEndpointAddress(([]EndpointAddress)(x.Addresses), e) @@ -36095,21 +36298,21 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) { if x.Addresses == nil { r.EncodeNil() } else { - yym2793 := z.EncBinary() - _ = yym2793 + yym2809 := z.EncBinary() + _ = yym2809 if false { } else { h.encSliceEndpointAddress(([]EndpointAddress)(x.Addresses), e) } } } - if yyr2790 || yy2arr2790 { + if yyr2806 || yy2arr2806 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.NotReadyAddresses == nil { r.EncodeNil() } else { - yym2795 := z.EncBinary() - _ = yym2795 + yym2811 := z.EncBinary() + _ = yym2811 if false { } else { h.encSliceEndpointAddress(([]EndpointAddress)(x.NotReadyAddresses), e) @@ -36122,21 +36325,21 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) { if x.NotReadyAddresses == nil { r.EncodeNil() } else { - yym2796 := z.EncBinary() - _ = yym2796 + yym2812 := z.EncBinary() + _ = yym2812 if false { } else { h.encSliceEndpointAddress(([]EndpointAddress)(x.NotReadyAddresses), e) } } } - if yyr2790 || yy2arr2790 { + if yyr2806 || yy2arr2806 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Ports == nil { r.EncodeNil() } else { - yym2798 := z.EncBinary() - _ = yym2798 + yym2814 := z.EncBinary() + _ = yym2814 if false { } else { h.encSliceEndpointPort(([]EndpointPort)(x.Ports), e) @@ -36149,15 +36352,15 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) { if x.Ports == nil { r.EncodeNil() } else { - yym2799 := z.EncBinary() - _ = yym2799 + yym2815 := z.EncBinary() + _ = yym2815 if false { } else { h.encSliceEndpointPort(([]EndpointPort)(x.Ports), e) } } } - if yyr2790 || yy2arr2790 { + if yyr2806 || yy2arr2806 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -36170,25 +36373,25 @@ func (x *EndpointSubset) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2800 := z.DecBinary() - _ = yym2800 + yym2816 := z.DecBinary() + _ = yym2816 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2801 := r.ContainerType() - if yyct2801 == codecSelferValueTypeMap1234 { - yyl2801 := r.ReadMapStart() - if yyl2801 == 0 { + yyct2817 := r.ContainerType() + if yyct2817 == codecSelferValueTypeMap1234 { + yyl2817 := r.ReadMapStart() + if yyl2817 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2801, d) + x.codecDecodeSelfFromMap(yyl2817, d) } - } else if yyct2801 == codecSelferValueTypeArray1234 { - yyl2801 := r.ReadArrayStart() - if yyl2801 == 0 { + } else if yyct2817 == codecSelferValueTypeArray1234 { + yyl2817 := r.ReadArrayStart() + if yyl2817 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2801, d) + x.codecDecodeSelfFromArray(yyl2817, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -36200,12 +36403,12 @@ func (x *EndpointSubset) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2802Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2802Slc - var yyhl2802 bool = l >= 0 - for yyj2802 := 0; ; yyj2802++ { - if yyhl2802 { - if yyj2802 >= l { + var yys2818Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2818Slc + var yyhl2818 bool = l >= 0 + for yyj2818 := 0; ; yyj2818++ { + if yyhl2818 { + if yyj2818 >= l { break } } else { @@ -36214,50 +36417,50 @@ func (x *EndpointSubset) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2802Slc = r.DecodeBytes(yys2802Slc, true, true) - yys2802 := string(yys2802Slc) + yys2818Slc = r.DecodeBytes(yys2818Slc, true, true) + yys2818 := string(yys2818Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2802 { + switch yys2818 { case "Addresses": if r.TryDecodeAsNil() { x.Addresses = nil } else { - yyv2803 := &x.Addresses - yym2804 := z.DecBinary() - _ = yym2804 + yyv2819 := &x.Addresses + yym2820 := z.DecBinary() + _ = yym2820 if false { } else { - h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2803), d) + h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2819), d) } } case "NotReadyAddresses": if r.TryDecodeAsNil() { x.NotReadyAddresses = nil } else { - yyv2805 := &x.NotReadyAddresses - yym2806 := z.DecBinary() - _ = yym2806 + yyv2821 := &x.NotReadyAddresses + yym2822 := z.DecBinary() + _ = yym2822 if false { } else { - h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2805), d) + h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2821), d) } } case "Ports": if r.TryDecodeAsNil() { x.Ports = nil } else { - yyv2807 := &x.Ports - yym2808 := z.DecBinary() - _ = yym2808 + yyv2823 := &x.Ports + yym2824 := z.DecBinary() + _ = yym2824 if false { } else { - h.decSliceEndpointPort((*[]EndpointPort)(yyv2807), d) + h.decSliceEndpointPort((*[]EndpointPort)(yyv2823), d) } } default: - z.DecStructFieldNotFound(-1, yys2802) - } // end switch yys2802 - } // end for yyj2802 + z.DecStructFieldNotFound(-1, yys2818) + } // end switch yys2818 + } // end for yyj2818 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -36265,16 +36468,16 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2809 int - var yyb2809 bool - var yyhl2809 bool = l >= 0 - yyj2809++ - if yyhl2809 { - yyb2809 = yyj2809 > l + var yyj2825 int + var yyb2825 bool + var yyhl2825 bool = l >= 0 + yyj2825++ + if yyhl2825 { + yyb2825 = yyj2825 > l } else { - yyb2809 = r.CheckBreak() + yyb2825 = r.CheckBreak() } - if yyb2809 { + if yyb2825 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36282,21 +36485,21 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Addresses = nil } else { - yyv2810 := &x.Addresses - yym2811 := z.DecBinary() - _ = yym2811 + yyv2826 := &x.Addresses + yym2827 := z.DecBinary() + _ = yym2827 if false { } else { - h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2810), d) + h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2826), d) } } - yyj2809++ - if yyhl2809 { - yyb2809 = yyj2809 > l + yyj2825++ + if yyhl2825 { + yyb2825 = yyj2825 > l } else { - yyb2809 = r.CheckBreak() + yyb2825 = r.CheckBreak() } - if yyb2809 { + if yyb2825 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36304,21 +36507,21 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.NotReadyAddresses = nil } else { - yyv2812 := &x.NotReadyAddresses - yym2813 := z.DecBinary() - _ = yym2813 + yyv2828 := &x.NotReadyAddresses + yym2829 := z.DecBinary() + _ = yym2829 if false { } else { - h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2812), d) + h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2828), d) } } - yyj2809++ - if yyhl2809 { - yyb2809 = yyj2809 > l + yyj2825++ + if yyhl2825 { + yyb2825 = yyj2825 > l } else { - yyb2809 = r.CheckBreak() + yyb2825 = r.CheckBreak() } - if yyb2809 { + if yyb2825 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36326,26 +36529,26 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Ports = nil } else { - yyv2814 := &x.Ports - yym2815 := z.DecBinary() - _ = yym2815 + yyv2830 := &x.Ports + yym2831 := z.DecBinary() + _ = yym2831 if false { } else { - h.decSliceEndpointPort((*[]EndpointPort)(yyv2814), d) + h.decSliceEndpointPort((*[]EndpointPort)(yyv2830), d) } } for { - yyj2809++ - if yyhl2809 { - yyb2809 = yyj2809 > l + yyj2825++ + if yyhl2825 { + yyb2825 = yyj2825 > l } else { - yyb2809 = r.CheckBreak() + yyb2825 = r.CheckBreak() } - if yyb2809 { + if yyb2825 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2809-1, "") + z.DecStructFieldNotFound(yyj2825-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -36357,35 +36560,35 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2816 := z.EncBinary() - _ = yym2816 + yym2832 := z.EncBinary() + _ = yym2832 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2817 := !z.EncBinary() - yy2arr2817 := z.EncBasicHandle().StructToArray - var yyq2817 [4]bool - _, _, _ = yysep2817, yyq2817, yy2arr2817 - const yyr2817 bool = false - yyq2817[1] = x.Hostname != "" - yyq2817[2] = x.NodeName != nil - var yynn2817 int - if yyr2817 || yy2arr2817 { + yysep2833 := !z.EncBinary() + yy2arr2833 := z.EncBasicHandle().StructToArray + var yyq2833 [4]bool + _, _, _ = yysep2833, yyq2833, yy2arr2833 + const yyr2833 bool = false + yyq2833[1] = x.Hostname != "" + yyq2833[2] = x.NodeName != nil + var yynn2833 int + if yyr2833 || yy2arr2833 { r.EncodeArrayStart(4) } else { - yynn2817 = 2 - for _, b := range yyq2817 { + yynn2833 = 2 + for _, b := range yyq2833 { if b { - yynn2817++ + yynn2833++ } } - r.EncodeMapStart(yynn2817) - yynn2817 = 0 + r.EncodeMapStart(yynn2833) + yynn2833 = 0 } - if yyr2817 || yy2arr2817 { + if yyr2833 || yy2arr2833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2819 := z.EncBinary() - _ = yym2819 + yym2835 := z.EncBinary() + _ = yym2835 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.IP)) @@ -36394,18 +36597,18 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("IP")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2820 := z.EncBinary() - _ = yym2820 + yym2836 := z.EncBinary() + _ = yym2836 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.IP)) } } - if yyr2817 || yy2arr2817 { + if yyr2833 || yy2arr2833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2817[1] { - yym2822 := z.EncBinary() - _ = yym2822 + if yyq2833[1] { + yym2838 := z.EncBinary() + _ = yym2838 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Hostname)) @@ -36414,54 +36617,54 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2817[1] { + if yyq2833[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("hostname")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2823 := z.EncBinary() - _ = yym2823 + yym2839 := z.EncBinary() + _ = yym2839 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Hostname)) } } } - if yyr2817 || yy2arr2817 { + if yyr2833 || yy2arr2833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2817[2] { + if yyq2833[2] { if x.NodeName == nil { r.EncodeNil() } else { - yy2825 := *x.NodeName - yym2826 := z.EncBinary() - _ = yym2826 + yy2841 := *x.NodeName + yym2842 := z.EncBinary() + _ = yym2842 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(yy2825)) + r.EncodeString(codecSelferC_UTF81234, string(yy2841)) } } } else { r.EncodeNil() } } else { - if yyq2817[2] { + if yyq2833[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("nodeName")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.NodeName == nil { r.EncodeNil() } else { - yy2827 := *x.NodeName - yym2828 := z.EncBinary() - _ = yym2828 + yy2843 := *x.NodeName + yym2844 := z.EncBinary() + _ = yym2844 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(yy2827)) + r.EncodeString(codecSelferC_UTF81234, string(yy2843)) } } } } - if yyr2817 || yy2arr2817 { + if yyr2833 || yy2arr2833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.TargetRef == nil { r.EncodeNil() @@ -36478,7 +36681,7 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) { x.TargetRef.CodecEncodeSelf(e) } } - if yyr2817 || yy2arr2817 { + if yyr2833 || yy2arr2833 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -36491,25 +36694,25 @@ func (x *EndpointAddress) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2830 := z.DecBinary() - _ = yym2830 + yym2846 := z.DecBinary() + _ = yym2846 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2831 := r.ContainerType() - if yyct2831 == codecSelferValueTypeMap1234 { - yyl2831 := r.ReadMapStart() - if yyl2831 == 0 { + yyct2847 := r.ContainerType() + if yyct2847 == codecSelferValueTypeMap1234 { + yyl2847 := r.ReadMapStart() + if yyl2847 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2831, d) + x.codecDecodeSelfFromMap(yyl2847, d) } - } else if yyct2831 == codecSelferValueTypeArray1234 { - yyl2831 := r.ReadArrayStart() - if yyl2831 == 0 { + } else if yyct2847 == codecSelferValueTypeArray1234 { + yyl2847 := r.ReadArrayStart() + if yyl2847 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2831, d) + x.codecDecodeSelfFromArray(yyl2847, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -36521,12 +36724,12 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2832Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2832Slc - var yyhl2832 bool = l >= 0 - for yyj2832 := 0; ; yyj2832++ { - if yyhl2832 { - if yyj2832 >= l { + var yys2848Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2848Slc + var yyhl2848 bool = l >= 0 + for yyj2848 := 0; ; yyj2848++ { + if yyhl2848 { + if yyj2848 >= l { break } } else { @@ -36535,10 +36738,10 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2832Slc = r.DecodeBytes(yys2832Slc, true, true) - yys2832 := string(yys2832Slc) + yys2848Slc = r.DecodeBytes(yys2848Slc, true, true) + yys2848 := string(yys2848Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2832 { + switch yys2848 { case "IP": if r.TryDecodeAsNil() { x.IP = "" @@ -36560,8 +36763,8 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.NodeName == nil { x.NodeName = new(string) } - yym2836 := z.DecBinary() - _ = yym2836 + yym2852 := z.DecBinary() + _ = yym2852 if false { } else { *((*string)(x.NodeName)) = r.DecodeString() @@ -36579,9 +36782,9 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.TargetRef.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2832) - } // end switch yys2832 - } // end for yyj2832 + z.DecStructFieldNotFound(-1, yys2848) + } // end switch yys2848 + } // end for yyj2848 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -36589,16 +36792,16 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2838 int - var yyb2838 bool - var yyhl2838 bool = l >= 0 - yyj2838++ - if yyhl2838 { - yyb2838 = yyj2838 > l + var yyj2854 int + var yyb2854 bool + var yyhl2854 bool = l >= 0 + yyj2854++ + if yyhl2854 { + yyb2854 = yyj2854 > l } else { - yyb2838 = r.CheckBreak() + yyb2854 = r.CheckBreak() } - if yyb2838 { + if yyb2854 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36608,13 +36811,13 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.IP = string(r.DecodeString()) } - yyj2838++ - if yyhl2838 { - yyb2838 = yyj2838 > l + yyj2854++ + if yyhl2854 { + yyb2854 = yyj2854 > l } else { - yyb2838 = r.CheckBreak() + yyb2854 = r.CheckBreak() } - if yyb2838 { + if yyb2854 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36624,13 +36827,13 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Hostname = string(r.DecodeString()) } - yyj2838++ - if yyhl2838 { - yyb2838 = yyj2838 > l + yyj2854++ + if yyhl2854 { + yyb2854 = yyj2854 > l } else { - yyb2838 = r.CheckBreak() + yyb2854 = r.CheckBreak() } - if yyb2838 { + if yyb2854 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36643,20 +36846,20 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if x.NodeName == nil { x.NodeName = new(string) } - yym2842 := z.DecBinary() - _ = yym2842 + yym2858 := z.DecBinary() + _ = yym2858 if false { } else { *((*string)(x.NodeName)) = r.DecodeString() } } - yyj2838++ - if yyhl2838 { - yyb2838 = yyj2838 > l + yyj2854++ + if yyhl2854 { + yyb2854 = yyj2854 > l } else { - yyb2838 = r.CheckBreak() + yyb2854 = r.CheckBreak() } - if yyb2838 { + if yyb2854 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36672,17 +36875,17 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) x.TargetRef.CodecDecodeSelf(d) } for { - yyj2838++ - if yyhl2838 { - yyb2838 = yyj2838 > l + yyj2854++ + if yyhl2854 { + yyb2854 = yyj2854 > l } else { - yyb2838 = r.CheckBreak() + yyb2854 = r.CheckBreak() } - if yyb2838 { + if yyb2854 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2838-1, "") + z.DecStructFieldNotFound(yyj2854-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -36694,33 +36897,33 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2844 := z.EncBinary() - _ = yym2844 + yym2860 := z.EncBinary() + _ = yym2860 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2845 := !z.EncBinary() - yy2arr2845 := z.EncBasicHandle().StructToArray - var yyq2845 [3]bool - _, _, _ = yysep2845, yyq2845, yy2arr2845 - const yyr2845 bool = false - var yynn2845 int - if yyr2845 || yy2arr2845 { + yysep2861 := !z.EncBinary() + yy2arr2861 := z.EncBasicHandle().StructToArray + var yyq2861 [3]bool + _, _, _ = yysep2861, yyq2861, yy2arr2861 + const yyr2861 bool = false + var yynn2861 int + if yyr2861 || yy2arr2861 { r.EncodeArrayStart(3) } else { - yynn2845 = 3 - for _, b := range yyq2845 { + yynn2861 = 3 + for _, b := range yyq2861 { if b { - yynn2845++ + yynn2861++ } } - r.EncodeMapStart(yynn2845) - yynn2845 = 0 + r.EncodeMapStart(yynn2861) + yynn2861 = 0 } - if yyr2845 || yy2arr2845 { + if yyr2861 || yy2arr2861 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2847 := z.EncBinary() - _ = yym2847 + yym2863 := z.EncBinary() + _ = yym2863 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) @@ -36729,17 +36932,17 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Name")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2848 := z.EncBinary() - _ = yym2848 + yym2864 := z.EncBinary() + _ = yym2864 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) } } - if yyr2845 || yy2arr2845 { + if yyr2861 || yy2arr2861 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2850 := z.EncBinary() - _ = yym2850 + yym2866 := z.EncBinary() + _ = yym2866 if false { } else { r.EncodeInt(int64(x.Port)) @@ -36748,14 +36951,14 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Port")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2851 := z.EncBinary() - _ = yym2851 + yym2867 := z.EncBinary() + _ = yym2867 if false { } else { r.EncodeInt(int64(x.Port)) } } - if yyr2845 || yy2arr2845 { + if yyr2861 || yy2arr2861 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Protocol.CodecEncodeSelf(e) } else { @@ -36764,7 +36967,7 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Protocol.CodecEncodeSelf(e) } - if yyr2845 || yy2arr2845 { + if yyr2861 || yy2arr2861 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -36777,25 +36980,25 @@ func (x *EndpointPort) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2853 := z.DecBinary() - _ = yym2853 + yym2869 := z.DecBinary() + _ = yym2869 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2854 := r.ContainerType() - if yyct2854 == codecSelferValueTypeMap1234 { - yyl2854 := r.ReadMapStart() - if yyl2854 == 0 { + yyct2870 := r.ContainerType() + if yyct2870 == codecSelferValueTypeMap1234 { + yyl2870 := r.ReadMapStart() + if yyl2870 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2854, d) + x.codecDecodeSelfFromMap(yyl2870, d) } - } else if yyct2854 == codecSelferValueTypeArray1234 { - yyl2854 := r.ReadArrayStart() - if yyl2854 == 0 { + } else if yyct2870 == codecSelferValueTypeArray1234 { + yyl2870 := r.ReadArrayStart() + if yyl2870 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2854, d) + x.codecDecodeSelfFromArray(yyl2870, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -36807,12 +37010,12 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2855Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2855Slc - var yyhl2855 bool = l >= 0 - for yyj2855 := 0; ; yyj2855++ { - if yyhl2855 { - if yyj2855 >= l { + var yys2871Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2871Slc + var yyhl2871 bool = l >= 0 + for yyj2871 := 0; ; yyj2871++ { + if yyhl2871 { + if yyj2871 >= l { break } } else { @@ -36821,10 +37024,10 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2855Slc = r.DecodeBytes(yys2855Slc, true, true) - yys2855 := string(yys2855Slc) + yys2871Slc = r.DecodeBytes(yys2871Slc, true, true) + yys2871 := string(yys2871Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2855 { + switch yys2871 { case "Name": if r.TryDecodeAsNil() { x.Name = "" @@ -36844,9 +37047,9 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Protocol = Protocol(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys2855) - } // end switch yys2855 - } // end for yyj2855 + z.DecStructFieldNotFound(-1, yys2871) + } // end switch yys2871 + } // end for yyj2871 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -36854,16 +37057,16 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2859 int - var yyb2859 bool - var yyhl2859 bool = l >= 0 - yyj2859++ - if yyhl2859 { - yyb2859 = yyj2859 > l + var yyj2875 int + var yyb2875 bool + var yyhl2875 bool = l >= 0 + yyj2875++ + if yyhl2875 { + yyb2875 = yyj2875 > l } else { - yyb2859 = r.CheckBreak() + yyb2875 = r.CheckBreak() } - if yyb2859 { + if yyb2875 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36873,13 +37076,13 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Name = string(r.DecodeString()) } - yyj2859++ - if yyhl2859 { - yyb2859 = yyj2859 > l + yyj2875++ + if yyhl2875 { + yyb2875 = yyj2875 > l } else { - yyb2859 = r.CheckBreak() + yyb2875 = r.CheckBreak() } - if yyb2859 { + if yyb2875 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36889,13 +37092,13 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Port = int32(r.DecodeInt(32)) } - yyj2859++ - if yyhl2859 { - yyb2859 = yyj2859 > l + yyj2875++ + if yyhl2875 { + yyb2875 = yyj2875 > l } else { - yyb2859 = r.CheckBreak() + yyb2875 = r.CheckBreak() } - if yyb2859 { + if yyb2875 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -36906,17 +37109,17 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Protocol = Protocol(r.DecodeString()) } for { - yyj2859++ - if yyhl2859 { - yyb2859 = yyj2859 > l + yyj2875++ + if yyhl2875 { + yyb2875 = yyj2875 > l } else { - yyb2859 = r.CheckBreak() + yyb2875 = r.CheckBreak() } - if yyb2859 { + if yyb2875 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2859-1, "") + z.DecStructFieldNotFound(yyj2875-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -36928,37 +37131,37 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2863 := z.EncBinary() - _ = yym2863 + yym2879 := z.EncBinary() + _ = yym2879 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2864 := !z.EncBinary() - yy2arr2864 := z.EncBasicHandle().StructToArray - var yyq2864 [4]bool - _, _, _ = yysep2864, yyq2864, yy2arr2864 - const yyr2864 bool = false - yyq2864[0] = x.Kind != "" - yyq2864[1] = x.APIVersion != "" - yyq2864[2] = true - var yynn2864 int - if yyr2864 || yy2arr2864 { + yysep2880 := !z.EncBinary() + yy2arr2880 := z.EncBasicHandle().StructToArray + var yyq2880 [4]bool + _, _, _ = yysep2880, yyq2880, yy2arr2880 + const yyr2880 bool = false + yyq2880[0] = x.Kind != "" + yyq2880[1] = x.APIVersion != "" + yyq2880[2] = true + var yynn2880 int + if yyr2880 || yy2arr2880 { r.EncodeArrayStart(4) } else { - yynn2864 = 1 - for _, b := range yyq2864 { + yynn2880 = 1 + for _, b := range yyq2880 { if b { - yynn2864++ + yynn2880++ } } - r.EncodeMapStart(yynn2864) - yynn2864 = 0 + r.EncodeMapStart(yynn2880) + yynn2880 = 0 } - if yyr2864 || yy2arr2864 { + if yyr2880 || yy2arr2880 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2864[0] { - yym2866 := z.EncBinary() - _ = yym2866 + if yyq2880[0] { + yym2882 := z.EncBinary() + _ = yym2882 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -36967,23 +37170,23 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2864[0] { + if yyq2880[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2867 := z.EncBinary() - _ = yym2867 + yym2883 := z.EncBinary() + _ = yym2883 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr2864 || yy2arr2864 { + if yyr2880 || yy2arr2880 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2864[1] { - yym2869 := z.EncBinary() - _ = yym2869 + if yyq2880[1] { + yym2885 := z.EncBinary() + _ = yym2885 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -36992,54 +37195,54 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2864[1] { + if yyq2880[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2870 := z.EncBinary() - _ = yym2870 + yym2886 := z.EncBinary() + _ = yym2886 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr2864 || yy2arr2864 { + if yyr2880 || yy2arr2880 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2864[2] { - yy2872 := &x.ListMeta - yym2873 := z.EncBinary() - _ = yym2873 + if yyq2880[2] { + yy2888 := &x.ListMeta + yym2889 := z.EncBinary() + _ = yym2889 if false { - } else if z.HasExtensions() && z.EncExt(yy2872) { + } else if z.HasExtensions() && z.EncExt(yy2888) { } else { - z.EncFallback(yy2872) + z.EncFallback(yy2888) } } else { r.EncodeNil() } } else { - if yyq2864[2] { + if yyq2880[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2874 := &x.ListMeta - yym2875 := z.EncBinary() - _ = yym2875 + yy2890 := &x.ListMeta + yym2891 := z.EncBinary() + _ = yym2891 if false { - } else if z.HasExtensions() && z.EncExt(yy2874) { + } else if z.HasExtensions() && z.EncExt(yy2890) { } else { - z.EncFallback(yy2874) + z.EncFallback(yy2890) } } } - if yyr2864 || yy2arr2864 { + if yyr2880 || yy2arr2880 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym2877 := z.EncBinary() - _ = yym2877 + yym2893 := z.EncBinary() + _ = yym2893 if false { } else { h.encSliceEndpoints(([]Endpoints)(x.Items), e) @@ -37052,15 +37255,15 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym2878 := z.EncBinary() - _ = yym2878 + yym2894 := z.EncBinary() + _ = yym2894 if false { } else { h.encSliceEndpoints(([]Endpoints)(x.Items), e) } } } - if yyr2864 || yy2arr2864 { + if yyr2880 || yy2arr2880 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -37073,25 +37276,25 @@ func (x *EndpointsList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2879 := z.DecBinary() - _ = yym2879 + yym2895 := z.DecBinary() + _ = yym2895 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2880 := r.ContainerType() - if yyct2880 == codecSelferValueTypeMap1234 { - yyl2880 := r.ReadMapStart() - if yyl2880 == 0 { + yyct2896 := r.ContainerType() + if yyct2896 == codecSelferValueTypeMap1234 { + yyl2896 := r.ReadMapStart() + if yyl2896 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2880, d) + x.codecDecodeSelfFromMap(yyl2896, d) } - } else if yyct2880 == codecSelferValueTypeArray1234 { - yyl2880 := r.ReadArrayStart() - if yyl2880 == 0 { + } else if yyct2896 == codecSelferValueTypeArray1234 { + yyl2896 := r.ReadArrayStart() + if yyl2896 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2880, d) + x.codecDecodeSelfFromArray(yyl2896, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -37103,12 +37306,12 @@ func (x *EndpointsList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2881Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2881Slc - var yyhl2881 bool = l >= 0 - for yyj2881 := 0; ; yyj2881++ { - if yyhl2881 { - if yyj2881 >= l { + var yys2897Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2897Slc + var yyhl2897 bool = l >= 0 + for yyj2897 := 0; ; yyj2897++ { + if yyhl2897 { + if yyj2897 >= l { break } } else { @@ -37117,10 +37320,10 @@ func (x *EndpointsList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2881Slc = r.DecodeBytes(yys2881Slc, true, true) - yys2881 := string(yys2881Slc) + yys2897Slc = r.DecodeBytes(yys2897Slc, true, true) + yys2897 := string(yys2897Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2881 { + switch yys2897 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -37137,31 +37340,31 @@ func (x *EndpointsList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2884 := &x.ListMeta - yym2885 := z.DecBinary() - _ = yym2885 + yyv2900 := &x.ListMeta + yym2901 := z.DecBinary() + _ = yym2901 if false { - } else if z.HasExtensions() && z.DecExt(yyv2884) { + } else if z.HasExtensions() && z.DecExt(yyv2900) { } else { - z.DecFallback(yyv2884, false) + z.DecFallback(yyv2900, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2886 := &x.Items - yym2887 := z.DecBinary() - _ = yym2887 + yyv2902 := &x.Items + yym2903 := z.DecBinary() + _ = yym2903 if false { } else { - h.decSliceEndpoints((*[]Endpoints)(yyv2886), d) + h.decSliceEndpoints((*[]Endpoints)(yyv2902), d) } } default: - z.DecStructFieldNotFound(-1, yys2881) - } // end switch yys2881 - } // end for yyj2881 + z.DecStructFieldNotFound(-1, yys2897) + } // end switch yys2897 + } // end for yyj2897 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -37169,16 +37372,16 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2888 int - var yyb2888 bool - var yyhl2888 bool = l >= 0 - yyj2888++ - if yyhl2888 { - yyb2888 = yyj2888 > l + var yyj2904 int + var yyb2904 bool + var yyhl2904 bool = l >= 0 + yyj2904++ + if yyhl2904 { + yyb2904 = yyj2904 > l } else { - yyb2888 = r.CheckBreak() + yyb2904 = r.CheckBreak() } - if yyb2888 { + if yyb2904 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37188,13 +37391,13 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj2888++ - if yyhl2888 { - yyb2888 = yyj2888 > l + yyj2904++ + if yyhl2904 { + yyb2904 = yyj2904 > l } else { - yyb2888 = r.CheckBreak() + yyb2904 = r.CheckBreak() } - if yyb2888 { + if yyb2904 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37204,13 +37407,13 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj2888++ - if yyhl2888 { - yyb2888 = yyj2888 > l + yyj2904++ + if yyhl2904 { + yyb2904 = yyj2904 > l } else { - yyb2888 = r.CheckBreak() + yyb2904 = r.CheckBreak() } - if yyb2888 { + if yyb2904 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37218,22 +37421,22 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv2891 := &x.ListMeta - yym2892 := z.DecBinary() - _ = yym2892 + yyv2907 := &x.ListMeta + yym2908 := z.DecBinary() + _ = yym2908 if false { - } else if z.HasExtensions() && z.DecExt(yyv2891) { + } else if z.HasExtensions() && z.DecExt(yyv2907) { } else { - z.DecFallback(yyv2891, false) + z.DecFallback(yyv2907, false) } } - yyj2888++ - if yyhl2888 { - yyb2888 = yyj2888 > l + yyj2904++ + if yyhl2904 { + yyb2904 = yyj2904 > l } else { - yyb2888 = r.CheckBreak() + yyb2904 = r.CheckBreak() } - if yyb2888 { + if yyb2904 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37241,26 +37444,26 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv2893 := &x.Items - yym2894 := z.DecBinary() - _ = yym2894 + yyv2909 := &x.Items + yym2910 := z.DecBinary() + _ = yym2910 if false { } else { - h.decSliceEndpoints((*[]Endpoints)(yyv2893), d) + h.decSliceEndpoints((*[]Endpoints)(yyv2909), d) } } for { - yyj2888++ - if yyhl2888 { - yyb2888 = yyj2888 > l + yyj2904++ + if yyhl2904 { + yyb2904 = yyj2904 > l } else { - yyb2888 = r.CheckBreak() + yyb2904 = r.CheckBreak() } - if yyb2888 { + if yyb2904 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2888-1, "") + z.DecStructFieldNotFound(yyj2904-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -37272,38 +37475,38 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2895 := z.EncBinary() - _ = yym2895 + yym2911 := z.EncBinary() + _ = yym2911 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2896 := !z.EncBinary() - yy2arr2896 := z.EncBasicHandle().StructToArray - var yyq2896 [4]bool - _, _, _ = yysep2896, yyq2896, yy2arr2896 - const yyr2896 bool = false - yyq2896[0] = x.PodCIDR != "" - yyq2896[1] = x.ExternalID != "" - yyq2896[2] = x.ProviderID != "" - yyq2896[3] = x.Unschedulable != false - var yynn2896 int - if yyr2896 || yy2arr2896 { + yysep2912 := !z.EncBinary() + yy2arr2912 := z.EncBasicHandle().StructToArray + var yyq2912 [4]bool + _, _, _ = yysep2912, yyq2912, yy2arr2912 + const yyr2912 bool = false + yyq2912[0] = x.PodCIDR != "" + yyq2912[1] = x.ExternalID != "" + yyq2912[2] = x.ProviderID != "" + yyq2912[3] = x.Unschedulable != false + var yynn2912 int + if yyr2912 || yy2arr2912 { r.EncodeArrayStart(4) } else { - yynn2896 = 0 - for _, b := range yyq2896 { + yynn2912 = 0 + for _, b := range yyq2912 { if b { - yynn2896++ + yynn2912++ } } - r.EncodeMapStart(yynn2896) - yynn2896 = 0 + r.EncodeMapStart(yynn2912) + yynn2912 = 0 } - if yyr2896 || yy2arr2896 { + if yyr2912 || yy2arr2912 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2896[0] { - yym2898 := z.EncBinary() - _ = yym2898 + if yyq2912[0] { + yym2914 := z.EncBinary() + _ = yym2914 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR)) @@ -37312,23 +37515,23 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2896[0] { + if yyq2912[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("podCIDR")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2899 := z.EncBinary() - _ = yym2899 + yym2915 := z.EncBinary() + _ = yym2915 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR)) } } } - if yyr2896 || yy2arr2896 { + if yyr2912 || yy2arr2912 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2896[1] { - yym2901 := z.EncBinary() - _ = yym2901 + if yyq2912[1] { + yym2917 := z.EncBinary() + _ = yym2917 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ExternalID)) @@ -37337,23 +37540,23 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2896[1] { + if yyq2912[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("externalID")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2902 := z.EncBinary() - _ = yym2902 + yym2918 := z.EncBinary() + _ = yym2918 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ExternalID)) } } } - if yyr2896 || yy2arr2896 { + if yyr2912 || yy2arr2912 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2896[2] { - yym2904 := z.EncBinary() - _ = yym2904 + if yyq2912[2] { + yym2920 := z.EncBinary() + _ = yym2920 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ProviderID)) @@ -37362,23 +37565,23 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq2896[2] { + if yyq2912[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("providerID")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2905 := z.EncBinary() - _ = yym2905 + yym2921 := z.EncBinary() + _ = yym2921 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ProviderID)) } } } - if yyr2896 || yy2arr2896 { + if yyr2912 || yy2arr2912 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2896[3] { - yym2907 := z.EncBinary() - _ = yym2907 + if yyq2912[3] { + yym2923 := z.EncBinary() + _ = yym2923 if false { } else { r.EncodeBool(bool(x.Unschedulable)) @@ -37387,19 +37590,19 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeBool(false) } } else { - if yyq2896[3] { + if yyq2912[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("unschedulable")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2908 := z.EncBinary() - _ = yym2908 + yym2924 := z.EncBinary() + _ = yym2924 if false { } else { r.EncodeBool(bool(x.Unschedulable)) } } } - if yyr2896 || yy2arr2896 { + if yyr2912 || yy2arr2912 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -37412,25 +37615,25 @@ func (x *NodeSpec) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2909 := z.DecBinary() - _ = yym2909 + yym2925 := z.DecBinary() + _ = yym2925 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2910 := r.ContainerType() - if yyct2910 == codecSelferValueTypeMap1234 { - yyl2910 := r.ReadMapStart() - if yyl2910 == 0 { + yyct2926 := r.ContainerType() + if yyct2926 == codecSelferValueTypeMap1234 { + yyl2926 := r.ReadMapStart() + if yyl2926 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2910, d) + x.codecDecodeSelfFromMap(yyl2926, d) } - } else if yyct2910 == codecSelferValueTypeArray1234 { - yyl2910 := r.ReadArrayStart() - if yyl2910 == 0 { + } else if yyct2926 == codecSelferValueTypeArray1234 { + yyl2926 := r.ReadArrayStart() + if yyl2926 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2910, d) + x.codecDecodeSelfFromArray(yyl2926, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -37442,12 +37645,12 @@ func (x *NodeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2911Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2911Slc - var yyhl2911 bool = l >= 0 - for yyj2911 := 0; ; yyj2911++ { - if yyhl2911 { - if yyj2911 >= l { + var yys2927Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2927Slc + var yyhl2927 bool = l >= 0 + for yyj2927 := 0; ; yyj2927++ { + if yyhl2927 { + if yyj2927 >= l { break } } else { @@ -37456,10 +37659,10 @@ func (x *NodeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2911Slc = r.DecodeBytes(yys2911Slc, true, true) - yys2911 := string(yys2911Slc) + yys2927Slc = r.DecodeBytes(yys2927Slc, true, true) + yys2927 := string(yys2927Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2911 { + switch yys2927 { case "podCIDR": if r.TryDecodeAsNil() { x.PodCIDR = "" @@ -37485,9 +37688,9 @@ func (x *NodeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Unschedulable = bool(r.DecodeBool()) } default: - z.DecStructFieldNotFound(-1, yys2911) - } // end switch yys2911 - } // end for yyj2911 + z.DecStructFieldNotFound(-1, yys2927) + } // end switch yys2927 + } // end for yyj2927 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -37495,16 +37698,16 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2916 int - var yyb2916 bool - var yyhl2916 bool = l >= 0 - yyj2916++ - if yyhl2916 { - yyb2916 = yyj2916 > l + var yyj2932 int + var yyb2932 bool + var yyhl2932 bool = l >= 0 + yyj2932++ + if yyhl2932 { + yyb2932 = yyj2932 > l } else { - yyb2916 = r.CheckBreak() + yyb2932 = r.CheckBreak() } - if yyb2916 { + if yyb2932 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37514,13 +37717,13 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.PodCIDR = string(r.DecodeString()) } - yyj2916++ - if yyhl2916 { - yyb2916 = yyj2916 > l + yyj2932++ + if yyhl2932 { + yyb2932 = yyj2932 > l } else { - yyb2916 = r.CheckBreak() + yyb2932 = r.CheckBreak() } - if yyb2916 { + if yyb2932 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37530,13 +37733,13 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.ExternalID = string(r.DecodeString()) } - yyj2916++ - if yyhl2916 { - yyb2916 = yyj2916 > l + yyj2932++ + if yyhl2932 { + yyb2932 = yyj2932 > l } else { - yyb2916 = r.CheckBreak() + yyb2932 = r.CheckBreak() } - if yyb2916 { + if yyb2932 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37546,13 +37749,13 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.ProviderID = string(r.DecodeString()) } - yyj2916++ - if yyhl2916 { - yyb2916 = yyj2916 > l + yyj2932++ + if yyhl2932 { + yyb2932 = yyj2932 > l } else { - yyb2916 = r.CheckBreak() + yyb2932 = r.CheckBreak() } - if yyb2916 { + if yyb2932 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37563,17 +37766,17 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Unschedulable = bool(r.DecodeBool()) } for { - yyj2916++ - if yyhl2916 { - yyb2916 = yyj2916 > l + yyj2932++ + if yyhl2932 { + yyb2932 = yyj2932 > l } else { - yyb2916 = r.CheckBreak() + yyb2932 = r.CheckBreak() } - if yyb2916 { + if yyb2932 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2916-1, "") + z.DecStructFieldNotFound(yyj2932-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -37585,33 +37788,33 @@ func (x *DaemonEndpoint) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2921 := z.EncBinary() - _ = yym2921 + yym2937 := z.EncBinary() + _ = yym2937 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2922 := !z.EncBinary() - yy2arr2922 := z.EncBasicHandle().StructToArray - var yyq2922 [1]bool - _, _, _ = yysep2922, yyq2922, yy2arr2922 - const yyr2922 bool = false - var yynn2922 int - if yyr2922 || yy2arr2922 { + yysep2938 := !z.EncBinary() + yy2arr2938 := z.EncBasicHandle().StructToArray + var yyq2938 [1]bool + _, _, _ = yysep2938, yyq2938, yy2arr2938 + const yyr2938 bool = false + var yynn2938 int + if yyr2938 || yy2arr2938 { r.EncodeArrayStart(1) } else { - yynn2922 = 1 - for _, b := range yyq2922 { + yynn2938 = 1 + for _, b := range yyq2938 { if b { - yynn2922++ + yynn2938++ } } - r.EncodeMapStart(yynn2922) - yynn2922 = 0 + r.EncodeMapStart(yynn2938) + yynn2938 = 0 } - if yyr2922 || yy2arr2922 { + if yyr2938 || yy2arr2938 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2924 := z.EncBinary() - _ = yym2924 + yym2940 := z.EncBinary() + _ = yym2940 if false { } else { r.EncodeInt(int64(x.Port)) @@ -37620,14 +37823,14 @@ func (x *DaemonEndpoint) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Port")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2925 := z.EncBinary() - _ = yym2925 + yym2941 := z.EncBinary() + _ = yym2941 if false { } else { r.EncodeInt(int64(x.Port)) } } - if yyr2922 || yy2arr2922 { + if yyr2938 || yy2arr2938 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -37640,25 +37843,25 @@ func (x *DaemonEndpoint) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2926 := z.DecBinary() - _ = yym2926 + yym2942 := z.DecBinary() + _ = yym2942 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2927 := r.ContainerType() - if yyct2927 == codecSelferValueTypeMap1234 { - yyl2927 := r.ReadMapStart() - if yyl2927 == 0 { + yyct2943 := r.ContainerType() + if yyct2943 == codecSelferValueTypeMap1234 { + yyl2943 := r.ReadMapStart() + if yyl2943 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2927, d) + x.codecDecodeSelfFromMap(yyl2943, d) } - } else if yyct2927 == codecSelferValueTypeArray1234 { - yyl2927 := r.ReadArrayStart() - if yyl2927 == 0 { + } else if yyct2943 == codecSelferValueTypeArray1234 { + yyl2943 := r.ReadArrayStart() + if yyl2943 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2927, d) + x.codecDecodeSelfFromArray(yyl2943, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -37670,12 +37873,12 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2928Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2928Slc - var yyhl2928 bool = l >= 0 - for yyj2928 := 0; ; yyj2928++ { - if yyhl2928 { - if yyj2928 >= l { + var yys2944Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2944Slc + var yyhl2944 bool = l >= 0 + for yyj2944 := 0; ; yyj2944++ { + if yyhl2944 { + if yyj2944 >= l { break } } else { @@ -37684,10 +37887,10 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2928Slc = r.DecodeBytes(yys2928Slc, true, true) - yys2928 := string(yys2928Slc) + yys2944Slc = r.DecodeBytes(yys2944Slc, true, true) + yys2944 := string(yys2944Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2928 { + switch yys2944 { case "Port": if r.TryDecodeAsNil() { x.Port = 0 @@ -37695,9 +37898,9 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Port = int32(r.DecodeInt(32)) } default: - z.DecStructFieldNotFound(-1, yys2928) - } // end switch yys2928 - } // end for yyj2928 + z.DecStructFieldNotFound(-1, yys2944) + } // end switch yys2944 + } // end for yyj2944 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -37705,16 +37908,16 @@ func (x *DaemonEndpoint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2930 int - var yyb2930 bool - var yyhl2930 bool = l >= 0 - yyj2930++ - if yyhl2930 { - yyb2930 = yyj2930 > l + var yyj2946 int + var yyb2946 bool + var yyhl2946 bool = l >= 0 + yyj2946++ + if yyhl2946 { + yyb2946 = yyj2946 > l } else { - yyb2930 = r.CheckBreak() + yyb2946 = r.CheckBreak() } - if yyb2930 { + if yyb2946 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37725,17 +37928,17 @@ func (x *DaemonEndpoint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Port = int32(r.DecodeInt(32)) } for { - yyj2930++ - if yyhl2930 { - yyb2930 = yyj2930 > l + yyj2946++ + if yyhl2946 { + yyb2946 = yyj2946 > l } else { - yyb2930 = r.CheckBreak() + yyb2946 = r.CheckBreak() } - if yyb2930 { + if yyb2946 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2930-1, "") + z.DecStructFieldNotFound(yyj2946-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -37747,48 +37950,48 @@ func (x *NodeDaemonEndpoints) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2932 := z.EncBinary() - _ = yym2932 + yym2948 := z.EncBinary() + _ = yym2948 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2933 := !z.EncBinary() - yy2arr2933 := z.EncBasicHandle().StructToArray - var yyq2933 [1]bool - _, _, _ = yysep2933, yyq2933, yy2arr2933 - const yyr2933 bool = false - yyq2933[0] = true - var yynn2933 int - if yyr2933 || yy2arr2933 { + yysep2949 := !z.EncBinary() + yy2arr2949 := z.EncBasicHandle().StructToArray + var yyq2949 [1]bool + _, _, _ = yysep2949, yyq2949, yy2arr2949 + const yyr2949 bool = false + yyq2949[0] = true + var yynn2949 int + if yyr2949 || yy2arr2949 { r.EncodeArrayStart(1) } else { - yynn2933 = 0 - for _, b := range yyq2933 { + yynn2949 = 0 + for _, b := range yyq2949 { if b { - yynn2933++ + yynn2949++ } } - r.EncodeMapStart(yynn2933) - yynn2933 = 0 + r.EncodeMapStart(yynn2949) + yynn2949 = 0 } - if yyr2933 || yy2arr2933 { + if yyr2949 || yy2arr2949 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq2933[0] { - yy2935 := &x.KubeletEndpoint - yy2935.CodecEncodeSelf(e) + if yyq2949[0] { + yy2951 := &x.KubeletEndpoint + yy2951.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq2933[0] { + if yyq2949[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeletEndpoint")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy2936 := &x.KubeletEndpoint - yy2936.CodecEncodeSelf(e) + yy2952 := &x.KubeletEndpoint + yy2952.CodecEncodeSelf(e) } } - if yyr2933 || yy2arr2933 { + if yyr2949 || yy2arr2949 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -37801,25 +38004,25 @@ func (x *NodeDaemonEndpoints) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2937 := z.DecBinary() - _ = yym2937 + yym2953 := z.DecBinary() + _ = yym2953 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2938 := r.ContainerType() - if yyct2938 == codecSelferValueTypeMap1234 { - yyl2938 := r.ReadMapStart() - if yyl2938 == 0 { + yyct2954 := r.ContainerType() + if yyct2954 == codecSelferValueTypeMap1234 { + yyl2954 := r.ReadMapStart() + if yyl2954 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2938, d) + x.codecDecodeSelfFromMap(yyl2954, d) } - } else if yyct2938 == codecSelferValueTypeArray1234 { - yyl2938 := r.ReadArrayStart() - if yyl2938 == 0 { + } else if yyct2954 == codecSelferValueTypeArray1234 { + yyl2954 := r.ReadArrayStart() + if yyl2954 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2938, d) + x.codecDecodeSelfFromArray(yyl2954, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -37831,12 +38034,12 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2939Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2939Slc - var yyhl2939 bool = l >= 0 - for yyj2939 := 0; ; yyj2939++ { - if yyhl2939 { - if yyj2939 >= l { + var yys2955Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2955Slc + var yyhl2955 bool = l >= 0 + for yyj2955 := 0; ; yyj2955++ { + if yyhl2955 { + if yyj2955 >= l { break } } else { @@ -37845,21 +38048,21 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2939Slc = r.DecodeBytes(yys2939Slc, true, true) - yys2939 := string(yys2939Slc) + yys2955Slc = r.DecodeBytes(yys2955Slc, true, true) + yys2955 := string(yys2955Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2939 { + switch yys2955 { case "kubeletEndpoint": if r.TryDecodeAsNil() { x.KubeletEndpoint = DaemonEndpoint{} } else { - yyv2940 := &x.KubeletEndpoint - yyv2940.CodecDecodeSelf(d) + yyv2956 := &x.KubeletEndpoint + yyv2956.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys2939) - } // end switch yys2939 - } // end for yyj2939 + z.DecStructFieldNotFound(-1, yys2955) + } // end switch yys2955 + } // end for yyj2955 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -37867,16 +38070,16 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2941 int - var yyb2941 bool - var yyhl2941 bool = l >= 0 - yyj2941++ - if yyhl2941 { - yyb2941 = yyj2941 > l + var yyj2957 int + var yyb2957 bool + var yyhl2957 bool = l >= 0 + yyj2957++ + if yyhl2957 { + yyb2957 = yyj2957 > l } else { - yyb2941 = r.CheckBreak() + yyb2957 = r.CheckBreak() } - if yyb2941 { + if yyb2957 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -37884,21 +38087,21 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.KubeletEndpoint = DaemonEndpoint{} } else { - yyv2942 := &x.KubeletEndpoint - yyv2942.CodecDecodeSelf(d) + yyv2958 := &x.KubeletEndpoint + yyv2958.CodecDecodeSelf(d) } for { - yyj2941++ - if yyhl2941 { - yyb2941 = yyj2941 > l + yyj2957++ + if yyhl2957 { + yyb2957 = yyj2957 > l } else { - yyb2941 = r.CheckBreak() + yyb2957 = r.CheckBreak() } - if yyb2941 { + if yyb2957 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2941-1, "") + z.DecStructFieldNotFound(yyj2957-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -37910,33 +38113,33 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2943 := z.EncBinary() - _ = yym2943 + yym2959 := z.EncBinary() + _ = yym2959 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep2944 := !z.EncBinary() - yy2arr2944 := z.EncBasicHandle().StructToArray - var yyq2944 [10]bool - _, _, _ = yysep2944, yyq2944, yy2arr2944 - const yyr2944 bool = false - var yynn2944 int - if yyr2944 || yy2arr2944 { + yysep2960 := !z.EncBinary() + yy2arr2960 := z.EncBasicHandle().StructToArray + var yyq2960 [10]bool + _, _, _ = yysep2960, yyq2960, yy2arr2960 + const yyr2960 bool = false + var yynn2960 int + if yyr2960 || yy2arr2960 { r.EncodeArrayStart(10) } else { - yynn2944 = 10 - for _, b := range yyq2944 { + yynn2960 = 10 + for _, b := range yyq2960 { if b { - yynn2944++ + yynn2960++ } } - r.EncodeMapStart(yynn2944) - yynn2944 = 0 + r.EncodeMapStart(yynn2960) + yynn2960 = 0 } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2946 := z.EncBinary() - _ = yym2946 + yym2962 := z.EncBinary() + _ = yym2962 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.MachineID)) @@ -37945,17 +38148,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("machineID")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2947 := z.EncBinary() - _ = yym2947 + yym2963 := z.EncBinary() + _ = yym2963 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.MachineID)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2949 := z.EncBinary() - _ = yym2949 + yym2965 := z.EncBinary() + _ = yym2965 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.SystemUUID)) @@ -37964,17 +38167,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("systemUUID")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2950 := z.EncBinary() - _ = yym2950 + yym2966 := z.EncBinary() + _ = yym2966 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.SystemUUID)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2952 := z.EncBinary() - _ = yym2952 + yym2968 := z.EncBinary() + _ = yym2968 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.BootID)) @@ -37983,17 +38186,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("bootID")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2953 := z.EncBinary() - _ = yym2953 + yym2969 := z.EncBinary() + _ = yym2969 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.BootID)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2955 := z.EncBinary() - _ = yym2955 + yym2971 := z.EncBinary() + _ = yym2971 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.KernelVersion)) @@ -38002,17 +38205,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kernelVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2956 := z.EncBinary() - _ = yym2956 + yym2972 := z.EncBinary() + _ = yym2972 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.KernelVersion)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2958 := z.EncBinary() - _ = yym2958 + yym2974 := z.EncBinary() + _ = yym2974 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.OSImage)) @@ -38021,17 +38224,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("osImage")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2959 := z.EncBinary() - _ = yym2959 + yym2975 := z.EncBinary() + _ = yym2975 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.OSImage)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2961 := z.EncBinary() - _ = yym2961 + yym2977 := z.EncBinary() + _ = yym2977 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntimeVersion)) @@ -38040,17 +38243,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("containerRuntimeVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2962 := z.EncBinary() - _ = yym2962 + yym2978 := z.EncBinary() + _ = yym2978 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntimeVersion)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2964 := z.EncBinary() - _ = yym2964 + yym2980 := z.EncBinary() + _ = yym2980 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.KubeletVersion)) @@ -38059,17 +38262,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeletVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2965 := z.EncBinary() - _ = yym2965 + yym2981 := z.EncBinary() + _ = yym2981 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.KubeletVersion)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2967 := z.EncBinary() - _ = yym2967 + yym2983 := z.EncBinary() + _ = yym2983 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.KubeProxyVersion)) @@ -38078,17 +38281,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeProxyVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2968 := z.EncBinary() - _ = yym2968 + yym2984 := z.EncBinary() + _ = yym2984 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.KubeProxyVersion)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2970 := z.EncBinary() - _ = yym2970 + yym2986 := z.EncBinary() + _ = yym2986 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem)) @@ -38097,17 +38300,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("operatingSystem")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2971 := z.EncBinary() - _ = yym2971 + yym2987 := z.EncBinary() + _ = yym2987 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym2973 := z.EncBinary() - _ = yym2973 + yym2989 := z.EncBinary() + _ = yym2989 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Architecture)) @@ -38116,14 +38319,14 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("architecture")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym2974 := z.EncBinary() - _ = yym2974 + yym2990 := z.EncBinary() + _ = yym2990 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Architecture)) } } - if yyr2944 || yy2arr2944 { + if yyr2960 || yy2arr2960 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -38136,25 +38339,25 @@ func (x *NodeSystemInfo) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym2975 := z.DecBinary() - _ = yym2975 + yym2991 := z.DecBinary() + _ = yym2991 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct2976 := r.ContainerType() - if yyct2976 == codecSelferValueTypeMap1234 { - yyl2976 := r.ReadMapStart() - if yyl2976 == 0 { + yyct2992 := r.ContainerType() + if yyct2992 == codecSelferValueTypeMap1234 { + yyl2992 := r.ReadMapStart() + if yyl2992 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl2976, d) + x.codecDecodeSelfFromMap(yyl2992, d) } - } else if yyct2976 == codecSelferValueTypeArray1234 { - yyl2976 := r.ReadArrayStart() - if yyl2976 == 0 { + } else if yyct2992 == codecSelferValueTypeArray1234 { + yyl2992 := r.ReadArrayStart() + if yyl2992 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl2976, d) + x.codecDecodeSelfFromArray(yyl2992, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -38166,12 +38369,12 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys2977Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys2977Slc - var yyhl2977 bool = l >= 0 - for yyj2977 := 0; ; yyj2977++ { - if yyhl2977 { - if yyj2977 >= l { + var yys2993Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys2993Slc + var yyhl2993 bool = l >= 0 + for yyj2993 := 0; ; yyj2993++ { + if yyhl2993 { + if yyj2993 >= l { break } } else { @@ -38180,10 +38383,10 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys2977Slc = r.DecodeBytes(yys2977Slc, true, true) - yys2977 := string(yys2977Slc) + yys2993Slc = r.DecodeBytes(yys2993Slc, true, true) + yys2993 := string(yys2993Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys2977 { + switch yys2993 { case "machineID": if r.TryDecodeAsNil() { x.MachineID = "" @@ -38245,9 +38448,9 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Architecture = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys2977) - } // end switch yys2977 - } // end for yyj2977 + z.DecStructFieldNotFound(-1, yys2993) + } // end switch yys2993 + } // end for yyj2993 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -38255,16 +38458,16 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj2988 int - var yyb2988 bool - var yyhl2988 bool = l >= 0 - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + var yyj3004 int + var yyb3004 bool + var yyhl3004 bool = l >= 0 + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38274,13 +38477,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.MachineID = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38290,13 +38493,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.SystemUUID = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38306,13 +38509,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.BootID = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38322,13 +38525,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.KernelVersion = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38338,13 +38541,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.OSImage = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38354,13 +38557,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.ContainerRuntimeVersion = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38370,13 +38573,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.KubeletVersion = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38386,13 +38589,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.KubeProxyVersion = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38402,13 +38605,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.OperatingSystem = string(r.DecodeString()) } - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38419,17 +38622,17 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Architecture = string(r.DecodeString()) } for { - yyj2988++ - if yyhl2988 { - yyb2988 = yyj2988 > l + yyj3004++ + if yyhl3004 { + yyb3004 = yyj3004 > l } else { - yyb2988 = r.CheckBreak() + yyb3004 = r.CheckBreak() } - if yyb2988 { + if yyb3004 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj2988-1, "") + z.DecStructFieldNotFound(yyj3004-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -38441,42 +38644,42 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym2999 := z.EncBinary() - _ = yym2999 + yym3015 := z.EncBinary() + _ = yym3015 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3000 := !z.EncBinary() - yy2arr3000 := z.EncBasicHandle().StructToArray - var yyq3000 [10]bool - _, _, _ = yysep3000, yyq3000, yy2arr3000 - const yyr3000 bool = false - yyq3000[0] = len(x.Capacity) != 0 - yyq3000[1] = len(x.Allocatable) != 0 - yyq3000[2] = x.Phase != "" - yyq3000[3] = len(x.Conditions) != 0 - yyq3000[4] = len(x.Addresses) != 0 - yyq3000[5] = true - yyq3000[6] = true - yyq3000[7] = len(x.Images) != 0 - yyq3000[8] = len(x.VolumesInUse) != 0 - yyq3000[9] = len(x.VolumesAttached) != 0 - var yynn3000 int - if yyr3000 || yy2arr3000 { + yysep3016 := !z.EncBinary() + yy2arr3016 := z.EncBasicHandle().StructToArray + var yyq3016 [10]bool + _, _, _ = yysep3016, yyq3016, yy2arr3016 + const yyr3016 bool = false + yyq3016[0] = len(x.Capacity) != 0 + yyq3016[1] = len(x.Allocatable) != 0 + yyq3016[2] = x.Phase != "" + yyq3016[3] = len(x.Conditions) != 0 + yyq3016[4] = len(x.Addresses) != 0 + yyq3016[5] = true + yyq3016[6] = true + yyq3016[7] = len(x.Images) != 0 + yyq3016[8] = len(x.VolumesInUse) != 0 + yyq3016[9] = len(x.VolumesAttached) != 0 + var yynn3016 int + if yyr3016 || yy2arr3016 { r.EncodeArrayStart(10) } else { - yynn3000 = 0 - for _, b := range yyq3000 { + yynn3016 = 0 + for _, b := range yyq3016 { if b { - yynn3000++ + yynn3016++ } } - r.EncodeMapStart(yynn3000) - yynn3000 = 0 + r.EncodeMapStart(yynn3016) + yynn3016 = 0 } - if yyr3000 || yy2arr3000 { + if yyr3016 || yy2arr3016 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[0] { + if yyq3016[0] { if x.Capacity == nil { r.EncodeNil() } else { @@ -38486,7 +38689,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3000[0] { + if yyq3016[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("capacity")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -38497,9 +38700,9 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3000 || yy2arr3000 { + if yyr3016 || yy2arr3016 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[1] { + if yyq3016[1] { if x.Allocatable == nil { r.EncodeNil() } else { @@ -38509,7 +38712,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3000[1] { + if yyq3016[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("allocatable")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -38520,195 +38723,195 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3000 || yy2arr3000 { + if yyr3016 || yy2arr3016 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[2] { + if yyq3016[2] { x.Phase.CodecEncodeSelf(e) } else { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3000[2] { + if yyq3016[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("phase")) z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Phase.CodecEncodeSelf(e) } } - if yyr3000 || yy2arr3000 { + if yyr3016 || yy2arr3016 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[3] { + if yyq3016[3] { if x.Conditions == nil { r.EncodeNil() - } else { - yym3005 := z.EncBinary() - _ = yym3005 - if false { - } else { - h.encSliceNodeCondition(([]NodeCondition)(x.Conditions), e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq3000[3] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("conditions")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Conditions == nil { - r.EncodeNil() - } else { - yym3006 := z.EncBinary() - _ = yym3006 - if false { - } else { - h.encSliceNodeCondition(([]NodeCondition)(x.Conditions), e) - } - } - } - } - if yyr3000 || yy2arr3000 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[4] { - if x.Addresses == nil { - r.EncodeNil() - } else { - yym3008 := z.EncBinary() - _ = yym3008 - if false { - } else { - h.encSliceNodeAddress(([]NodeAddress)(x.Addresses), e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq3000[4] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("addresses")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Addresses == nil { - r.EncodeNil() - } else { - yym3009 := z.EncBinary() - _ = yym3009 - if false { - } else { - h.encSliceNodeAddress(([]NodeAddress)(x.Addresses), e) - } - } - } - } - if yyr3000 || yy2arr3000 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[5] { - yy3011 := &x.DaemonEndpoints - yy3011.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq3000[5] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("daemonEndpoints")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3012 := &x.DaemonEndpoints - yy3012.CodecEncodeSelf(e) - } - } - if yyr3000 || yy2arr3000 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[6] { - yy3014 := &x.NodeInfo - yy3014.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq3000[6] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("nodeInfo")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3015 := &x.NodeInfo - yy3015.CodecEncodeSelf(e) - } - } - if yyr3000 || yy2arr3000 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[7] { - if x.Images == nil { - r.EncodeNil() - } else { - yym3017 := z.EncBinary() - _ = yym3017 - if false { - } else { - h.encSliceContainerImage(([]ContainerImage)(x.Images), e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq3000[7] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("images")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Images == nil { - r.EncodeNil() - } else { - yym3018 := z.EncBinary() - _ = yym3018 - if false { - } else { - h.encSliceContainerImage(([]ContainerImage)(x.Images), e) - } - } - } - } - if yyr3000 || yy2arr3000 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[8] { - if x.VolumesInUse == nil { - r.EncodeNil() - } else { - yym3020 := z.EncBinary() - _ = yym3020 - if false { - } else { - h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq3000[8] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("volumesInUse")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.VolumesInUse == nil { - r.EncodeNil() } else { yym3021 := z.EncBinary() _ = yym3021 if false { + } else { + h.encSliceNodeCondition(([]NodeCondition)(x.Conditions), e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq3016[3] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("conditions")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Conditions == nil { + r.EncodeNil() + } else { + yym3022 := z.EncBinary() + _ = yym3022 + if false { + } else { + h.encSliceNodeCondition(([]NodeCondition)(x.Conditions), e) + } + } + } + } + if yyr3016 || yy2arr3016 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3016[4] { + if x.Addresses == nil { + r.EncodeNil() + } else { + yym3024 := z.EncBinary() + _ = yym3024 + if false { + } else { + h.encSliceNodeAddress(([]NodeAddress)(x.Addresses), e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq3016[4] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("addresses")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Addresses == nil { + r.EncodeNil() + } else { + yym3025 := z.EncBinary() + _ = yym3025 + if false { + } else { + h.encSliceNodeAddress(([]NodeAddress)(x.Addresses), e) + } + } + } + } + if yyr3016 || yy2arr3016 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3016[5] { + yy3027 := &x.DaemonEndpoints + yy3027.CodecEncodeSelf(e) + } else { + r.EncodeNil() + } + } else { + if yyq3016[5] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("daemonEndpoints")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3028 := &x.DaemonEndpoints + yy3028.CodecEncodeSelf(e) + } + } + if yyr3016 || yy2arr3016 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3016[6] { + yy3030 := &x.NodeInfo + yy3030.CodecEncodeSelf(e) + } else { + r.EncodeNil() + } + } else { + if yyq3016[6] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeInfo")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3031 := &x.NodeInfo + yy3031.CodecEncodeSelf(e) + } + } + if yyr3016 || yy2arr3016 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3016[7] { + if x.Images == nil { + r.EncodeNil() + } else { + yym3033 := z.EncBinary() + _ = yym3033 + if false { + } else { + h.encSliceContainerImage(([]ContainerImage)(x.Images), e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq3016[7] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("images")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Images == nil { + r.EncodeNil() + } else { + yym3034 := z.EncBinary() + _ = yym3034 + if false { + } else { + h.encSliceContainerImage(([]ContainerImage)(x.Images), e) + } + } + } + } + if yyr3016 || yy2arr3016 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3016[8] { + if x.VolumesInUse == nil { + r.EncodeNil() + } else { + yym3036 := z.EncBinary() + _ = yym3036 + if false { + } else { + h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq3016[8] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("volumesInUse")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.VolumesInUse == nil { + r.EncodeNil() + } else { + yym3037 := z.EncBinary() + _ = yym3037 + if false { } else { h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e) } } } } - if yyr3000 || yy2arr3000 { + if yyr3016 || yy2arr3016 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3000[9] { + if yyq3016[9] { if x.VolumesAttached == nil { r.EncodeNil() } else { - yym3023 := z.EncBinary() - _ = yym3023 + yym3039 := z.EncBinary() + _ = yym3039 if false { } else { h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e) @@ -38718,15 +38921,15 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3000[9] { + if yyq3016[9] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("volumesAttached")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.VolumesAttached == nil { r.EncodeNil() } else { - yym3024 := z.EncBinary() - _ = yym3024 + yym3040 := z.EncBinary() + _ = yym3040 if false { } else { h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e) @@ -38734,7 +38937,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3000 || yy2arr3000 { + if yyr3016 || yy2arr3016 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -38747,25 +38950,25 @@ func (x *NodeStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3025 := z.DecBinary() - _ = yym3025 + yym3041 := z.DecBinary() + _ = yym3041 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3026 := r.ContainerType() - if yyct3026 == codecSelferValueTypeMap1234 { - yyl3026 := r.ReadMapStart() - if yyl3026 == 0 { + yyct3042 := r.ContainerType() + if yyct3042 == codecSelferValueTypeMap1234 { + yyl3042 := r.ReadMapStart() + if yyl3042 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3026, d) + x.codecDecodeSelfFromMap(yyl3042, d) } - } else if yyct3026 == codecSelferValueTypeArray1234 { - yyl3026 := r.ReadArrayStart() - if yyl3026 == 0 { + } else if yyct3042 == codecSelferValueTypeArray1234 { + yyl3042 := r.ReadArrayStart() + if yyl3042 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3026, d) + x.codecDecodeSelfFromArray(yyl3042, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -38777,12 +38980,12 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3027Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3027Slc - var yyhl3027 bool = l >= 0 - for yyj3027 := 0; ; yyj3027++ { - if yyhl3027 { - if yyj3027 >= l { + var yys3043Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3043Slc + var yyhl3043 bool = l >= 0 + for yyj3043 := 0; ; yyj3043++ { + if yyhl3043 { + if yyj3043 >= l { break } } else { @@ -38791,23 +38994,23 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3027Slc = r.DecodeBytes(yys3027Slc, true, true) - yys3027 := string(yys3027Slc) + yys3043Slc = r.DecodeBytes(yys3043Slc, true, true) + yys3043 := string(yys3043Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3027 { + switch yys3043 { case "capacity": if r.TryDecodeAsNil() { x.Capacity = nil } else { - yyv3028 := &x.Capacity - yyv3028.CodecDecodeSelf(d) + yyv3044 := &x.Capacity + yyv3044.CodecDecodeSelf(d) } case "allocatable": if r.TryDecodeAsNil() { x.Allocatable = nil } else { - yyv3029 := &x.Allocatable - yyv3029.CodecDecodeSelf(d) + yyv3045 := &x.Allocatable + yyv3045.CodecDecodeSelf(d) } case "phase": if r.TryDecodeAsNil() { @@ -38819,80 +39022,80 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Conditions = nil } else { - yyv3031 := &x.Conditions - yym3032 := z.DecBinary() - _ = yym3032 + yyv3047 := &x.Conditions + yym3048 := z.DecBinary() + _ = yym3048 if false { } else { - h.decSliceNodeCondition((*[]NodeCondition)(yyv3031), d) + h.decSliceNodeCondition((*[]NodeCondition)(yyv3047), d) } } case "addresses": if r.TryDecodeAsNil() { x.Addresses = nil } else { - yyv3033 := &x.Addresses - yym3034 := z.DecBinary() - _ = yym3034 + yyv3049 := &x.Addresses + yym3050 := z.DecBinary() + _ = yym3050 if false { } else { - h.decSliceNodeAddress((*[]NodeAddress)(yyv3033), d) + h.decSliceNodeAddress((*[]NodeAddress)(yyv3049), d) } } case "daemonEndpoints": if r.TryDecodeAsNil() { x.DaemonEndpoints = NodeDaemonEndpoints{} } else { - yyv3035 := &x.DaemonEndpoints - yyv3035.CodecDecodeSelf(d) + yyv3051 := &x.DaemonEndpoints + yyv3051.CodecDecodeSelf(d) } case "nodeInfo": if r.TryDecodeAsNil() { x.NodeInfo = NodeSystemInfo{} } else { - yyv3036 := &x.NodeInfo - yyv3036.CodecDecodeSelf(d) + yyv3052 := &x.NodeInfo + yyv3052.CodecDecodeSelf(d) } case "images": if r.TryDecodeAsNil() { x.Images = nil } else { - yyv3037 := &x.Images - yym3038 := z.DecBinary() - _ = yym3038 + yyv3053 := &x.Images + yym3054 := z.DecBinary() + _ = yym3054 if false { } else { - h.decSliceContainerImage((*[]ContainerImage)(yyv3037), d) + h.decSliceContainerImage((*[]ContainerImage)(yyv3053), d) } } case "volumesInUse": if r.TryDecodeAsNil() { x.VolumesInUse = nil } else { - yyv3039 := &x.VolumesInUse - yym3040 := z.DecBinary() - _ = yym3040 + yyv3055 := &x.VolumesInUse + yym3056 := z.DecBinary() + _ = yym3056 if false { } else { - h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3039), d) + h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3055), d) } } case "volumesAttached": if r.TryDecodeAsNil() { x.VolumesAttached = nil } else { - yyv3041 := &x.VolumesAttached - yym3042 := z.DecBinary() - _ = yym3042 + yyv3057 := &x.VolumesAttached + yym3058 := z.DecBinary() + _ = yym3058 if false { } else { - h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3041), d) + h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3057), d) } } default: - z.DecStructFieldNotFound(-1, yys3027) - } // end switch yys3027 - } // end for yyj3027 + z.DecStructFieldNotFound(-1, yys3043) + } // end switch yys3043 + } // end for yyj3043 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -38900,16 +39103,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3043 int - var yyb3043 bool - var yyhl3043 bool = l >= 0 - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + var yyj3059 int + var yyb3059 bool + var yyhl3059 bool = l >= 0 + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38917,16 +39120,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Capacity = nil } else { - yyv3044 := &x.Capacity - yyv3044.CodecDecodeSelf(d) + yyv3060 := &x.Capacity + yyv3060.CodecDecodeSelf(d) } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38934,16 +39137,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Allocatable = nil } else { - yyv3045 := &x.Allocatable - yyv3045.CodecDecodeSelf(d) + yyv3061 := &x.Allocatable + yyv3061.CodecDecodeSelf(d) } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38953,13 +39156,13 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Phase = NodePhase(r.DecodeString()) } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38967,21 +39170,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Conditions = nil } else { - yyv3047 := &x.Conditions - yym3048 := z.DecBinary() - _ = yym3048 + yyv3063 := &x.Conditions + yym3064 := z.DecBinary() + _ = yym3064 if false { } else { - h.decSliceNodeCondition((*[]NodeCondition)(yyv3047), d) + h.decSliceNodeCondition((*[]NodeCondition)(yyv3063), d) } } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -38989,21 +39192,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Addresses = nil } else { - yyv3049 := &x.Addresses - yym3050 := z.DecBinary() - _ = yym3050 + yyv3065 := &x.Addresses + yym3066 := z.DecBinary() + _ = yym3066 if false { } else { - h.decSliceNodeAddress((*[]NodeAddress)(yyv3049), d) + h.decSliceNodeAddress((*[]NodeAddress)(yyv3065), d) } } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39011,16 +39214,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.DaemonEndpoints = NodeDaemonEndpoints{} } else { - yyv3051 := &x.DaemonEndpoints - yyv3051.CodecDecodeSelf(d) + yyv3067 := &x.DaemonEndpoints + yyv3067.CodecDecodeSelf(d) } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39028,16 +39231,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.NodeInfo = NodeSystemInfo{} } else { - yyv3052 := &x.NodeInfo - yyv3052.CodecDecodeSelf(d) + yyv3068 := &x.NodeInfo + yyv3068.CodecDecodeSelf(d) } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39045,21 +39248,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Images = nil } else { - yyv3053 := &x.Images - yym3054 := z.DecBinary() - _ = yym3054 + yyv3069 := &x.Images + yym3070 := z.DecBinary() + _ = yym3070 if false { } else { - h.decSliceContainerImage((*[]ContainerImage)(yyv3053), d) + h.decSliceContainerImage((*[]ContainerImage)(yyv3069), d) } } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39067,21 +39270,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.VolumesInUse = nil } else { - yyv3055 := &x.VolumesInUse - yym3056 := z.DecBinary() - _ = yym3056 + yyv3071 := &x.VolumesInUse + yym3072 := z.DecBinary() + _ = yym3072 if false { } else { - h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3055), d) + h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3071), d) } } - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39089,26 +39292,26 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.VolumesAttached = nil } else { - yyv3057 := &x.VolumesAttached - yym3058 := z.DecBinary() - _ = yym3058 + yyv3073 := &x.VolumesAttached + yym3074 := z.DecBinary() + _ = yym3074 if false { } else { - h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3057), d) + h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3073), d) } } for { - yyj3043++ - if yyhl3043 { - yyb3043 = yyj3043 > l + yyj3059++ + if yyhl3059 { + yyb3059 = yyj3059 > l } else { - yyb3043 = r.CheckBreak() + yyb3059 = r.CheckBreak() } - if yyb3043 { + if yyb3059 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3043-1, "") + z.DecStructFieldNotFound(yyj3059-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -39117,8 +39320,8 @@ func (x UniqueVolumeName) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3059 := z.EncBinary() - _ = yym3059 + yym3075 := z.EncBinary() + _ = yym3075 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -39130,8 +39333,8 @@ func (x *UniqueVolumeName) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3060 := z.DecBinary() - _ = yym3060 + yym3076 := z.DecBinary() + _ = yym3076 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -39146,30 +39349,30 @@ func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3061 := z.EncBinary() - _ = yym3061 + yym3077 := z.EncBinary() + _ = yym3077 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3062 := !z.EncBinary() - yy2arr3062 := z.EncBasicHandle().StructToArray - var yyq3062 [2]bool - _, _, _ = yysep3062, yyq3062, yy2arr3062 - const yyr3062 bool = false - var yynn3062 int - if yyr3062 || yy2arr3062 { + yysep3078 := !z.EncBinary() + yy2arr3078 := z.EncBasicHandle().StructToArray + var yyq3078 [2]bool + _, _, _ = yysep3078, yyq3078, yy2arr3078 + const yyr3078 bool = false + var yynn3078 int + if yyr3078 || yy2arr3078 { r.EncodeArrayStart(2) } else { - yynn3062 = 2 - for _, b := range yyq3062 { + yynn3078 = 2 + for _, b := range yyq3078 { if b { - yynn3062++ + yynn3078++ } } - r.EncodeMapStart(yynn3062) - yynn3062 = 0 + r.EncodeMapStart(yynn3078) + yynn3078 = 0 } - if yyr3062 || yy2arr3062 { + if yyr3078 || yy2arr3078 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Name.CodecEncodeSelf(e) } else { @@ -39178,10 +39381,10 @@ func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Name.CodecEncodeSelf(e) } - if yyr3062 || yy2arr3062 { + if yyr3078 || yy2arr3078 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3065 := z.EncBinary() - _ = yym3065 + yym3081 := z.EncBinary() + _ = yym3081 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath)) @@ -39190,14 +39393,14 @@ func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("devicePath")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3066 := z.EncBinary() - _ = yym3066 + yym3082 := z.EncBinary() + _ = yym3082 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath)) } } - if yyr3062 || yy2arr3062 { + if yyr3078 || yy2arr3078 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -39210,25 +39413,25 @@ func (x *AttachedVolume) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3067 := z.DecBinary() - _ = yym3067 + yym3083 := z.DecBinary() + _ = yym3083 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3068 := r.ContainerType() - if yyct3068 == codecSelferValueTypeMap1234 { - yyl3068 := r.ReadMapStart() - if yyl3068 == 0 { + yyct3084 := r.ContainerType() + if yyct3084 == codecSelferValueTypeMap1234 { + yyl3084 := r.ReadMapStart() + if yyl3084 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3068, d) + x.codecDecodeSelfFromMap(yyl3084, d) } - } else if yyct3068 == codecSelferValueTypeArray1234 { - yyl3068 := r.ReadArrayStart() - if yyl3068 == 0 { + } else if yyct3084 == codecSelferValueTypeArray1234 { + yyl3084 := r.ReadArrayStart() + if yyl3084 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3068, d) + x.codecDecodeSelfFromArray(yyl3084, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -39240,12 +39443,12 @@ func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3069Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3069Slc - var yyhl3069 bool = l >= 0 - for yyj3069 := 0; ; yyj3069++ { - if yyhl3069 { - if yyj3069 >= l { + var yys3085Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3085Slc + var yyhl3085 bool = l >= 0 + for yyj3085 := 0; ; yyj3085++ { + if yyhl3085 { + if yyj3085 >= l { break } } else { @@ -39254,10 +39457,10 @@ func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3069Slc = r.DecodeBytes(yys3069Slc, true, true) - yys3069 := string(yys3069Slc) + yys3085Slc = r.DecodeBytes(yys3085Slc, true, true) + yys3085 := string(yys3085Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3069 { + switch yys3085 { case "name": if r.TryDecodeAsNil() { x.Name = "" @@ -39271,9 +39474,9 @@ func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.DevicePath = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3069) - } // end switch yys3069 - } // end for yyj3069 + z.DecStructFieldNotFound(-1, yys3085) + } // end switch yys3085 + } // end for yyj3085 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -39281,16 +39484,16 @@ func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3072 int - var yyb3072 bool - var yyhl3072 bool = l >= 0 - yyj3072++ - if yyhl3072 { - yyb3072 = yyj3072 > l + var yyj3088 int + var yyb3088 bool + var yyhl3088 bool = l >= 0 + yyj3088++ + if yyhl3088 { + yyb3088 = yyj3088 > l } else { - yyb3072 = r.CheckBreak() + yyb3088 = r.CheckBreak() } - if yyb3072 { + if yyb3088 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39300,13 +39503,13 @@ func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Name = UniqueVolumeName(r.DecodeString()) } - yyj3072++ - if yyhl3072 { - yyb3072 = yyj3072 > l + yyj3088++ + if yyhl3088 { + yyb3088 = yyj3088 > l } else { - yyb3072 = r.CheckBreak() + yyb3088 = r.CheckBreak() } - if yyb3072 { + if yyb3088 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39317,17 +39520,17 @@ func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.DevicePath = string(r.DecodeString()) } for { - yyj3072++ - if yyhl3072 { - yyb3072 = yyj3072 > l + yyj3088++ + if yyhl3088 { + yyb3088 = yyj3088 > l } else { - yyb3072 = r.CheckBreak() + yyb3088 = r.CheckBreak() } - if yyb3072 { + if yyb3088 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3072-1, "") + z.DecStructFieldNotFound(yyj3088-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -39339,38 +39542,38 @@ func (x *AvoidPods) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3075 := z.EncBinary() - _ = yym3075 + yym3091 := z.EncBinary() + _ = yym3091 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3076 := !z.EncBinary() - yy2arr3076 := z.EncBasicHandle().StructToArray - var yyq3076 [1]bool - _, _, _ = yysep3076, yyq3076, yy2arr3076 - const yyr3076 bool = false - yyq3076[0] = len(x.PreferAvoidPods) != 0 - var yynn3076 int - if yyr3076 || yy2arr3076 { + yysep3092 := !z.EncBinary() + yy2arr3092 := z.EncBasicHandle().StructToArray + var yyq3092 [1]bool + _, _, _ = yysep3092, yyq3092, yy2arr3092 + const yyr3092 bool = false + yyq3092[0] = len(x.PreferAvoidPods) != 0 + var yynn3092 int + if yyr3092 || yy2arr3092 { r.EncodeArrayStart(1) } else { - yynn3076 = 0 - for _, b := range yyq3076 { + yynn3092 = 0 + for _, b := range yyq3092 { if b { - yynn3076++ + yynn3092++ } } - r.EncodeMapStart(yynn3076) - yynn3076 = 0 + r.EncodeMapStart(yynn3092) + yynn3092 = 0 } - if yyr3076 || yy2arr3076 { + if yyr3092 || yy2arr3092 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3076[0] { + if yyq3092[0] { if x.PreferAvoidPods == nil { r.EncodeNil() } else { - yym3078 := z.EncBinary() - _ = yym3078 + yym3094 := z.EncBinary() + _ = yym3094 if false { } else { h.encSlicePreferAvoidPodsEntry(([]PreferAvoidPodsEntry)(x.PreferAvoidPods), e) @@ -39380,15 +39583,15 @@ func (x *AvoidPods) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3076[0] { + if yyq3092[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("preferAvoidPods")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.PreferAvoidPods == nil { r.EncodeNil() } else { - yym3079 := z.EncBinary() - _ = yym3079 + yym3095 := z.EncBinary() + _ = yym3095 if false { } else { h.encSlicePreferAvoidPodsEntry(([]PreferAvoidPodsEntry)(x.PreferAvoidPods), e) @@ -39396,7 +39599,7 @@ func (x *AvoidPods) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3076 || yy2arr3076 { + if yyr3092 || yy2arr3092 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -39409,25 +39612,25 @@ func (x *AvoidPods) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3080 := z.DecBinary() - _ = yym3080 + yym3096 := z.DecBinary() + _ = yym3096 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3081 := r.ContainerType() - if yyct3081 == codecSelferValueTypeMap1234 { - yyl3081 := r.ReadMapStart() - if yyl3081 == 0 { + yyct3097 := r.ContainerType() + if yyct3097 == codecSelferValueTypeMap1234 { + yyl3097 := r.ReadMapStart() + if yyl3097 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3081, d) + x.codecDecodeSelfFromMap(yyl3097, d) } - } else if yyct3081 == codecSelferValueTypeArray1234 { - yyl3081 := r.ReadArrayStart() - if yyl3081 == 0 { + } else if yyct3097 == codecSelferValueTypeArray1234 { + yyl3097 := r.ReadArrayStart() + if yyl3097 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3081, d) + x.codecDecodeSelfFromArray(yyl3097, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -39439,12 +39642,12 @@ func (x *AvoidPods) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3082Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3082Slc - var yyhl3082 bool = l >= 0 - for yyj3082 := 0; ; yyj3082++ { - if yyhl3082 { - if yyj3082 >= l { + var yys3098Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3098Slc + var yyhl3098 bool = l >= 0 + for yyj3098 := 0; ; yyj3098++ { + if yyhl3098 { + if yyj3098 >= l { break } } else { @@ -39453,26 +39656,26 @@ func (x *AvoidPods) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3082Slc = r.DecodeBytes(yys3082Slc, true, true) - yys3082 := string(yys3082Slc) + yys3098Slc = r.DecodeBytes(yys3098Slc, true, true) + yys3098 := string(yys3098Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3082 { + switch yys3098 { case "preferAvoidPods": if r.TryDecodeAsNil() { x.PreferAvoidPods = nil } else { - yyv3083 := &x.PreferAvoidPods - yym3084 := z.DecBinary() - _ = yym3084 + yyv3099 := &x.PreferAvoidPods + yym3100 := z.DecBinary() + _ = yym3100 if false { } else { - h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3083), d) + h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3099), d) } } default: - z.DecStructFieldNotFound(-1, yys3082) - } // end switch yys3082 - } // end for yyj3082 + z.DecStructFieldNotFound(-1, yys3098) + } // end switch yys3098 + } // end for yyj3098 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -39480,16 +39683,16 @@ func (x *AvoidPods) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3085 int - var yyb3085 bool - var yyhl3085 bool = l >= 0 - yyj3085++ - if yyhl3085 { - yyb3085 = yyj3085 > l + var yyj3101 int + var yyb3101 bool + var yyhl3101 bool = l >= 0 + yyj3101++ + if yyhl3101 { + yyb3101 = yyj3101 > l } else { - yyb3085 = r.CheckBreak() + yyb3101 = r.CheckBreak() } - if yyb3085 { + if yyb3101 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39497,26 +39700,26 @@ func (x *AvoidPods) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.PreferAvoidPods = nil } else { - yyv3086 := &x.PreferAvoidPods - yym3087 := z.DecBinary() - _ = yym3087 + yyv3102 := &x.PreferAvoidPods + yym3103 := z.DecBinary() + _ = yym3103 if false { } else { - h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3086), d) + h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3102), d) } } for { - yyj3085++ - if yyhl3085 { - yyb3085 = yyj3085 > l + yyj3101++ + if yyhl3101 { + yyb3101 = yyj3101 > l } else { - yyb3085 = r.CheckBreak() + yyb3101 = r.CheckBreak() } - if yyb3085 { + if yyb3101 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3085-1, "") + z.DecStructFieldNotFound(yyj3101-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -39528,85 +39731,85 @@ func (x *PreferAvoidPodsEntry) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3088 := z.EncBinary() - _ = yym3088 + yym3104 := z.EncBinary() + _ = yym3104 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3089 := !z.EncBinary() - yy2arr3089 := z.EncBasicHandle().StructToArray - var yyq3089 [4]bool - _, _, _ = yysep3089, yyq3089, yy2arr3089 - const yyr3089 bool = false - yyq3089[1] = true - yyq3089[2] = x.Reason != "" - yyq3089[3] = x.Message != "" - var yynn3089 int - if yyr3089 || yy2arr3089 { + yysep3105 := !z.EncBinary() + yy2arr3105 := z.EncBasicHandle().StructToArray + var yyq3105 [4]bool + _, _, _ = yysep3105, yyq3105, yy2arr3105 + const yyr3105 bool = false + yyq3105[1] = true + yyq3105[2] = x.Reason != "" + yyq3105[3] = x.Message != "" + var yynn3105 int + if yyr3105 || yy2arr3105 { r.EncodeArrayStart(4) } else { - yynn3089 = 1 - for _, b := range yyq3089 { + yynn3105 = 1 + for _, b := range yyq3105 { if b { - yynn3089++ + yynn3105++ } } - r.EncodeMapStart(yynn3089) - yynn3089 = 0 + r.EncodeMapStart(yynn3105) + yynn3105 = 0 } - if yyr3089 || yy2arr3089 { + if yyr3105 || yy2arr3105 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy3091 := &x.PodSignature - yy3091.CodecEncodeSelf(e) + yy3107 := &x.PodSignature + yy3107.CodecEncodeSelf(e) } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("podSignature")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3092 := &x.PodSignature - yy3092.CodecEncodeSelf(e) + yy3108 := &x.PodSignature + yy3108.CodecEncodeSelf(e) } - if yyr3089 || yy2arr3089 { + if yyr3105 || yy2arr3105 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3089[1] { - yy3094 := &x.EvictionTime - yym3095 := z.EncBinary() - _ = yym3095 + if yyq3105[1] { + yy3110 := &x.EvictionTime + yym3111 := z.EncBinary() + _ = yym3111 if false { - } else if z.HasExtensions() && z.EncExt(yy3094) { - } else if yym3095 { - z.EncBinaryMarshal(yy3094) - } else if !yym3095 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3094) + } else if z.HasExtensions() && z.EncExt(yy3110) { + } else if yym3111 { + z.EncBinaryMarshal(yy3110) + } else if !yym3111 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3110) } else { - z.EncFallback(yy3094) + z.EncFallback(yy3110) } } else { r.EncodeNil() } } else { - if yyq3089[1] { + if yyq3105[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("evictionTime")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3096 := &x.EvictionTime - yym3097 := z.EncBinary() - _ = yym3097 + yy3112 := &x.EvictionTime + yym3113 := z.EncBinary() + _ = yym3113 if false { - } else if z.HasExtensions() && z.EncExt(yy3096) { - } else if yym3097 { - z.EncBinaryMarshal(yy3096) - } else if !yym3097 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3096) + } else if z.HasExtensions() && z.EncExt(yy3112) { + } else if yym3113 { + z.EncBinaryMarshal(yy3112) + } else if !yym3113 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3112) } else { - z.EncFallback(yy3096) + z.EncFallback(yy3112) } } } - if yyr3089 || yy2arr3089 { + if yyr3105 || yy2arr3105 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3089[2] { - yym3099 := z.EncBinary() - _ = yym3099 + if yyq3105[2] { + yym3115 := z.EncBinary() + _ = yym3115 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) @@ -39615,23 +39818,23 @@ func (x *PreferAvoidPodsEntry) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3089[2] { + if yyq3105[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("reason")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3100 := z.EncBinary() - _ = yym3100 + yym3116 := z.EncBinary() + _ = yym3116 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) } } } - if yyr3089 || yy2arr3089 { + if yyr3105 || yy2arr3105 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3089[3] { - yym3102 := z.EncBinary() - _ = yym3102 + if yyq3105[3] { + yym3118 := z.EncBinary() + _ = yym3118 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) @@ -39640,19 +39843,19 @@ func (x *PreferAvoidPodsEntry) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3089[3] { + if yyq3105[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("message")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3103 := z.EncBinary() - _ = yym3103 + yym3119 := z.EncBinary() + _ = yym3119 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) } } } - if yyr3089 || yy2arr3089 { + if yyr3105 || yy2arr3105 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -39665,25 +39868,25 @@ func (x *PreferAvoidPodsEntry) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3104 := z.DecBinary() - _ = yym3104 + yym3120 := z.DecBinary() + _ = yym3120 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3105 := r.ContainerType() - if yyct3105 == codecSelferValueTypeMap1234 { - yyl3105 := r.ReadMapStart() - if yyl3105 == 0 { + yyct3121 := r.ContainerType() + if yyct3121 == codecSelferValueTypeMap1234 { + yyl3121 := r.ReadMapStart() + if yyl3121 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3105, d) + x.codecDecodeSelfFromMap(yyl3121, d) } - } else if yyct3105 == codecSelferValueTypeArray1234 { - yyl3105 := r.ReadArrayStart() - if yyl3105 == 0 { + } else if yyct3121 == codecSelferValueTypeArray1234 { + yyl3121 := r.ReadArrayStart() + if yyl3121 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3105, d) + x.codecDecodeSelfFromArray(yyl3121, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -39695,12 +39898,12 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromMap(l int, d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3106Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3106Slc - var yyhl3106 bool = l >= 0 - for yyj3106 := 0; ; yyj3106++ { - if yyhl3106 { - if yyj3106 >= l { + var yys3122Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3122Slc + var yyhl3122 bool = l >= 0 + for yyj3122 := 0; ; yyj3122++ { + if yyhl3122 { + if yyj3122 >= l { break } } else { @@ -39709,32 +39912,32 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromMap(l int, d *codec1978.Decode } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3106Slc = r.DecodeBytes(yys3106Slc, true, true) - yys3106 := string(yys3106Slc) + yys3122Slc = r.DecodeBytes(yys3122Slc, true, true) + yys3122 := string(yys3122Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3106 { + switch yys3122 { case "podSignature": if r.TryDecodeAsNil() { x.PodSignature = PodSignature{} } else { - yyv3107 := &x.PodSignature - yyv3107.CodecDecodeSelf(d) + yyv3123 := &x.PodSignature + yyv3123.CodecDecodeSelf(d) } case "evictionTime": if r.TryDecodeAsNil() { x.EvictionTime = pkg2_unversioned.Time{} } else { - yyv3108 := &x.EvictionTime - yym3109 := z.DecBinary() - _ = yym3109 + yyv3124 := &x.EvictionTime + yym3125 := z.DecBinary() + _ = yym3125 if false { - } else if z.HasExtensions() && z.DecExt(yyv3108) { - } else if yym3109 { - z.DecBinaryUnmarshal(yyv3108) - } else if !yym3109 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3108) + } else if z.HasExtensions() && z.DecExt(yyv3124) { + } else if yym3125 { + z.DecBinaryUnmarshal(yyv3124) + } else if !yym3125 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3124) } else { - z.DecFallback(yyv3108, false) + z.DecFallback(yyv3124, false) } } case "reason": @@ -39750,9 +39953,9 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromMap(l int, d *codec1978.Decode x.Message = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3106) - } // end switch yys3106 - } // end for yyj3106 + z.DecStructFieldNotFound(-1, yys3122) + } // end switch yys3122 + } // end for yyj3122 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -39760,16 +39963,16 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3112 int - var yyb3112 bool - var yyhl3112 bool = l >= 0 - yyj3112++ - if yyhl3112 { - yyb3112 = yyj3112 > l + var yyj3128 int + var yyb3128 bool + var yyhl3128 bool = l >= 0 + yyj3128++ + if yyhl3128 { + yyb3128 = yyj3128 > l } else { - yyb3112 = r.CheckBreak() + yyb3128 = r.CheckBreak() } - if yyb3112 { + if yyb3128 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39777,16 +39980,16 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.PodSignature = PodSignature{} } else { - yyv3113 := &x.PodSignature - yyv3113.CodecDecodeSelf(d) + yyv3129 := &x.PodSignature + yyv3129.CodecDecodeSelf(d) } - yyj3112++ - if yyhl3112 { - yyb3112 = yyj3112 > l + yyj3128++ + if yyhl3128 { + yyb3128 = yyj3128 > l } else { - yyb3112 = r.CheckBreak() + yyb3128 = r.CheckBreak() } - if yyb3112 { + if yyb3128 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39794,26 +39997,26 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.EvictionTime = pkg2_unversioned.Time{} } else { - yyv3114 := &x.EvictionTime - yym3115 := z.DecBinary() - _ = yym3115 + yyv3130 := &x.EvictionTime + yym3131 := z.DecBinary() + _ = yym3131 if false { - } else if z.HasExtensions() && z.DecExt(yyv3114) { - } else if yym3115 { - z.DecBinaryUnmarshal(yyv3114) - } else if !yym3115 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3114) + } else if z.HasExtensions() && z.DecExt(yyv3130) { + } else if yym3131 { + z.DecBinaryUnmarshal(yyv3130) + } else if !yym3131 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3130) } else { - z.DecFallback(yyv3114, false) + z.DecFallback(yyv3130, false) } } - yyj3112++ - if yyhl3112 { - yyb3112 = yyj3112 > l + yyj3128++ + if yyhl3128 { + yyb3128 = yyj3128 > l } else { - yyb3112 = r.CheckBreak() + yyb3128 = r.CheckBreak() } - if yyb3112 { + if yyb3128 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39823,13 +40026,13 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.Reason = string(r.DecodeString()) } - yyj3112++ - if yyhl3112 { - yyb3112 = yyj3112 > l + yyj3128++ + if yyhl3128 { + yyb3128 = yyj3128 > l } else { - yyb3112 = r.CheckBreak() + yyb3128 = r.CheckBreak() } - if yyb3112 { + if yyb3128 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -39840,17 +40043,17 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco x.Message = string(r.DecodeString()) } for { - yyj3112++ - if yyhl3112 { - yyb3112 = yyj3112 > l + yyj3128++ + if yyhl3128 { + yyb3128 = yyj3128 > l } else { - yyb3112 = r.CheckBreak() + yyb3128 = r.CheckBreak() } - if yyb3112 { + if yyb3128 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3112-1, "") + z.DecStructFieldNotFound(yyj3128-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -39862,33 +40065,33 @@ func (x *PodSignature) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3118 := z.EncBinary() - _ = yym3118 + yym3134 := z.EncBinary() + _ = yym3134 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3119 := !z.EncBinary() - yy2arr3119 := z.EncBasicHandle().StructToArray - var yyq3119 [1]bool - _, _, _ = yysep3119, yyq3119, yy2arr3119 - const yyr3119 bool = false - yyq3119[0] = x.PodController != nil - var yynn3119 int - if yyr3119 || yy2arr3119 { + yysep3135 := !z.EncBinary() + yy2arr3135 := z.EncBasicHandle().StructToArray + var yyq3135 [1]bool + _, _, _ = yysep3135, yyq3135, yy2arr3135 + const yyr3135 bool = false + yyq3135[0] = x.PodController != nil + var yynn3135 int + if yyr3135 || yy2arr3135 { r.EncodeArrayStart(1) } else { - yynn3119 = 0 - for _, b := range yyq3119 { + yynn3135 = 0 + for _, b := range yyq3135 { if b { - yynn3119++ + yynn3135++ } } - r.EncodeMapStart(yynn3119) - yynn3119 = 0 + r.EncodeMapStart(yynn3135) + yynn3135 = 0 } - if yyr3119 || yy2arr3119 { + if yyr3135 || yy2arr3135 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3119[0] { + if yyq3135[0] { if x.PodController == nil { r.EncodeNil() } else { @@ -39898,7 +40101,7 @@ func (x *PodSignature) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3119[0] { + if yyq3135[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("podController")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -39909,7 +40112,7 @@ func (x *PodSignature) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3119 || yy2arr3119 { + if yyr3135 || yy2arr3135 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -39922,25 +40125,25 @@ func (x *PodSignature) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3121 := z.DecBinary() - _ = yym3121 + yym3137 := z.DecBinary() + _ = yym3137 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3122 := r.ContainerType() - if yyct3122 == codecSelferValueTypeMap1234 { - yyl3122 := r.ReadMapStart() - if yyl3122 == 0 { + yyct3138 := r.ContainerType() + if yyct3138 == codecSelferValueTypeMap1234 { + yyl3138 := r.ReadMapStart() + if yyl3138 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3122, d) + x.codecDecodeSelfFromMap(yyl3138, d) } - } else if yyct3122 == codecSelferValueTypeArray1234 { - yyl3122 := r.ReadArrayStart() - if yyl3122 == 0 { + } else if yyct3138 == codecSelferValueTypeArray1234 { + yyl3138 := r.ReadArrayStart() + if yyl3138 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3122, d) + x.codecDecodeSelfFromArray(yyl3138, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -39952,12 +40155,12 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3123Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3123Slc - var yyhl3123 bool = l >= 0 - for yyj3123 := 0; ; yyj3123++ { - if yyhl3123 { - if yyj3123 >= l { + var yys3139Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3139Slc + var yyhl3139 bool = l >= 0 + for yyj3139 := 0; ; yyj3139++ { + if yyhl3139 { + if yyj3139 >= l { break } } else { @@ -39966,10 +40169,10 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3123Slc = r.DecodeBytes(yys3123Slc, true, true) - yys3123 := string(yys3123Slc) + yys3139Slc = r.DecodeBytes(yys3139Slc, true, true) + yys3139 := string(yys3139Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3123 { + switch yys3139 { case "podController": if r.TryDecodeAsNil() { if x.PodController != nil { @@ -39982,226 +40185,13 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.PodController.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys3123) - } // end switch yys3123 - } // end for yyj3123 + z.DecStructFieldNotFound(-1, yys3139) + } // end switch yys3139 + } // end for yyj3139 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } func (x *PodSignature) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yyj3125 int - var yyb3125 bool - var yyhl3125 bool = l >= 0 - yyj3125++ - if yyhl3125 { - yyb3125 = yyj3125 > l - } else { - yyb3125 = r.CheckBreak() - } - if yyb3125 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - if x.PodController != nil { - x.PodController = nil - } - } else { - if x.PodController == nil { - x.PodController = new(OwnerReference) - } - x.PodController.CodecDecodeSelf(d) - } - for { - yyj3125++ - if yyhl3125 { - yyb3125 = yyj3125 > l - } else { - yyb3125 = r.CheckBreak() - } - if yyb3125 { - break - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3125-1, "") - } - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x *ContainerImage) CodecEncodeSelf(e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - if x == nil { - r.EncodeNil() - } else { - yym3127 := z.EncBinary() - _ = yym3127 - if false { - } else if z.HasExtensions() && z.EncExt(x) { - } else { - yysep3128 := !z.EncBinary() - yy2arr3128 := z.EncBasicHandle().StructToArray - var yyq3128 [2]bool - _, _, _ = yysep3128, yyq3128, yy2arr3128 - const yyr3128 bool = false - yyq3128[1] = x.SizeBytes != 0 - var yynn3128 int - if yyr3128 || yy2arr3128 { - r.EncodeArrayStart(2) - } else { - yynn3128 = 1 - for _, b := range yyq3128 { - if b { - yynn3128++ - } - } - r.EncodeMapStart(yynn3128) - yynn3128 = 0 - } - if yyr3128 || yy2arr3128 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if x.Names == nil { - r.EncodeNil() - } else { - yym3130 := z.EncBinary() - _ = yym3130 - if false { - } else { - z.F.EncSliceStringV(x.Names, false, e) - } - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("names")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Names == nil { - r.EncodeNil() - } else { - yym3131 := z.EncBinary() - _ = yym3131 - if false { - } else { - z.F.EncSliceStringV(x.Names, false, e) - } - } - } - if yyr3128 || yy2arr3128 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3128[1] { - yym3133 := z.EncBinary() - _ = yym3133 - if false { - } else { - r.EncodeInt(int64(x.SizeBytes)) - } - } else { - r.EncodeInt(0) - } - } else { - if yyq3128[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("sizeBytes")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3134 := z.EncBinary() - _ = yym3134 - if false { - } else { - r.EncodeInt(int64(x.SizeBytes)) - } - } - } - if yyr3128 || yy2arr3128 { - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - z.EncSendContainerState(codecSelfer_containerMapEnd1234) - } - } - } -} - -func (x *ContainerImage) CodecDecodeSelf(d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - yym3135 := z.DecBinary() - _ = yym3135 - if false { - } else if z.HasExtensions() && z.DecExt(x) { - } else { - yyct3136 := r.ContainerType() - if yyct3136 == codecSelferValueTypeMap1234 { - yyl3136 := r.ReadMapStart() - if yyl3136 == 0 { - z.DecSendContainerState(codecSelfer_containerMapEnd1234) - } else { - x.codecDecodeSelfFromMap(yyl3136, d) - } - } else if yyct3136 == codecSelferValueTypeArray1234 { - yyl3136 := r.ReadArrayStart() - if yyl3136 == 0 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - x.codecDecodeSelfFromArray(yyl3136, d) - } - } else { - panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) - } - } -} - -func (x *ContainerImage) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yys3137Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3137Slc - var yyhl3137 bool = l >= 0 - for yyj3137 := 0; ; yyj3137++ { - if yyhl3137 { - if yyj3137 >= l { - break - } - } else { - if r.CheckBreak() { - break - } - } - z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3137Slc = r.DecodeBytes(yys3137Slc, true, true) - yys3137 := string(yys3137Slc) - z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3137 { - case "names": - if r.TryDecodeAsNil() { - x.Names = nil - } else { - yyv3138 := &x.Names - yym3139 := z.DecBinary() - _ = yym3139 - if false { - } else { - z.F.DecSliceStringX(yyv3138, false, d) - } - } - case "sizeBytes": - if r.TryDecodeAsNil() { - x.SizeBytes = 0 - } else { - x.SizeBytes = int64(r.DecodeInt(64)) - } - default: - z.DecStructFieldNotFound(-1, yys3137) - } // end switch yys3137 - } // end for yyj3137 - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r @@ -40220,31 +40210,14 @@ func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.Names = nil - } else { - yyv3142 := &x.Names - yym3143 := z.DecBinary() - _ = yym3143 - if false { - } else { - z.F.DecSliceStringX(yyv3142, false, d) + if x.PodController != nil { + x.PodController = nil } - } - yyj3141++ - if yyhl3141 { - yyb3141 = yyj3141 > l } else { - yyb3141 = r.CheckBreak() - } - if yyb3141 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.SizeBytes = 0 - } else { - x.SizeBytes = int64(r.DecodeInt(64)) + if x.PodController == nil { + x.PodController = new(OwnerReference) + } + x.PodController.CodecDecodeSelf(d) } for { yyj3141++ @@ -40262,12 +40235,242 @@ func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } +func (x *ContainerImage) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym3143 := z.EncBinary() + _ = yym3143 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep3144 := !z.EncBinary() + yy2arr3144 := z.EncBasicHandle().StructToArray + var yyq3144 [2]bool + _, _, _ = yysep3144, yyq3144, yy2arr3144 + const yyr3144 bool = false + yyq3144[1] = x.SizeBytes != 0 + var yynn3144 int + if yyr3144 || yy2arr3144 { + r.EncodeArrayStart(2) + } else { + yynn3144 = 1 + for _, b := range yyq3144 { + if b { + yynn3144++ + } + } + r.EncodeMapStart(yynn3144) + yynn3144 = 0 + } + if yyr3144 || yy2arr3144 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if x.Names == nil { + r.EncodeNil() + } else { + yym3146 := z.EncBinary() + _ = yym3146 + if false { + } else { + z.F.EncSliceStringV(x.Names, false, e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("names")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Names == nil { + r.EncodeNil() + } else { + yym3147 := z.EncBinary() + _ = yym3147 + if false { + } else { + z.F.EncSliceStringV(x.Names, false, e) + } + } + } + if yyr3144 || yy2arr3144 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3144[1] { + yym3149 := z.EncBinary() + _ = yym3149 + if false { + } else { + r.EncodeInt(int64(x.SizeBytes)) + } + } else { + r.EncodeInt(0) + } + } else { + if yyq3144[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("sizeBytes")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3150 := z.EncBinary() + _ = yym3150 + if false { + } else { + r.EncodeInt(int64(x.SizeBytes)) + } + } + } + if yyr3144 || yy2arr3144 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + +func (x *ContainerImage) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym3151 := z.DecBinary() + _ = yym3151 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct3152 := r.ContainerType() + if yyct3152 == codecSelferValueTypeMap1234 { + yyl3152 := r.ReadMapStart() + if yyl3152 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl3152, d) + } + } else if yyct3152 == codecSelferValueTypeArray1234 { + yyl3152 := r.ReadArrayStart() + if yyl3152 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl3152, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *ContainerImage) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3153Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3153Slc + var yyhl3153 bool = l >= 0 + for yyj3153 := 0; ; yyj3153++ { + if yyhl3153 { + if yyj3153 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys3153Slc = r.DecodeBytes(yys3153Slc, true, true) + yys3153 := string(yys3153Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys3153 { + case "names": + if r.TryDecodeAsNil() { + x.Names = nil + } else { + yyv3154 := &x.Names + yym3155 := z.DecBinary() + _ = yym3155 + if false { + } else { + z.F.DecSliceStringX(yyv3154, false, d) + } + } + case "sizeBytes": + if r.TryDecodeAsNil() { + x.SizeBytes = 0 + } else { + x.SizeBytes = int64(r.DecodeInt(64)) + } + default: + z.DecStructFieldNotFound(-1, yys3153) + } // end switch yys3153 + } // end for yyj3153 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj3157 int + var yyb3157 bool + var yyhl3157 bool = l >= 0 + yyj3157++ + if yyhl3157 { + yyb3157 = yyj3157 > l + } else { + yyb3157 = r.CheckBreak() + } + if yyb3157 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Names = nil + } else { + yyv3158 := &x.Names + yym3159 := z.DecBinary() + _ = yym3159 + if false { + } else { + z.F.DecSliceStringX(yyv3158, false, d) + } + } + yyj3157++ + if yyhl3157 { + yyb3157 = yyj3157 > l + } else { + yyb3157 = r.CheckBreak() + } + if yyb3157 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.SizeBytes = 0 + } else { + x.SizeBytes = int64(r.DecodeInt(64)) + } + for { + yyj3157++ + if yyhl3157 { + yyb3157 = yyj3157 > l + } else { + yyb3157 = r.CheckBreak() + } + if yyb3157 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj3157-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + func (x NodePhase) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3145 := z.EncBinary() - _ = yym3145 + yym3161 := z.EncBinary() + _ = yym3161 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -40279,8 +40482,8 @@ func (x *NodePhase) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3146 := z.DecBinary() - _ = yym3146 + yym3162 := z.DecBinary() + _ = yym3162 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -40292,8 +40495,8 @@ func (x NodeConditionType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3147 := z.EncBinary() - _ = yym3147 + yym3163 := z.EncBinary() + _ = yym3163 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -40305,8 +40508,8 @@ func (x *NodeConditionType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3148 := z.DecBinary() - _ = yym3148 + yym3164 := z.DecBinary() + _ = yym3164 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -40321,34 +40524,34 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3149 := z.EncBinary() - _ = yym3149 + yym3165 := z.EncBinary() + _ = yym3165 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3150 := !z.EncBinary() - yy2arr3150 := z.EncBasicHandle().StructToArray - var yyq3150 [6]bool - _, _, _ = yysep3150, yyq3150, yy2arr3150 - const yyr3150 bool = false - yyq3150[2] = true - yyq3150[3] = true - yyq3150[4] = x.Reason != "" - yyq3150[5] = x.Message != "" - var yynn3150 int - if yyr3150 || yy2arr3150 { + yysep3166 := !z.EncBinary() + yy2arr3166 := z.EncBasicHandle().StructToArray + var yyq3166 [6]bool + _, _, _ = yysep3166, yyq3166, yy2arr3166 + const yyr3166 bool = false + yyq3166[2] = true + yyq3166[3] = true + yyq3166[4] = x.Reason != "" + yyq3166[5] = x.Message != "" + var yynn3166 int + if yyr3166 || yy2arr3166 { r.EncodeArrayStart(6) } else { - yynn3150 = 2 - for _, b := range yyq3150 { + yynn3166 = 2 + for _, b := range yyq3166 { if b { - yynn3150++ + yynn3166++ } } - r.EncodeMapStart(yynn3150) - yynn3150 = 0 + r.EncodeMapStart(yynn3166) + yynn3166 = 0 } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Type.CodecEncodeSelf(e) } else { @@ -40357,7 +40560,7 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Type.CodecEncodeSelf(e) } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Status.CodecEncodeSelf(e) } else { @@ -40366,85 +40569,85 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Status.CodecEncodeSelf(e) } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3150[2] { - yy3154 := &x.LastHeartbeatTime - yym3155 := z.EncBinary() - _ = yym3155 + if yyq3166[2] { + yy3170 := &x.LastHeartbeatTime + yym3171 := z.EncBinary() + _ = yym3171 if false { - } else if z.HasExtensions() && z.EncExt(yy3154) { - } else if yym3155 { - z.EncBinaryMarshal(yy3154) - } else if !yym3155 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3154) + } else if z.HasExtensions() && z.EncExt(yy3170) { + } else if yym3171 { + z.EncBinaryMarshal(yy3170) + } else if !yym3171 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3170) } else { - z.EncFallback(yy3154) + z.EncFallback(yy3170) } } else { r.EncodeNil() } } else { - if yyq3150[2] { + if yyq3166[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("lastHeartbeatTime")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3156 := &x.LastHeartbeatTime - yym3157 := z.EncBinary() - _ = yym3157 + yy3172 := &x.LastHeartbeatTime + yym3173 := z.EncBinary() + _ = yym3173 if false { - } else if z.HasExtensions() && z.EncExt(yy3156) { - } else if yym3157 { - z.EncBinaryMarshal(yy3156) - } else if !yym3157 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3156) + } else if z.HasExtensions() && z.EncExt(yy3172) { + } else if yym3173 { + z.EncBinaryMarshal(yy3172) + } else if !yym3173 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3172) } else { - z.EncFallback(yy3156) + z.EncFallback(yy3172) } } } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3150[3] { - yy3159 := &x.LastTransitionTime - yym3160 := z.EncBinary() - _ = yym3160 + if yyq3166[3] { + yy3175 := &x.LastTransitionTime + yym3176 := z.EncBinary() + _ = yym3176 if false { - } else if z.HasExtensions() && z.EncExt(yy3159) { - } else if yym3160 { - z.EncBinaryMarshal(yy3159) - } else if !yym3160 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3159) + } else if z.HasExtensions() && z.EncExt(yy3175) { + } else if yym3176 { + z.EncBinaryMarshal(yy3175) + } else if !yym3176 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3175) } else { - z.EncFallback(yy3159) + z.EncFallback(yy3175) } } else { r.EncodeNil() } } else { - if yyq3150[3] { + if yyq3166[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3161 := &x.LastTransitionTime - yym3162 := z.EncBinary() - _ = yym3162 + yy3177 := &x.LastTransitionTime + yym3178 := z.EncBinary() + _ = yym3178 if false { - } else if z.HasExtensions() && z.EncExt(yy3161) { - } else if yym3162 { - z.EncBinaryMarshal(yy3161) - } else if !yym3162 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3161) + } else if z.HasExtensions() && z.EncExt(yy3177) { + } else if yym3178 { + z.EncBinaryMarshal(yy3177) + } else if !yym3178 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3177) } else { - z.EncFallback(yy3161) + z.EncFallback(yy3177) } } } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3150[4] { - yym3164 := z.EncBinary() - _ = yym3164 + if yyq3166[4] { + yym3180 := z.EncBinary() + _ = yym3180 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) @@ -40453,23 +40656,23 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3150[4] { + if yyq3166[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("reason")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3165 := z.EncBinary() - _ = yym3165 + yym3181 := z.EncBinary() + _ = yym3181 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) } } } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3150[5] { - yym3167 := z.EncBinary() - _ = yym3167 + if yyq3166[5] { + yym3183 := z.EncBinary() + _ = yym3183 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) @@ -40478,19 +40681,19 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3150[5] { + if yyq3166[5] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("message")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3168 := z.EncBinary() - _ = yym3168 + yym3184 := z.EncBinary() + _ = yym3184 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) } } } - if yyr3150 || yy2arr3150 { + if yyr3166 || yy2arr3166 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -40503,25 +40706,25 @@ func (x *NodeCondition) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3169 := z.DecBinary() - _ = yym3169 + yym3185 := z.DecBinary() + _ = yym3185 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3170 := r.ContainerType() - if yyct3170 == codecSelferValueTypeMap1234 { - yyl3170 := r.ReadMapStart() - if yyl3170 == 0 { + yyct3186 := r.ContainerType() + if yyct3186 == codecSelferValueTypeMap1234 { + yyl3186 := r.ReadMapStart() + if yyl3186 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3170, d) + x.codecDecodeSelfFromMap(yyl3186, d) } - } else if yyct3170 == codecSelferValueTypeArray1234 { - yyl3170 := r.ReadArrayStart() - if yyl3170 == 0 { + } else if yyct3186 == codecSelferValueTypeArray1234 { + yyl3186 := r.ReadArrayStart() + if yyl3186 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3170, d) + x.codecDecodeSelfFromArray(yyl3186, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -40533,12 +40736,12 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3171Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3171Slc - var yyhl3171 bool = l >= 0 - for yyj3171 := 0; ; yyj3171++ { - if yyhl3171 { - if yyj3171 >= l { + var yys3187Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3187Slc + var yyhl3187 bool = l >= 0 + for yyj3187 := 0; ; yyj3187++ { + if yyhl3187 { + if yyj3187 >= l { break } } else { @@ -40547,10 +40750,10 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3171Slc = r.DecodeBytes(yys3171Slc, true, true) - yys3171 := string(yys3171Slc) + yys3187Slc = r.DecodeBytes(yys3187Slc, true, true) + yys3187 := string(yys3187Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3171 { + switch yys3187 { case "type": if r.TryDecodeAsNil() { x.Type = "" @@ -40567,34 +40770,34 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LastHeartbeatTime = pkg2_unversioned.Time{} } else { - yyv3174 := &x.LastHeartbeatTime - yym3175 := z.DecBinary() - _ = yym3175 + yyv3190 := &x.LastHeartbeatTime + yym3191 := z.DecBinary() + _ = yym3191 if false { - } else if z.HasExtensions() && z.DecExt(yyv3174) { - } else if yym3175 { - z.DecBinaryUnmarshal(yyv3174) - } else if !yym3175 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3174) + } else if z.HasExtensions() && z.DecExt(yyv3190) { + } else if yym3191 { + z.DecBinaryUnmarshal(yyv3190) + } else if !yym3191 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3190) } else { - z.DecFallback(yyv3174, false) + z.DecFallback(yyv3190, false) } } case "lastTransitionTime": if r.TryDecodeAsNil() { x.LastTransitionTime = pkg2_unversioned.Time{} } else { - yyv3176 := &x.LastTransitionTime - yym3177 := z.DecBinary() - _ = yym3177 + yyv3192 := &x.LastTransitionTime + yym3193 := z.DecBinary() + _ = yym3193 if false { - } else if z.HasExtensions() && z.DecExt(yyv3176) { - } else if yym3177 { - z.DecBinaryUnmarshal(yyv3176) - } else if !yym3177 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3176) + } else if z.HasExtensions() && z.DecExt(yyv3192) { + } else if yym3193 { + z.DecBinaryUnmarshal(yyv3192) + } else if !yym3193 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3192) } else { - z.DecFallback(yyv3176, false) + z.DecFallback(yyv3192, false) } } case "reason": @@ -40610,9 +40813,9 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Message = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3171) - } // end switch yys3171 - } // end for yyj3171 + z.DecStructFieldNotFound(-1, yys3187) + } // end switch yys3187 + } // end for yyj3187 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -40620,16 +40823,16 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3180 int - var yyb3180 bool - var yyhl3180 bool = l >= 0 - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + var yyj3196 int + var yyb3196 bool + var yyhl3196 bool = l >= 0 + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40639,13 +40842,13 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Type = NodeConditionType(r.DecodeString()) } - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40655,13 +40858,13 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Status = ConditionStatus(r.DecodeString()) } - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40669,26 +40872,26 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LastHeartbeatTime = pkg2_unversioned.Time{} } else { - yyv3183 := &x.LastHeartbeatTime - yym3184 := z.DecBinary() - _ = yym3184 + yyv3199 := &x.LastHeartbeatTime + yym3200 := z.DecBinary() + _ = yym3200 if false { - } else if z.HasExtensions() && z.DecExt(yyv3183) { - } else if yym3184 { - z.DecBinaryUnmarshal(yyv3183) - } else if !yym3184 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3183) + } else if z.HasExtensions() && z.DecExt(yyv3199) { + } else if yym3200 { + z.DecBinaryUnmarshal(yyv3199) + } else if !yym3200 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3199) } else { - z.DecFallback(yyv3183, false) + z.DecFallback(yyv3199, false) } } - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40696,26 +40899,26 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LastTransitionTime = pkg2_unversioned.Time{} } else { - yyv3185 := &x.LastTransitionTime - yym3186 := z.DecBinary() - _ = yym3186 + yyv3201 := &x.LastTransitionTime + yym3202 := z.DecBinary() + _ = yym3202 if false { - } else if z.HasExtensions() && z.DecExt(yyv3185) { - } else if yym3186 { - z.DecBinaryUnmarshal(yyv3185) - } else if !yym3186 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3185) + } else if z.HasExtensions() && z.DecExt(yyv3201) { + } else if yym3202 { + z.DecBinaryUnmarshal(yyv3201) + } else if !yym3202 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3201) } else { - z.DecFallback(yyv3185, false) + z.DecFallback(yyv3201, false) } } - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40725,13 +40928,13 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Reason = string(r.DecodeString()) } - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40742,17 +40945,17 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Message = string(r.DecodeString()) } for { - yyj3180++ - if yyhl3180 { - yyb3180 = yyj3180 > l + yyj3196++ + if yyhl3196 { + yyb3196 = yyj3196 > l } else { - yyb3180 = r.CheckBreak() + yyb3196 = r.CheckBreak() } - if yyb3180 { + if yyb3196 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3180-1, "") + z.DecStructFieldNotFound(yyj3196-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -40761,8 +40964,8 @@ func (x NodeAddressType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3189 := z.EncBinary() - _ = yym3189 + yym3205 := z.EncBinary() + _ = yym3205 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -40774,8 +40977,8 @@ func (x *NodeAddressType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3190 := z.DecBinary() - _ = yym3190 + yym3206 := z.DecBinary() + _ = yym3206 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -40790,30 +40993,30 @@ func (x *NodeAddress) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3191 := z.EncBinary() - _ = yym3191 + yym3207 := z.EncBinary() + _ = yym3207 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3192 := !z.EncBinary() - yy2arr3192 := z.EncBasicHandle().StructToArray - var yyq3192 [2]bool - _, _, _ = yysep3192, yyq3192, yy2arr3192 - const yyr3192 bool = false - var yynn3192 int - if yyr3192 || yy2arr3192 { + yysep3208 := !z.EncBinary() + yy2arr3208 := z.EncBasicHandle().StructToArray + var yyq3208 [2]bool + _, _, _ = yysep3208, yyq3208, yy2arr3208 + const yyr3208 bool = false + var yynn3208 int + if yyr3208 || yy2arr3208 { r.EncodeArrayStart(2) } else { - yynn3192 = 2 - for _, b := range yyq3192 { + yynn3208 = 2 + for _, b := range yyq3208 { if b { - yynn3192++ + yynn3208++ } } - r.EncodeMapStart(yynn3192) - yynn3192 = 0 + r.EncodeMapStart(yynn3208) + yynn3208 = 0 } - if yyr3192 || yy2arr3192 { + if yyr3208 || yy2arr3208 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Type.CodecEncodeSelf(e) } else { @@ -40822,10 +41025,10 @@ func (x *NodeAddress) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Type.CodecEncodeSelf(e) } - if yyr3192 || yy2arr3192 { + if yyr3208 || yy2arr3208 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3195 := z.EncBinary() - _ = yym3195 + yym3211 := z.EncBinary() + _ = yym3211 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Address)) @@ -40834,14 +41037,14 @@ func (x *NodeAddress) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("address")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3196 := z.EncBinary() - _ = yym3196 + yym3212 := z.EncBinary() + _ = yym3212 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Address)) } } - if yyr3192 || yy2arr3192 { + if yyr3208 || yy2arr3208 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -40854,25 +41057,25 @@ func (x *NodeAddress) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3197 := z.DecBinary() - _ = yym3197 + yym3213 := z.DecBinary() + _ = yym3213 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3198 := r.ContainerType() - if yyct3198 == codecSelferValueTypeMap1234 { - yyl3198 := r.ReadMapStart() - if yyl3198 == 0 { + yyct3214 := r.ContainerType() + if yyct3214 == codecSelferValueTypeMap1234 { + yyl3214 := r.ReadMapStart() + if yyl3214 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3198, d) + x.codecDecodeSelfFromMap(yyl3214, d) } - } else if yyct3198 == codecSelferValueTypeArray1234 { - yyl3198 := r.ReadArrayStart() - if yyl3198 == 0 { + } else if yyct3214 == codecSelferValueTypeArray1234 { + yyl3214 := r.ReadArrayStart() + if yyl3214 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3198, d) + x.codecDecodeSelfFromArray(yyl3214, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -40884,12 +41087,12 @@ func (x *NodeAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3199Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3199Slc - var yyhl3199 bool = l >= 0 - for yyj3199 := 0; ; yyj3199++ { - if yyhl3199 { - if yyj3199 >= l { + var yys3215Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3215Slc + var yyhl3215 bool = l >= 0 + for yyj3215 := 0; ; yyj3215++ { + if yyhl3215 { + if yyj3215 >= l { break } } else { @@ -40898,10 +41101,10 @@ func (x *NodeAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3199Slc = r.DecodeBytes(yys3199Slc, true, true) - yys3199 := string(yys3199Slc) + yys3215Slc = r.DecodeBytes(yys3215Slc, true, true) + yys3215 := string(yys3215Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3199 { + switch yys3215 { case "type": if r.TryDecodeAsNil() { x.Type = "" @@ -40915,9 +41118,9 @@ func (x *NodeAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Address = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3199) - } // end switch yys3199 - } // end for yyj3199 + z.DecStructFieldNotFound(-1, yys3215) + } // end switch yys3215 + } // end for yyj3215 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -40925,16 +41128,16 @@ func (x *NodeAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3202 int - var yyb3202 bool - var yyhl3202 bool = l >= 0 - yyj3202++ - if yyhl3202 { - yyb3202 = yyj3202 > l + var yyj3218 int + var yyb3218 bool + var yyhl3218 bool = l >= 0 + yyj3218++ + if yyhl3218 { + yyb3218 = yyj3218 > l } else { - yyb3202 = r.CheckBreak() + yyb3218 = r.CheckBreak() } - if yyb3202 { + if yyb3218 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40944,13 +41147,13 @@ func (x *NodeAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Type = NodeAddressType(r.DecodeString()) } - yyj3202++ - if yyhl3202 { - yyb3202 = yyj3202 > l + yyj3218++ + if yyhl3218 { + yyb3218 = yyj3218 > l } else { - yyb3202 = r.CheckBreak() + yyb3218 = r.CheckBreak() } - if yyb3202 { + if yyb3218 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -40961,17 +41164,17 @@ func (x *NodeAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Address = string(r.DecodeString()) } for { - yyj3202++ - if yyhl3202 { - yyb3202 = yyj3202 > l + yyj3218++ + if yyhl3218 { + yyb3218 = yyj3218 > l } else { - yyb3202 = r.CheckBreak() + yyb3218 = r.CheckBreak() } - if yyb3202 { + if yyb3218 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3202-1, "") + z.DecStructFieldNotFound(yyj3218-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -40983,33 +41186,33 @@ func (x *NodeResources) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3205 := z.EncBinary() - _ = yym3205 + yym3221 := z.EncBinary() + _ = yym3221 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3206 := !z.EncBinary() - yy2arr3206 := z.EncBasicHandle().StructToArray - var yyq3206 [1]bool - _, _, _ = yysep3206, yyq3206, yy2arr3206 - const yyr3206 bool = false - yyq3206[0] = len(x.Capacity) != 0 - var yynn3206 int - if yyr3206 || yy2arr3206 { + yysep3222 := !z.EncBinary() + yy2arr3222 := z.EncBasicHandle().StructToArray + var yyq3222 [1]bool + _, _, _ = yysep3222, yyq3222, yy2arr3222 + const yyr3222 bool = false + yyq3222[0] = len(x.Capacity) != 0 + var yynn3222 int + if yyr3222 || yy2arr3222 { r.EncodeArrayStart(1) } else { - yynn3206 = 0 - for _, b := range yyq3206 { + yynn3222 = 0 + for _, b := range yyq3222 { if b { - yynn3206++ + yynn3222++ } } - r.EncodeMapStart(yynn3206) - yynn3206 = 0 + r.EncodeMapStart(yynn3222) + yynn3222 = 0 } - if yyr3206 || yy2arr3206 { + if yyr3222 || yy2arr3222 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3206[0] { + if yyq3222[0] { if x.Capacity == nil { r.EncodeNil() } else { @@ -41019,7 +41222,7 @@ func (x *NodeResources) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3206[0] { + if yyq3222[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("capacity")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -41030,7 +41233,7 @@ func (x *NodeResources) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3206 || yy2arr3206 { + if yyr3222 || yy2arr3222 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -41043,25 +41246,25 @@ func (x *NodeResources) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3208 := z.DecBinary() - _ = yym3208 + yym3224 := z.DecBinary() + _ = yym3224 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3209 := r.ContainerType() - if yyct3209 == codecSelferValueTypeMap1234 { - yyl3209 := r.ReadMapStart() - if yyl3209 == 0 { + yyct3225 := r.ContainerType() + if yyct3225 == codecSelferValueTypeMap1234 { + yyl3225 := r.ReadMapStart() + if yyl3225 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3209, d) + x.codecDecodeSelfFromMap(yyl3225, d) } - } else if yyct3209 == codecSelferValueTypeArray1234 { - yyl3209 := r.ReadArrayStart() - if yyl3209 == 0 { + } else if yyct3225 == codecSelferValueTypeArray1234 { + yyl3225 := r.ReadArrayStart() + if yyl3225 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3209, d) + x.codecDecodeSelfFromArray(yyl3225, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -41073,12 +41276,12 @@ func (x *NodeResources) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3210Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3210Slc - var yyhl3210 bool = l >= 0 - for yyj3210 := 0; ; yyj3210++ { - if yyhl3210 { - if yyj3210 >= l { + var yys3226Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3226Slc + var yyhl3226 bool = l >= 0 + for yyj3226 := 0; ; yyj3226++ { + if yyhl3226 { + if yyj3226 >= l { break } } else { @@ -41087,21 +41290,21 @@ func (x *NodeResources) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3210Slc = r.DecodeBytes(yys3210Slc, true, true) - yys3210 := string(yys3210Slc) + yys3226Slc = r.DecodeBytes(yys3226Slc, true, true) + yys3226 := string(yys3226Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3210 { + switch yys3226 { case "capacity": if r.TryDecodeAsNil() { x.Capacity = nil } else { - yyv3211 := &x.Capacity - yyv3211.CodecDecodeSelf(d) + yyv3227 := &x.Capacity + yyv3227.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys3210) - } // end switch yys3210 - } // end for yyj3210 + z.DecStructFieldNotFound(-1, yys3226) + } // end switch yys3226 + } // end for yyj3226 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -41109,16 +41312,16 @@ func (x *NodeResources) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3212 int - var yyb3212 bool - var yyhl3212 bool = l >= 0 - yyj3212++ - if yyhl3212 { - yyb3212 = yyj3212 > l + var yyj3228 int + var yyb3228 bool + var yyhl3228 bool = l >= 0 + yyj3228++ + if yyhl3228 { + yyb3228 = yyj3228 > l } else { - yyb3212 = r.CheckBreak() + yyb3228 = r.CheckBreak() } - if yyb3212 { + if yyb3228 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41126,21 +41329,21 @@ func (x *NodeResources) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Capacity = nil } else { - yyv3213 := &x.Capacity - yyv3213.CodecDecodeSelf(d) + yyv3229 := &x.Capacity + yyv3229.CodecDecodeSelf(d) } for { - yyj3212++ - if yyhl3212 { - yyb3212 = yyj3212 > l + yyj3228++ + if yyhl3228 { + yyb3228 = yyj3228 > l } else { - yyb3212 = r.CheckBreak() + yyb3228 = r.CheckBreak() } - if yyb3212 { + if yyb3228 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3212-1, "") + z.DecStructFieldNotFound(yyj3228-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -41149,8 +41352,8 @@ func (x ResourceName) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3214 := z.EncBinary() - _ = yym3214 + yym3230 := z.EncBinary() + _ = yym3230 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -41162,8 +41365,8 @@ func (x *ResourceName) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3215 := z.DecBinary() - _ = yym3215 + yym3231 := z.DecBinary() + _ = yym3231 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -41178,8 +41381,8 @@ func (x ResourceList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3216 := z.EncBinary() - _ = yym3216 + yym3232 := z.EncBinary() + _ = yym3232 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -41192,8 +41395,8 @@ func (x *ResourceList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3217 := z.DecBinary() - _ = yym3217 + yym3233 := z.DecBinary() + _ = yym3233 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -41208,39 +41411,39 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3218 := z.EncBinary() - _ = yym3218 + yym3234 := z.EncBinary() + _ = yym3234 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3219 := !z.EncBinary() - yy2arr3219 := z.EncBasicHandle().StructToArray - var yyq3219 [5]bool - _, _, _ = yysep3219, yyq3219, yy2arr3219 - const yyr3219 bool = false - yyq3219[0] = x.Kind != "" - yyq3219[1] = x.APIVersion != "" - yyq3219[2] = true - yyq3219[3] = true - yyq3219[4] = true - var yynn3219 int - if yyr3219 || yy2arr3219 { + yysep3235 := !z.EncBinary() + yy2arr3235 := z.EncBasicHandle().StructToArray + var yyq3235 [5]bool + _, _, _ = yysep3235, yyq3235, yy2arr3235 + const yyr3235 bool = false + yyq3235[0] = x.Kind != "" + yyq3235[1] = x.APIVersion != "" + yyq3235[2] = true + yyq3235[3] = true + yyq3235[4] = true + var yynn3235 int + if yyr3235 || yy2arr3235 { r.EncodeArrayStart(5) } else { - yynn3219 = 0 - for _, b := range yyq3219 { + yynn3235 = 0 + for _, b := range yyq3235 { if b { - yynn3219++ + yynn3235++ } } - r.EncodeMapStart(yynn3219) - yynn3219 = 0 + r.EncodeMapStart(yynn3235) + yynn3235 = 0 } - if yyr3219 || yy2arr3219 { + if yyr3235 || yy2arr3235 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3219[0] { - yym3221 := z.EncBinary() - _ = yym3221 + if yyq3235[0] { + yym3237 := z.EncBinary() + _ = yym3237 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -41249,23 +41452,23 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3219[0] { + if yyq3235[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3222 := z.EncBinary() - _ = yym3222 + yym3238 := z.EncBinary() + _ = yym3238 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3219 || yy2arr3219 { + if yyr3235 || yy2arr3235 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3219[1] { - yym3224 := z.EncBinary() - _ = yym3224 + if yyq3235[1] { + yym3240 := z.EncBinary() + _ = yym3240 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -41274,70 +41477,70 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3219[1] { + if yyq3235[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3225 := z.EncBinary() - _ = yym3225 + yym3241 := z.EncBinary() + _ = yym3241 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3219 || yy2arr3219 { + if yyr3235 || yy2arr3235 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3219[2] { - yy3227 := &x.ObjectMeta - yy3227.CodecEncodeSelf(e) + if yyq3235[2] { + yy3243 := &x.ObjectMeta + yy3243.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3219[2] { + if yyq3235[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3228 := &x.ObjectMeta - yy3228.CodecEncodeSelf(e) + yy3244 := &x.ObjectMeta + yy3244.CodecEncodeSelf(e) } } - if yyr3219 || yy2arr3219 { + if yyr3235 || yy2arr3235 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3219[3] { - yy3230 := &x.Spec - yy3230.CodecEncodeSelf(e) + if yyq3235[3] { + yy3246 := &x.Spec + yy3246.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3219[3] { + if yyq3235[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3231 := &x.Spec - yy3231.CodecEncodeSelf(e) + yy3247 := &x.Spec + yy3247.CodecEncodeSelf(e) } } - if yyr3219 || yy2arr3219 { + if yyr3235 || yy2arr3235 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3219[4] { - yy3233 := &x.Status - yy3233.CodecEncodeSelf(e) + if yyq3235[4] { + yy3249 := &x.Status + yy3249.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3219[4] { + if yyq3235[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3234 := &x.Status - yy3234.CodecEncodeSelf(e) + yy3250 := &x.Status + yy3250.CodecEncodeSelf(e) } } - if yyr3219 || yy2arr3219 { + if yyr3235 || yy2arr3235 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -41350,25 +41553,25 @@ func (x *Node) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3235 := z.DecBinary() - _ = yym3235 + yym3251 := z.DecBinary() + _ = yym3251 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3236 := r.ContainerType() - if yyct3236 == codecSelferValueTypeMap1234 { - yyl3236 := r.ReadMapStart() - if yyl3236 == 0 { + yyct3252 := r.ContainerType() + if yyct3252 == codecSelferValueTypeMap1234 { + yyl3252 := r.ReadMapStart() + if yyl3252 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3236, d) + x.codecDecodeSelfFromMap(yyl3252, d) } - } else if yyct3236 == codecSelferValueTypeArray1234 { - yyl3236 := r.ReadArrayStart() - if yyl3236 == 0 { + } else if yyct3252 == codecSelferValueTypeArray1234 { + yyl3252 := r.ReadArrayStart() + if yyl3252 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3236, d) + x.codecDecodeSelfFromArray(yyl3252, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -41380,12 +41583,12 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3237Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3237Slc - var yyhl3237 bool = l >= 0 - for yyj3237 := 0; ; yyj3237++ { - if yyhl3237 { - if yyj3237 >= l { + var yys3253Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3253Slc + var yyhl3253 bool = l >= 0 + for yyj3253 := 0; ; yyj3253++ { + if yyhl3253 { + if yyj3253 >= l { break } } else { @@ -41394,10 +41597,10 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3237Slc = r.DecodeBytes(yys3237Slc, true, true) - yys3237 := string(yys3237Slc) + yys3253Slc = r.DecodeBytes(yys3253Slc, true, true) + yys3253 := string(yys3253Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3237 { + switch yys3253 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -41414,27 +41617,27 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3240 := &x.ObjectMeta - yyv3240.CodecDecodeSelf(d) + yyv3256 := &x.ObjectMeta + yyv3256.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = NodeSpec{} } else { - yyv3241 := &x.Spec - yyv3241.CodecDecodeSelf(d) + yyv3257 := &x.Spec + yyv3257.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = NodeStatus{} } else { - yyv3242 := &x.Status - yyv3242.CodecDecodeSelf(d) + yyv3258 := &x.Status + yyv3258.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys3237) - } // end switch yys3237 - } // end for yyj3237 + z.DecStructFieldNotFound(-1, yys3253) + } // end switch yys3253 + } // end for yyj3253 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -41442,16 +41645,16 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3243 int - var yyb3243 bool - var yyhl3243 bool = l >= 0 - yyj3243++ - if yyhl3243 { - yyb3243 = yyj3243 > l + var yyj3259 int + var yyb3259 bool + var yyhl3259 bool = l >= 0 + yyj3259++ + if yyhl3259 { + yyb3259 = yyj3259 > l } else { - yyb3243 = r.CheckBreak() + yyb3259 = r.CheckBreak() } - if yyb3243 { + if yyb3259 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41461,13 +41664,13 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3243++ - if yyhl3243 { - yyb3243 = yyj3243 > l + yyj3259++ + if yyhl3259 { + yyb3259 = yyj3259 > l } else { - yyb3243 = r.CheckBreak() + yyb3259 = r.CheckBreak() } - if yyb3243 { + if yyb3259 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41477,13 +41680,13 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3243++ - if yyhl3243 { - yyb3243 = yyj3243 > l + yyj3259++ + if yyhl3259 { + yyb3259 = yyj3259 > l } else { - yyb3243 = r.CheckBreak() + yyb3259 = r.CheckBreak() } - if yyb3243 { + if yyb3259 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41491,16 +41694,16 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3246 := &x.ObjectMeta - yyv3246.CodecDecodeSelf(d) + yyv3262 := &x.ObjectMeta + yyv3262.CodecDecodeSelf(d) } - yyj3243++ - if yyhl3243 { - yyb3243 = yyj3243 > l + yyj3259++ + if yyhl3259 { + yyb3259 = yyj3259 > l } else { - yyb3243 = r.CheckBreak() + yyb3259 = r.CheckBreak() } - if yyb3243 { + if yyb3259 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41508,16 +41711,16 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Spec = NodeSpec{} } else { - yyv3247 := &x.Spec - yyv3247.CodecDecodeSelf(d) + yyv3263 := &x.Spec + yyv3263.CodecDecodeSelf(d) } - yyj3243++ - if yyhl3243 { - yyb3243 = yyj3243 > l + yyj3259++ + if yyhl3259 { + yyb3259 = yyj3259 > l } else { - yyb3243 = r.CheckBreak() + yyb3259 = r.CheckBreak() } - if yyb3243 { + if yyb3259 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41525,21 +41728,21 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Status = NodeStatus{} } else { - yyv3248 := &x.Status - yyv3248.CodecDecodeSelf(d) + yyv3264 := &x.Status + yyv3264.CodecDecodeSelf(d) } for { - yyj3243++ - if yyhl3243 { - yyb3243 = yyj3243 > l + yyj3259++ + if yyhl3259 { + yyb3259 = yyj3259 > l } else { - yyb3243 = r.CheckBreak() + yyb3259 = r.CheckBreak() } - if yyb3243 { + if yyb3259 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3243-1, "") + z.DecStructFieldNotFound(yyj3259-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -41551,37 +41754,37 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3249 := z.EncBinary() - _ = yym3249 + yym3265 := z.EncBinary() + _ = yym3265 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3250 := !z.EncBinary() - yy2arr3250 := z.EncBasicHandle().StructToArray - var yyq3250 [4]bool - _, _, _ = yysep3250, yyq3250, yy2arr3250 - const yyr3250 bool = false - yyq3250[0] = x.Kind != "" - yyq3250[1] = x.APIVersion != "" - yyq3250[2] = true - var yynn3250 int - if yyr3250 || yy2arr3250 { + yysep3266 := !z.EncBinary() + yy2arr3266 := z.EncBasicHandle().StructToArray + var yyq3266 [4]bool + _, _, _ = yysep3266, yyq3266, yy2arr3266 + const yyr3266 bool = false + yyq3266[0] = x.Kind != "" + yyq3266[1] = x.APIVersion != "" + yyq3266[2] = true + var yynn3266 int + if yyr3266 || yy2arr3266 { r.EncodeArrayStart(4) } else { - yynn3250 = 1 - for _, b := range yyq3250 { + yynn3266 = 1 + for _, b := range yyq3266 { if b { - yynn3250++ + yynn3266++ } } - r.EncodeMapStart(yynn3250) - yynn3250 = 0 + r.EncodeMapStart(yynn3266) + yynn3266 = 0 } - if yyr3250 || yy2arr3250 { + if yyr3266 || yy2arr3266 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3250[0] { - yym3252 := z.EncBinary() - _ = yym3252 + if yyq3266[0] { + yym3268 := z.EncBinary() + _ = yym3268 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -41590,23 +41793,23 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3250[0] { + if yyq3266[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3253 := z.EncBinary() - _ = yym3253 + yym3269 := z.EncBinary() + _ = yym3269 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3250 || yy2arr3250 { + if yyr3266 || yy2arr3266 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3250[1] { - yym3255 := z.EncBinary() - _ = yym3255 + if yyq3266[1] { + yym3271 := z.EncBinary() + _ = yym3271 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -41615,54 +41818,54 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3250[1] { + if yyq3266[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3256 := z.EncBinary() - _ = yym3256 + yym3272 := z.EncBinary() + _ = yym3272 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3250 || yy2arr3250 { + if yyr3266 || yy2arr3266 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3250[2] { - yy3258 := &x.ListMeta - yym3259 := z.EncBinary() - _ = yym3259 + if yyq3266[2] { + yy3274 := &x.ListMeta + yym3275 := z.EncBinary() + _ = yym3275 if false { - } else if z.HasExtensions() && z.EncExt(yy3258) { + } else if z.HasExtensions() && z.EncExt(yy3274) { } else { - z.EncFallback(yy3258) + z.EncFallback(yy3274) } } else { r.EncodeNil() } } else { - if yyq3250[2] { + if yyq3266[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3260 := &x.ListMeta - yym3261 := z.EncBinary() - _ = yym3261 + yy3276 := &x.ListMeta + yym3277 := z.EncBinary() + _ = yym3277 if false { - } else if z.HasExtensions() && z.EncExt(yy3260) { + } else if z.HasExtensions() && z.EncExt(yy3276) { } else { - z.EncFallback(yy3260) + z.EncFallback(yy3276) } } } - if yyr3250 || yy2arr3250 { + if yyr3266 || yy2arr3266 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym3263 := z.EncBinary() - _ = yym3263 + yym3279 := z.EncBinary() + _ = yym3279 if false { } else { h.encSliceNode(([]Node)(x.Items), e) @@ -41675,15 +41878,15 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym3264 := z.EncBinary() - _ = yym3264 + yym3280 := z.EncBinary() + _ = yym3280 if false { } else { h.encSliceNode(([]Node)(x.Items), e) } } } - if yyr3250 || yy2arr3250 { + if yyr3266 || yy2arr3266 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -41696,25 +41899,25 @@ func (x *NodeList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3265 := z.DecBinary() - _ = yym3265 + yym3281 := z.DecBinary() + _ = yym3281 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3266 := r.ContainerType() - if yyct3266 == codecSelferValueTypeMap1234 { - yyl3266 := r.ReadMapStart() - if yyl3266 == 0 { + yyct3282 := r.ContainerType() + if yyct3282 == codecSelferValueTypeMap1234 { + yyl3282 := r.ReadMapStart() + if yyl3282 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3266, d) + x.codecDecodeSelfFromMap(yyl3282, d) } - } else if yyct3266 == codecSelferValueTypeArray1234 { - yyl3266 := r.ReadArrayStart() - if yyl3266 == 0 { + } else if yyct3282 == codecSelferValueTypeArray1234 { + yyl3282 := r.ReadArrayStart() + if yyl3282 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3266, d) + x.codecDecodeSelfFromArray(yyl3282, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -41726,12 +41929,12 @@ func (x *NodeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3267Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3267Slc - var yyhl3267 bool = l >= 0 - for yyj3267 := 0; ; yyj3267++ { - if yyhl3267 { - if yyj3267 >= l { + var yys3283Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3283Slc + var yyhl3283 bool = l >= 0 + for yyj3283 := 0; ; yyj3283++ { + if yyhl3283 { + if yyj3283 >= l { break } } else { @@ -41740,10 +41943,10 @@ func (x *NodeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3267Slc = r.DecodeBytes(yys3267Slc, true, true) - yys3267 := string(yys3267Slc) + yys3283Slc = r.DecodeBytes(yys3283Slc, true, true) + yys3283 := string(yys3283Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3267 { + switch yys3283 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -41760,31 +41963,31 @@ func (x *NodeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3270 := &x.ListMeta - yym3271 := z.DecBinary() - _ = yym3271 + yyv3286 := &x.ListMeta + yym3287 := z.DecBinary() + _ = yym3287 if false { - } else if z.HasExtensions() && z.DecExt(yyv3270) { + } else if z.HasExtensions() && z.DecExt(yyv3286) { } else { - z.DecFallback(yyv3270, false) + z.DecFallback(yyv3286, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3272 := &x.Items - yym3273 := z.DecBinary() - _ = yym3273 + yyv3288 := &x.Items + yym3289 := z.DecBinary() + _ = yym3289 if false { } else { - h.decSliceNode((*[]Node)(yyv3272), d) + h.decSliceNode((*[]Node)(yyv3288), d) } } default: - z.DecStructFieldNotFound(-1, yys3267) - } // end switch yys3267 - } // end for yyj3267 + z.DecStructFieldNotFound(-1, yys3283) + } // end switch yys3283 + } // end for yyj3283 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -41792,16 +41995,16 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3274 int - var yyb3274 bool - var yyhl3274 bool = l >= 0 - yyj3274++ - if yyhl3274 { - yyb3274 = yyj3274 > l + var yyj3290 int + var yyb3290 bool + var yyhl3290 bool = l >= 0 + yyj3290++ + if yyhl3290 { + yyb3290 = yyj3290 > l } else { - yyb3274 = r.CheckBreak() + yyb3290 = r.CheckBreak() } - if yyb3274 { + if yyb3290 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41811,13 +42014,13 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3274++ - if yyhl3274 { - yyb3274 = yyj3274 > l + yyj3290++ + if yyhl3290 { + yyb3290 = yyj3290 > l } else { - yyb3274 = r.CheckBreak() + yyb3290 = r.CheckBreak() } - if yyb3274 { + if yyb3290 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41827,13 +42030,13 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3274++ - if yyhl3274 { - yyb3274 = yyj3274 > l + yyj3290++ + if yyhl3290 { + yyb3290 = yyj3290 > l } else { - yyb3274 = r.CheckBreak() + yyb3290 = r.CheckBreak() } - if yyb3274 { + if yyb3290 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41841,22 +42044,22 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3277 := &x.ListMeta - yym3278 := z.DecBinary() - _ = yym3278 + yyv3293 := &x.ListMeta + yym3294 := z.DecBinary() + _ = yym3294 if false { - } else if z.HasExtensions() && z.DecExt(yyv3277) { + } else if z.HasExtensions() && z.DecExt(yyv3293) { } else { - z.DecFallback(yyv3277, false) + z.DecFallback(yyv3293, false) } } - yyj3274++ - if yyhl3274 { - yyb3274 = yyj3274 > l + yyj3290++ + if yyhl3290 { + yyb3290 = yyj3290 > l } else { - yyb3274 = r.CheckBreak() + yyb3290 = r.CheckBreak() } - if yyb3274 { + if yyb3290 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -41864,26 +42067,26 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3279 := &x.Items - yym3280 := z.DecBinary() - _ = yym3280 + yyv3295 := &x.Items + yym3296 := z.DecBinary() + _ = yym3296 if false { } else { - h.decSliceNode((*[]Node)(yyv3279), d) + h.decSliceNode((*[]Node)(yyv3295), d) } } for { - yyj3274++ - if yyhl3274 { - yyb3274 = yyj3274 > l + yyj3290++ + if yyhl3290 { + yyb3290 = yyj3290 > l } else { - yyb3274 = r.CheckBreak() + yyb3290 = r.CheckBreak() } - if yyb3274 { + if yyb3290 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3274-1, "") + z.DecStructFieldNotFound(yyj3290-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -41895,36 +42098,36 @@ func (x *NamespaceSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3281 := z.EncBinary() - _ = yym3281 + yym3297 := z.EncBinary() + _ = yym3297 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3282 := !z.EncBinary() - yy2arr3282 := z.EncBasicHandle().StructToArray - var yyq3282 [1]bool - _, _, _ = yysep3282, yyq3282, yy2arr3282 - const yyr3282 bool = false - var yynn3282 int - if yyr3282 || yy2arr3282 { + yysep3298 := !z.EncBinary() + yy2arr3298 := z.EncBasicHandle().StructToArray + var yyq3298 [1]bool + _, _, _ = yysep3298, yyq3298, yy2arr3298 + const yyr3298 bool = false + var yynn3298 int + if yyr3298 || yy2arr3298 { r.EncodeArrayStart(1) } else { - yynn3282 = 1 - for _, b := range yyq3282 { + yynn3298 = 1 + for _, b := range yyq3298 { if b { - yynn3282++ + yynn3298++ } } - r.EncodeMapStart(yynn3282) - yynn3282 = 0 + r.EncodeMapStart(yynn3298) + yynn3298 = 0 } - if yyr3282 || yy2arr3282 { + if yyr3298 || yy2arr3298 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Finalizers == nil { r.EncodeNil() } else { - yym3284 := z.EncBinary() - _ = yym3284 + yym3300 := z.EncBinary() + _ = yym3300 if false { } else { h.encSliceFinalizerName(([]FinalizerName)(x.Finalizers), e) @@ -41937,15 +42140,15 @@ func (x *NamespaceSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x.Finalizers == nil { r.EncodeNil() } else { - yym3285 := z.EncBinary() - _ = yym3285 + yym3301 := z.EncBinary() + _ = yym3301 if false { } else { h.encSliceFinalizerName(([]FinalizerName)(x.Finalizers), e) } } } - if yyr3282 || yy2arr3282 { + if yyr3298 || yy2arr3298 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -41958,25 +42161,25 @@ func (x *NamespaceSpec) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3286 := z.DecBinary() - _ = yym3286 + yym3302 := z.DecBinary() + _ = yym3302 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3287 := r.ContainerType() - if yyct3287 == codecSelferValueTypeMap1234 { - yyl3287 := r.ReadMapStart() - if yyl3287 == 0 { + yyct3303 := r.ContainerType() + if yyct3303 == codecSelferValueTypeMap1234 { + yyl3303 := r.ReadMapStart() + if yyl3303 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3287, d) + x.codecDecodeSelfFromMap(yyl3303, d) } - } else if yyct3287 == codecSelferValueTypeArray1234 { - yyl3287 := r.ReadArrayStart() - if yyl3287 == 0 { + } else if yyct3303 == codecSelferValueTypeArray1234 { + yyl3303 := r.ReadArrayStart() + if yyl3303 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3287, d) + x.codecDecodeSelfFromArray(yyl3303, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -41988,12 +42191,12 @@ func (x *NamespaceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3288Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3288Slc - var yyhl3288 bool = l >= 0 - for yyj3288 := 0; ; yyj3288++ { - if yyhl3288 { - if yyj3288 >= l { + var yys3304Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3304Slc + var yyhl3304 bool = l >= 0 + for yyj3304 := 0; ; yyj3304++ { + if yyhl3304 { + if yyj3304 >= l { break } } else { @@ -42002,26 +42205,26 @@ func (x *NamespaceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3288Slc = r.DecodeBytes(yys3288Slc, true, true) - yys3288 := string(yys3288Slc) + yys3304Slc = r.DecodeBytes(yys3304Slc, true, true) + yys3304 := string(yys3304Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3288 { + switch yys3304 { case "Finalizers": if r.TryDecodeAsNil() { x.Finalizers = nil } else { - yyv3289 := &x.Finalizers - yym3290 := z.DecBinary() - _ = yym3290 + yyv3305 := &x.Finalizers + yym3306 := z.DecBinary() + _ = yym3306 if false { } else { - h.decSliceFinalizerName((*[]FinalizerName)(yyv3289), d) + h.decSliceFinalizerName((*[]FinalizerName)(yyv3305), d) } } default: - z.DecStructFieldNotFound(-1, yys3288) - } // end switch yys3288 - } // end for yyj3288 + z.DecStructFieldNotFound(-1, yys3304) + } // end switch yys3304 + } // end for yyj3304 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -42029,16 +42232,16 @@ func (x *NamespaceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3291 int - var yyb3291 bool - var yyhl3291 bool = l >= 0 - yyj3291++ - if yyhl3291 { - yyb3291 = yyj3291 > l + var yyj3307 int + var yyb3307 bool + var yyhl3307 bool = l >= 0 + yyj3307++ + if yyhl3307 { + yyb3307 = yyj3307 > l } else { - yyb3291 = r.CheckBreak() + yyb3307 = r.CheckBreak() } - if yyb3291 { + if yyb3307 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42046,26 +42249,26 @@ func (x *NamespaceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Finalizers = nil } else { - yyv3292 := &x.Finalizers - yym3293 := z.DecBinary() - _ = yym3293 + yyv3308 := &x.Finalizers + yym3309 := z.DecBinary() + _ = yym3309 if false { } else { - h.decSliceFinalizerName((*[]FinalizerName)(yyv3292), d) + h.decSliceFinalizerName((*[]FinalizerName)(yyv3308), d) } } for { - yyj3291++ - if yyhl3291 { - yyb3291 = yyj3291 > l + yyj3307++ + if yyhl3307 { + yyb3307 = yyj3307 > l } else { - yyb3291 = r.CheckBreak() + yyb3307 = r.CheckBreak() } - if yyb3291 { + if yyb3307 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3291-1, "") + z.DecStructFieldNotFound(yyj3307-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -42074,8 +42277,8 @@ func (x FinalizerName) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3294 := z.EncBinary() - _ = yym3294 + yym3310 := z.EncBinary() + _ = yym3310 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -42087,8 +42290,8 @@ func (x *FinalizerName) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3295 := z.DecBinary() - _ = yym3295 + yym3311 := z.DecBinary() + _ = yym3311 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -42103,46 +42306,46 @@ func (x *NamespaceStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3296 := z.EncBinary() - _ = yym3296 + yym3312 := z.EncBinary() + _ = yym3312 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3297 := !z.EncBinary() - yy2arr3297 := z.EncBasicHandle().StructToArray - var yyq3297 [1]bool - _, _, _ = yysep3297, yyq3297, yy2arr3297 - const yyr3297 bool = false - yyq3297[0] = x.Phase != "" - var yynn3297 int - if yyr3297 || yy2arr3297 { + yysep3313 := !z.EncBinary() + yy2arr3313 := z.EncBasicHandle().StructToArray + var yyq3313 [1]bool + _, _, _ = yysep3313, yyq3313, yy2arr3313 + const yyr3313 bool = false + yyq3313[0] = x.Phase != "" + var yynn3313 int + if yyr3313 || yy2arr3313 { r.EncodeArrayStart(1) } else { - yynn3297 = 0 - for _, b := range yyq3297 { + yynn3313 = 0 + for _, b := range yyq3313 { if b { - yynn3297++ + yynn3313++ } } - r.EncodeMapStart(yynn3297) - yynn3297 = 0 + r.EncodeMapStart(yynn3313) + yynn3313 = 0 } - if yyr3297 || yy2arr3297 { + if yyr3313 || yy2arr3313 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3297[0] { + if yyq3313[0] { x.Phase.CodecEncodeSelf(e) } else { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3297[0] { + if yyq3313[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("phase")) z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Phase.CodecEncodeSelf(e) } } - if yyr3297 || yy2arr3297 { + if yyr3313 || yy2arr3313 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -42155,25 +42358,25 @@ func (x *NamespaceStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3299 := z.DecBinary() - _ = yym3299 + yym3315 := z.DecBinary() + _ = yym3315 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3300 := r.ContainerType() - if yyct3300 == codecSelferValueTypeMap1234 { - yyl3300 := r.ReadMapStart() - if yyl3300 == 0 { + yyct3316 := r.ContainerType() + if yyct3316 == codecSelferValueTypeMap1234 { + yyl3316 := r.ReadMapStart() + if yyl3316 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3300, d) + x.codecDecodeSelfFromMap(yyl3316, d) } - } else if yyct3300 == codecSelferValueTypeArray1234 { - yyl3300 := r.ReadArrayStart() - if yyl3300 == 0 { + } else if yyct3316 == codecSelferValueTypeArray1234 { + yyl3316 := r.ReadArrayStart() + if yyl3316 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3300, d) + x.codecDecodeSelfFromArray(yyl3316, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -42185,12 +42388,12 @@ func (x *NamespaceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3301Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3301Slc - var yyhl3301 bool = l >= 0 - for yyj3301 := 0; ; yyj3301++ { - if yyhl3301 { - if yyj3301 >= l { + var yys3317Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3317Slc + var yyhl3317 bool = l >= 0 + for yyj3317 := 0; ; yyj3317++ { + if yyhl3317 { + if yyj3317 >= l { break } } else { @@ -42199,10 +42402,10 @@ func (x *NamespaceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3301Slc = r.DecodeBytes(yys3301Slc, true, true) - yys3301 := string(yys3301Slc) + yys3317Slc = r.DecodeBytes(yys3317Slc, true, true) + yys3317 := string(yys3317Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3301 { + switch yys3317 { case "phase": if r.TryDecodeAsNil() { x.Phase = "" @@ -42210,9 +42413,9 @@ func (x *NamespaceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Phase = NamespacePhase(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3301) - } // end switch yys3301 - } // end for yyj3301 + z.DecStructFieldNotFound(-1, yys3317) + } // end switch yys3317 + } // end for yyj3317 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -42220,16 +42423,16 @@ func (x *NamespaceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3303 int - var yyb3303 bool - var yyhl3303 bool = l >= 0 - yyj3303++ - if yyhl3303 { - yyb3303 = yyj3303 > l + var yyj3319 int + var yyb3319 bool + var yyhl3319 bool = l >= 0 + yyj3319++ + if yyhl3319 { + yyb3319 = yyj3319 > l } else { - yyb3303 = r.CheckBreak() + yyb3319 = r.CheckBreak() } - if yyb3303 { + if yyb3319 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42240,17 +42443,17 @@ func (x *NamespaceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) x.Phase = NamespacePhase(r.DecodeString()) } for { - yyj3303++ - if yyhl3303 { - yyb3303 = yyj3303 > l + yyj3319++ + if yyhl3319 { + yyb3319 = yyj3319 > l } else { - yyb3303 = r.CheckBreak() + yyb3319 = r.CheckBreak() } - if yyb3303 { + if yyb3319 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3303-1, "") + z.DecStructFieldNotFound(yyj3319-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -42259,8 +42462,8 @@ func (x NamespacePhase) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym3305 := z.EncBinary() - _ = yym3305 + yym3321 := z.EncBinary() + _ = yym3321 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -42272,8 +42475,8 @@ func (x *NamespacePhase) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3306 := z.DecBinary() - _ = yym3306 + yym3322 := z.DecBinary() + _ = yym3322 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -42288,39 +42491,39 @@ func (x *Namespace) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3307 := z.EncBinary() - _ = yym3307 + yym3323 := z.EncBinary() + _ = yym3323 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3308 := !z.EncBinary() - yy2arr3308 := z.EncBasicHandle().StructToArray - var yyq3308 [5]bool - _, _, _ = yysep3308, yyq3308, yy2arr3308 - const yyr3308 bool = false - yyq3308[0] = x.Kind != "" - yyq3308[1] = x.APIVersion != "" - yyq3308[2] = true - yyq3308[3] = true - yyq3308[4] = true - var yynn3308 int - if yyr3308 || yy2arr3308 { + yysep3324 := !z.EncBinary() + yy2arr3324 := z.EncBasicHandle().StructToArray + var yyq3324 [5]bool + _, _, _ = yysep3324, yyq3324, yy2arr3324 + const yyr3324 bool = false + yyq3324[0] = x.Kind != "" + yyq3324[1] = x.APIVersion != "" + yyq3324[2] = true + yyq3324[3] = true + yyq3324[4] = true + var yynn3324 int + if yyr3324 || yy2arr3324 { r.EncodeArrayStart(5) } else { - yynn3308 = 0 - for _, b := range yyq3308 { + yynn3324 = 0 + for _, b := range yyq3324 { if b { - yynn3308++ + yynn3324++ } } - r.EncodeMapStart(yynn3308) - yynn3308 = 0 + r.EncodeMapStart(yynn3324) + yynn3324 = 0 } - if yyr3308 || yy2arr3308 { + if yyr3324 || yy2arr3324 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3308[0] { - yym3310 := z.EncBinary() - _ = yym3310 + if yyq3324[0] { + yym3326 := z.EncBinary() + _ = yym3326 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -42329,23 +42532,23 @@ func (x *Namespace) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3308[0] { + if yyq3324[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3311 := z.EncBinary() - _ = yym3311 + yym3327 := z.EncBinary() + _ = yym3327 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3308 || yy2arr3308 { + if yyr3324 || yy2arr3324 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3308[1] { - yym3313 := z.EncBinary() - _ = yym3313 + if yyq3324[1] { + yym3329 := z.EncBinary() + _ = yym3329 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -42354,70 +42557,70 @@ func (x *Namespace) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3308[1] { + if yyq3324[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3314 := z.EncBinary() - _ = yym3314 + yym3330 := z.EncBinary() + _ = yym3330 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3308 || yy2arr3308 { + if yyr3324 || yy2arr3324 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3308[2] { - yy3316 := &x.ObjectMeta - yy3316.CodecEncodeSelf(e) + if yyq3324[2] { + yy3332 := &x.ObjectMeta + yy3332.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3308[2] { + if yyq3324[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3317 := &x.ObjectMeta - yy3317.CodecEncodeSelf(e) + yy3333 := &x.ObjectMeta + yy3333.CodecEncodeSelf(e) } } - if yyr3308 || yy2arr3308 { + if yyr3324 || yy2arr3324 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3308[3] { - yy3319 := &x.Spec - yy3319.CodecEncodeSelf(e) + if yyq3324[3] { + yy3335 := &x.Spec + yy3335.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3308[3] { + if yyq3324[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3320 := &x.Spec - yy3320.CodecEncodeSelf(e) + yy3336 := &x.Spec + yy3336.CodecEncodeSelf(e) } } - if yyr3308 || yy2arr3308 { + if yyr3324 || yy2arr3324 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3308[4] { - yy3322 := &x.Status - yy3322.CodecEncodeSelf(e) + if yyq3324[4] { + yy3338 := &x.Status + yy3338.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3308[4] { + if yyq3324[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3323 := &x.Status - yy3323.CodecEncodeSelf(e) + yy3339 := &x.Status + yy3339.CodecEncodeSelf(e) } } - if yyr3308 || yy2arr3308 { + if yyr3324 || yy2arr3324 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -42430,25 +42633,25 @@ func (x *Namespace) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3324 := z.DecBinary() - _ = yym3324 + yym3340 := z.DecBinary() + _ = yym3340 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3325 := r.ContainerType() - if yyct3325 == codecSelferValueTypeMap1234 { - yyl3325 := r.ReadMapStart() - if yyl3325 == 0 { + yyct3341 := r.ContainerType() + if yyct3341 == codecSelferValueTypeMap1234 { + yyl3341 := r.ReadMapStart() + if yyl3341 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3325, d) + x.codecDecodeSelfFromMap(yyl3341, d) } - } else if yyct3325 == codecSelferValueTypeArray1234 { - yyl3325 := r.ReadArrayStart() - if yyl3325 == 0 { + } else if yyct3341 == codecSelferValueTypeArray1234 { + yyl3341 := r.ReadArrayStart() + if yyl3341 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3325, d) + x.codecDecodeSelfFromArray(yyl3341, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -42460,12 +42663,12 @@ func (x *Namespace) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3326Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3326Slc - var yyhl3326 bool = l >= 0 - for yyj3326 := 0; ; yyj3326++ { - if yyhl3326 { - if yyj3326 >= l { + var yys3342Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3342Slc + var yyhl3342 bool = l >= 0 + for yyj3342 := 0; ; yyj3342++ { + if yyhl3342 { + if yyj3342 >= l { break } } else { @@ -42474,10 +42677,10 @@ func (x *Namespace) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3326Slc = r.DecodeBytes(yys3326Slc, true, true) - yys3326 := string(yys3326Slc) + yys3342Slc = r.DecodeBytes(yys3342Slc, true, true) + yys3342 := string(yys3342Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3326 { + switch yys3342 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -42494,27 +42697,27 @@ func (x *Namespace) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3329 := &x.ObjectMeta - yyv3329.CodecDecodeSelf(d) + yyv3345 := &x.ObjectMeta + yyv3345.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = NamespaceSpec{} } else { - yyv3330 := &x.Spec - yyv3330.CodecDecodeSelf(d) + yyv3346 := &x.Spec + yyv3346.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = NamespaceStatus{} } else { - yyv3331 := &x.Status - yyv3331.CodecDecodeSelf(d) + yyv3347 := &x.Status + yyv3347.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys3326) - } // end switch yys3326 - } // end for yyj3326 + z.DecStructFieldNotFound(-1, yys3342) + } // end switch yys3342 + } // end for yyj3342 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -42522,16 +42725,16 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3332 int - var yyb3332 bool - var yyhl3332 bool = l >= 0 - yyj3332++ - if yyhl3332 { - yyb3332 = yyj3332 > l + var yyj3348 int + var yyb3348 bool + var yyhl3348 bool = l >= 0 + yyj3348++ + if yyhl3348 { + yyb3348 = yyj3348 > l } else { - yyb3332 = r.CheckBreak() + yyb3348 = r.CheckBreak() } - if yyb3332 { + if yyb3348 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42541,13 +42744,13 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3332++ - if yyhl3332 { - yyb3332 = yyj3332 > l + yyj3348++ + if yyhl3348 { + yyb3348 = yyj3348 > l } else { - yyb3332 = r.CheckBreak() + yyb3348 = r.CheckBreak() } - if yyb3332 { + if yyb3348 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42557,13 +42760,13 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3332++ - if yyhl3332 { - yyb3332 = yyj3332 > l + yyj3348++ + if yyhl3348 { + yyb3348 = yyj3348 > l } else { - yyb3332 = r.CheckBreak() + yyb3348 = r.CheckBreak() } - if yyb3332 { + if yyb3348 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42571,16 +42774,16 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3335 := &x.ObjectMeta - yyv3335.CodecDecodeSelf(d) + yyv3351 := &x.ObjectMeta + yyv3351.CodecDecodeSelf(d) } - yyj3332++ - if yyhl3332 { - yyb3332 = yyj3332 > l + yyj3348++ + if yyhl3348 { + yyb3348 = yyj3348 > l } else { - yyb3332 = r.CheckBreak() + yyb3348 = r.CheckBreak() } - if yyb3332 { + if yyb3348 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42588,16 +42791,16 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Spec = NamespaceSpec{} } else { - yyv3336 := &x.Spec - yyv3336.CodecDecodeSelf(d) + yyv3352 := &x.Spec + yyv3352.CodecDecodeSelf(d) } - yyj3332++ - if yyhl3332 { - yyb3332 = yyj3332 > l + yyj3348++ + if yyhl3348 { + yyb3348 = yyj3348 > l } else { - yyb3332 = r.CheckBreak() + yyb3348 = r.CheckBreak() } - if yyb3332 { + if yyb3348 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42605,21 +42808,21 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Status = NamespaceStatus{} } else { - yyv3337 := &x.Status - yyv3337.CodecDecodeSelf(d) + yyv3353 := &x.Status + yyv3353.CodecDecodeSelf(d) } for { - yyj3332++ - if yyhl3332 { - yyb3332 = yyj3332 > l + yyj3348++ + if yyhl3348 { + yyb3348 = yyj3348 > l } else { - yyb3332 = r.CheckBreak() + yyb3348 = r.CheckBreak() } - if yyb3332 { + if yyb3348 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3332-1, "") + z.DecStructFieldNotFound(yyj3348-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -42631,37 +42834,37 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3338 := z.EncBinary() - _ = yym3338 + yym3354 := z.EncBinary() + _ = yym3354 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3339 := !z.EncBinary() - yy2arr3339 := z.EncBasicHandle().StructToArray - var yyq3339 [4]bool - _, _, _ = yysep3339, yyq3339, yy2arr3339 - const yyr3339 bool = false - yyq3339[0] = x.Kind != "" - yyq3339[1] = x.APIVersion != "" - yyq3339[2] = true - var yynn3339 int - if yyr3339 || yy2arr3339 { + yysep3355 := !z.EncBinary() + yy2arr3355 := z.EncBasicHandle().StructToArray + var yyq3355 [4]bool + _, _, _ = yysep3355, yyq3355, yy2arr3355 + const yyr3355 bool = false + yyq3355[0] = x.Kind != "" + yyq3355[1] = x.APIVersion != "" + yyq3355[2] = true + var yynn3355 int + if yyr3355 || yy2arr3355 { r.EncodeArrayStart(4) } else { - yynn3339 = 1 - for _, b := range yyq3339 { + yynn3355 = 1 + for _, b := range yyq3355 { if b { - yynn3339++ + yynn3355++ } } - r.EncodeMapStart(yynn3339) - yynn3339 = 0 + r.EncodeMapStart(yynn3355) + yynn3355 = 0 } - if yyr3339 || yy2arr3339 { + if yyr3355 || yy2arr3355 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3339[0] { - yym3341 := z.EncBinary() - _ = yym3341 + if yyq3355[0] { + yym3357 := z.EncBinary() + _ = yym3357 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -42670,23 +42873,23 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3339[0] { + if yyq3355[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3342 := z.EncBinary() - _ = yym3342 + yym3358 := z.EncBinary() + _ = yym3358 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3339 || yy2arr3339 { + if yyr3355 || yy2arr3355 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3339[1] { - yym3344 := z.EncBinary() - _ = yym3344 + if yyq3355[1] { + yym3360 := z.EncBinary() + _ = yym3360 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -42695,54 +42898,54 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3339[1] { + if yyq3355[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3345 := z.EncBinary() - _ = yym3345 + yym3361 := z.EncBinary() + _ = yym3361 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3339 || yy2arr3339 { + if yyr3355 || yy2arr3355 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3339[2] { - yy3347 := &x.ListMeta - yym3348 := z.EncBinary() - _ = yym3348 + if yyq3355[2] { + yy3363 := &x.ListMeta + yym3364 := z.EncBinary() + _ = yym3364 if false { - } else if z.HasExtensions() && z.EncExt(yy3347) { + } else if z.HasExtensions() && z.EncExt(yy3363) { } else { - z.EncFallback(yy3347) + z.EncFallback(yy3363) } } else { r.EncodeNil() } } else { - if yyq3339[2] { + if yyq3355[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3349 := &x.ListMeta - yym3350 := z.EncBinary() - _ = yym3350 + yy3365 := &x.ListMeta + yym3366 := z.EncBinary() + _ = yym3366 if false { - } else if z.HasExtensions() && z.EncExt(yy3349) { + } else if z.HasExtensions() && z.EncExt(yy3365) { } else { - z.EncFallback(yy3349) + z.EncFallback(yy3365) } } } - if yyr3339 || yy2arr3339 { + if yyr3355 || yy2arr3355 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym3352 := z.EncBinary() - _ = yym3352 + yym3368 := z.EncBinary() + _ = yym3368 if false { } else { h.encSliceNamespace(([]Namespace)(x.Items), e) @@ -42755,15 +42958,15 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym3353 := z.EncBinary() - _ = yym3353 + yym3369 := z.EncBinary() + _ = yym3369 if false { } else { h.encSliceNamespace(([]Namespace)(x.Items), e) } } } - if yyr3339 || yy2arr3339 { + if yyr3355 || yy2arr3355 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -42776,25 +42979,25 @@ func (x *NamespaceList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3354 := z.DecBinary() - _ = yym3354 + yym3370 := z.DecBinary() + _ = yym3370 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3355 := r.ContainerType() - if yyct3355 == codecSelferValueTypeMap1234 { - yyl3355 := r.ReadMapStart() - if yyl3355 == 0 { + yyct3371 := r.ContainerType() + if yyct3371 == codecSelferValueTypeMap1234 { + yyl3371 := r.ReadMapStart() + if yyl3371 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3355, d) + x.codecDecodeSelfFromMap(yyl3371, d) } - } else if yyct3355 == codecSelferValueTypeArray1234 { - yyl3355 := r.ReadArrayStart() - if yyl3355 == 0 { + } else if yyct3371 == codecSelferValueTypeArray1234 { + yyl3371 := r.ReadArrayStart() + if yyl3371 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3355, d) + x.codecDecodeSelfFromArray(yyl3371, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -42806,12 +43009,12 @@ func (x *NamespaceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3356Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3356Slc - var yyhl3356 bool = l >= 0 - for yyj3356 := 0; ; yyj3356++ { - if yyhl3356 { - if yyj3356 >= l { + var yys3372Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3372Slc + var yyhl3372 bool = l >= 0 + for yyj3372 := 0; ; yyj3372++ { + if yyhl3372 { + if yyj3372 >= l { break } } else { @@ -42820,10 +43023,10 @@ func (x *NamespaceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3356Slc = r.DecodeBytes(yys3356Slc, true, true) - yys3356 := string(yys3356Slc) + yys3372Slc = r.DecodeBytes(yys3372Slc, true, true) + yys3372 := string(yys3372Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3356 { + switch yys3372 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -42840,31 +43043,31 @@ func (x *NamespaceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3359 := &x.ListMeta - yym3360 := z.DecBinary() - _ = yym3360 + yyv3375 := &x.ListMeta + yym3376 := z.DecBinary() + _ = yym3376 if false { - } else if z.HasExtensions() && z.DecExt(yyv3359) { + } else if z.HasExtensions() && z.DecExt(yyv3375) { } else { - z.DecFallback(yyv3359, false) + z.DecFallback(yyv3375, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3361 := &x.Items - yym3362 := z.DecBinary() - _ = yym3362 + yyv3377 := &x.Items + yym3378 := z.DecBinary() + _ = yym3378 if false { } else { - h.decSliceNamespace((*[]Namespace)(yyv3361), d) + h.decSliceNamespace((*[]Namespace)(yyv3377), d) } } default: - z.DecStructFieldNotFound(-1, yys3356) - } // end switch yys3356 - } // end for yyj3356 + z.DecStructFieldNotFound(-1, yys3372) + } // end switch yys3372 + } // end for yyj3372 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -42872,16 +43075,16 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3363 int - var yyb3363 bool - var yyhl3363 bool = l >= 0 - yyj3363++ - if yyhl3363 { - yyb3363 = yyj3363 > l + var yyj3379 int + var yyb3379 bool + var yyhl3379 bool = l >= 0 + yyj3379++ + if yyhl3379 { + yyb3379 = yyj3379 > l } else { - yyb3363 = r.CheckBreak() + yyb3379 = r.CheckBreak() } - if yyb3363 { + if yyb3379 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42891,13 +43094,13 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3363++ - if yyhl3363 { - yyb3363 = yyj3363 > l + yyj3379++ + if yyhl3379 { + yyb3379 = yyj3379 > l } else { - yyb3363 = r.CheckBreak() + yyb3379 = r.CheckBreak() } - if yyb3363 { + if yyb3379 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42907,13 +43110,13 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3363++ - if yyhl3363 { - yyb3363 = yyj3363 > l + yyj3379++ + if yyhl3379 { + yyb3379 = yyj3379 > l } else { - yyb3363 = r.CheckBreak() + yyb3379 = r.CheckBreak() } - if yyb3363 { + if yyb3379 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42921,22 +43124,22 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3366 := &x.ListMeta - yym3367 := z.DecBinary() - _ = yym3367 + yyv3382 := &x.ListMeta + yym3383 := z.DecBinary() + _ = yym3383 if false { - } else if z.HasExtensions() && z.DecExt(yyv3366) { + } else if z.HasExtensions() && z.DecExt(yyv3382) { } else { - z.DecFallback(yyv3366, false) + z.DecFallback(yyv3382, false) } } - yyj3363++ - if yyhl3363 { - yyb3363 = yyj3363 > l + yyj3379++ + if yyhl3379 { + yyb3379 = yyj3379 > l } else { - yyb3363 = r.CheckBreak() + yyb3379 = r.CheckBreak() } - if yyb3363 { + if yyb3379 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -42944,26 +43147,26 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3368 := &x.Items - yym3369 := z.DecBinary() - _ = yym3369 + yyv3384 := &x.Items + yym3385 := z.DecBinary() + _ = yym3385 if false { } else { - h.decSliceNamespace((*[]Namespace)(yyv3368), d) + h.decSliceNamespace((*[]Namespace)(yyv3384), d) } } for { - yyj3363++ - if yyhl3363 { - yyb3363 = yyj3363 > l + yyj3379++ + if yyhl3379 { + yyb3379 = yyj3379 > l } else { - yyb3363 = r.CheckBreak() + yyb3379 = r.CheckBreak() } - if yyb3363 { + if yyb3379 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3363-1, "") + z.DecStructFieldNotFound(yyj3379-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -42975,37 +43178,37 @@ func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3370 := z.EncBinary() - _ = yym3370 + yym3386 := z.EncBinary() + _ = yym3386 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3371 := !z.EncBinary() - yy2arr3371 := z.EncBasicHandle().StructToArray - var yyq3371 [4]bool - _, _, _ = yysep3371, yyq3371, yy2arr3371 - const yyr3371 bool = false - yyq3371[0] = x.Kind != "" - yyq3371[1] = x.APIVersion != "" - yyq3371[2] = true - var yynn3371 int - if yyr3371 || yy2arr3371 { + yysep3387 := !z.EncBinary() + yy2arr3387 := z.EncBasicHandle().StructToArray + var yyq3387 [4]bool + _, _, _ = yysep3387, yyq3387, yy2arr3387 + const yyr3387 bool = false + yyq3387[0] = x.Kind != "" + yyq3387[1] = x.APIVersion != "" + yyq3387[2] = true + var yynn3387 int + if yyr3387 || yy2arr3387 { r.EncodeArrayStart(4) } else { - yynn3371 = 1 - for _, b := range yyq3371 { + yynn3387 = 1 + for _, b := range yyq3387 { if b { - yynn3371++ + yynn3387++ } } - r.EncodeMapStart(yynn3371) - yynn3371 = 0 + r.EncodeMapStart(yynn3387) + yynn3387 = 0 } - if yyr3371 || yy2arr3371 { + if yyr3387 || yy2arr3387 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3371[0] { - yym3373 := z.EncBinary() - _ = yym3373 + if yyq3387[0] { + yym3389 := z.EncBinary() + _ = yym3389 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -43014,23 +43217,23 @@ func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3371[0] { + if yyq3387[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3374 := z.EncBinary() - _ = yym3374 + yym3390 := z.EncBinary() + _ = yym3390 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3371 || yy2arr3371 { + if yyr3387 || yy2arr3387 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3371[1] { - yym3376 := z.EncBinary() - _ = yym3376 + if yyq3387[1] { + yym3392 := z.EncBinary() + _ = yym3392 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -43039,47 +43242,47 @@ func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3371[1] { + if yyq3387[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3377 := z.EncBinary() - _ = yym3377 + yym3393 := z.EncBinary() + _ = yym3393 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3371 || yy2arr3371 { + if yyr3387 || yy2arr3387 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3371[2] { - yy3379 := &x.ObjectMeta - yy3379.CodecEncodeSelf(e) + if yyq3387[2] { + yy3395 := &x.ObjectMeta + yy3395.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3371[2] { + if yyq3387[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3380 := &x.ObjectMeta - yy3380.CodecEncodeSelf(e) + yy3396 := &x.ObjectMeta + yy3396.CodecEncodeSelf(e) } } - if yyr3371 || yy2arr3371 { + if yyr3387 || yy2arr3387 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy3382 := &x.Target - yy3382.CodecEncodeSelf(e) + yy3398 := &x.Target + yy3398.CodecEncodeSelf(e) } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("target")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3383 := &x.Target - yy3383.CodecEncodeSelf(e) + yy3399 := &x.Target + yy3399.CodecEncodeSelf(e) } - if yyr3371 || yy2arr3371 { + if yyr3387 || yy2arr3387 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -43092,25 +43295,25 @@ func (x *Binding) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3384 := z.DecBinary() - _ = yym3384 + yym3400 := z.DecBinary() + _ = yym3400 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3385 := r.ContainerType() - if yyct3385 == codecSelferValueTypeMap1234 { - yyl3385 := r.ReadMapStart() - if yyl3385 == 0 { + yyct3401 := r.ContainerType() + if yyct3401 == codecSelferValueTypeMap1234 { + yyl3401 := r.ReadMapStart() + if yyl3401 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3385, d) + x.codecDecodeSelfFromMap(yyl3401, d) } - } else if yyct3385 == codecSelferValueTypeArray1234 { - yyl3385 := r.ReadArrayStart() - if yyl3385 == 0 { + } else if yyct3401 == codecSelferValueTypeArray1234 { + yyl3401 := r.ReadArrayStart() + if yyl3401 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3385, d) + x.codecDecodeSelfFromArray(yyl3401, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -43122,12 +43325,12 @@ func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3386Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3386Slc - var yyhl3386 bool = l >= 0 - for yyj3386 := 0; ; yyj3386++ { - if yyhl3386 { - if yyj3386 >= l { + var yys3402Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3402Slc + var yyhl3402 bool = l >= 0 + for yyj3402 := 0; ; yyj3402++ { + if yyhl3402 { + if yyj3402 >= l { break } } else { @@ -43136,10 +43339,10 @@ func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3386Slc = r.DecodeBytes(yys3386Slc, true, true) - yys3386 := string(yys3386Slc) + yys3402Slc = r.DecodeBytes(yys3402Slc, true, true) + yys3402 := string(yys3402Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3386 { + switch yys3402 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -43156,20 +43359,20 @@ func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3389 := &x.ObjectMeta - yyv3389.CodecDecodeSelf(d) + yyv3405 := &x.ObjectMeta + yyv3405.CodecDecodeSelf(d) } case "target": if r.TryDecodeAsNil() { x.Target = ObjectReference{} } else { - yyv3390 := &x.Target - yyv3390.CodecDecodeSelf(d) + yyv3406 := &x.Target + yyv3406.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys3386) - } // end switch yys3386 - } // end for yyj3386 + z.DecStructFieldNotFound(-1, yys3402) + } // end switch yys3402 + } // end for yyj3402 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -43177,16 +43380,16 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3391 int - var yyb3391 bool - var yyhl3391 bool = l >= 0 - yyj3391++ - if yyhl3391 { - yyb3391 = yyj3391 > l + var yyj3407 int + var yyb3407 bool + var yyhl3407 bool = l >= 0 + yyj3407++ + if yyhl3407 { + yyb3407 = yyj3407 > l } else { - yyb3391 = r.CheckBreak() + yyb3407 = r.CheckBreak() } - if yyb3391 { + if yyb3407 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43196,13 +43399,13 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3391++ - if yyhl3391 { - yyb3391 = yyj3391 > l + yyj3407++ + if yyhl3407 { + yyb3407 = yyj3407 > l } else { - yyb3391 = r.CheckBreak() + yyb3407 = r.CheckBreak() } - if yyb3391 { + if yyb3407 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43212,13 +43415,13 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3391++ - if yyhl3391 { - yyb3391 = yyj3391 > l + yyj3407++ + if yyhl3407 { + yyb3407 = yyj3407 > l } else { - yyb3391 = r.CheckBreak() + yyb3407 = r.CheckBreak() } - if yyb3391 { + if yyb3407 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43226,16 +43429,16 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3394 := &x.ObjectMeta - yyv3394.CodecDecodeSelf(d) + yyv3410 := &x.ObjectMeta + yyv3410.CodecDecodeSelf(d) } - yyj3391++ - if yyhl3391 { - yyb3391 = yyj3391 > l + yyj3407++ + if yyhl3407 { + yyb3407 = yyj3407 > l } else { - yyb3391 = r.CheckBreak() + yyb3407 = r.CheckBreak() } - if yyb3391 { + if yyb3407 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43243,21 +43446,21 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Target = ObjectReference{} } else { - yyv3395 := &x.Target - yyv3395.CodecDecodeSelf(d) + yyv3411 := &x.Target + yyv3411.CodecDecodeSelf(d) } for { - yyj3391++ - if yyhl3391 { - yyb3391 = yyj3391 > l + yyj3407++ + if yyhl3407 { + yyb3407 = yyj3407 > l } else { - yyb3391 = r.CheckBreak() + yyb3407 = r.CheckBreak() } - if yyb3391 { + if yyb3407 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3391-1, "") + z.DecStructFieldNotFound(yyj3407-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -43269,68 +43472,68 @@ func (x *Preconditions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3396 := z.EncBinary() - _ = yym3396 + yym3412 := z.EncBinary() + _ = yym3412 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3397 := !z.EncBinary() - yy2arr3397 := z.EncBasicHandle().StructToArray - var yyq3397 [1]bool - _, _, _ = yysep3397, yyq3397, yy2arr3397 - const yyr3397 bool = false - yyq3397[0] = x.UID != nil - var yynn3397 int - if yyr3397 || yy2arr3397 { + yysep3413 := !z.EncBinary() + yy2arr3413 := z.EncBasicHandle().StructToArray + var yyq3413 [1]bool + _, _, _ = yysep3413, yyq3413, yy2arr3413 + const yyr3413 bool = false + yyq3413[0] = x.UID != nil + var yynn3413 int + if yyr3413 || yy2arr3413 { r.EncodeArrayStart(1) } else { - yynn3397 = 0 - for _, b := range yyq3397 { + yynn3413 = 0 + for _, b := range yyq3413 { if b { - yynn3397++ + yynn3413++ } } - r.EncodeMapStart(yynn3397) - yynn3397 = 0 + r.EncodeMapStart(yynn3413) + yynn3413 = 0 } - if yyr3397 || yy2arr3397 { + if yyr3413 || yy2arr3413 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3397[0] { + if yyq3413[0] { if x.UID == nil { r.EncodeNil() } else { - yy3399 := *x.UID - yym3400 := z.EncBinary() - _ = yym3400 + yy3415 := *x.UID + yym3416 := z.EncBinary() + _ = yym3416 if false { - } else if z.HasExtensions() && z.EncExt(yy3399) { + } else if z.HasExtensions() && z.EncExt(yy3415) { } else { - r.EncodeString(codecSelferC_UTF81234, string(yy3399)) + r.EncodeString(codecSelferC_UTF81234, string(yy3415)) } } } else { r.EncodeNil() } } else { - if yyq3397[0] { + if yyq3413[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("uid")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.UID == nil { r.EncodeNil() } else { - yy3401 := *x.UID - yym3402 := z.EncBinary() - _ = yym3402 + yy3417 := *x.UID + yym3418 := z.EncBinary() + _ = yym3418 if false { - } else if z.HasExtensions() && z.EncExt(yy3401) { + } else if z.HasExtensions() && z.EncExt(yy3417) { } else { - r.EncodeString(codecSelferC_UTF81234, string(yy3401)) + r.EncodeString(codecSelferC_UTF81234, string(yy3417)) } } } } - if yyr3397 || yy2arr3397 { + if yyr3413 || yy2arr3413 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -43343,25 +43546,25 @@ func (x *Preconditions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3403 := z.DecBinary() - _ = yym3403 + yym3419 := z.DecBinary() + _ = yym3419 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3404 := r.ContainerType() - if yyct3404 == codecSelferValueTypeMap1234 { - yyl3404 := r.ReadMapStart() - if yyl3404 == 0 { + yyct3420 := r.ContainerType() + if yyct3420 == codecSelferValueTypeMap1234 { + yyl3420 := r.ReadMapStart() + if yyl3420 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3404, d) + x.codecDecodeSelfFromMap(yyl3420, d) } - } else if yyct3404 == codecSelferValueTypeArray1234 { - yyl3404 := r.ReadArrayStart() - if yyl3404 == 0 { + } else if yyct3420 == codecSelferValueTypeArray1234 { + yyl3420 := r.ReadArrayStart() + if yyl3420 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3404, d) + x.codecDecodeSelfFromArray(yyl3420, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -43373,12 +43576,12 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3405Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3405Slc - var yyhl3405 bool = l >= 0 - for yyj3405 := 0; ; yyj3405++ { - if yyhl3405 { - if yyj3405 >= l { + var yys3421Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3421Slc + var yyhl3421 bool = l >= 0 + for yyj3421 := 0; ; yyj3421++ { + if yyhl3421 { + if yyj3421 >= l { break } } else { @@ -43387,10 +43590,10 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3405Slc = r.DecodeBytes(yys3405Slc, true, true) - yys3405 := string(yys3405Slc) + yys3421Slc = r.DecodeBytes(yys3421Slc, true, true) + yys3421 := string(yys3421Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3405 { + switch yys3421 { case "uid": if r.TryDecodeAsNil() { if x.UID != nil { @@ -43400,8 +43603,8 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.UID == nil { x.UID = new(pkg1_types.UID) } - yym3407 := z.DecBinary() - _ = yym3407 + yym3423 := z.DecBinary() + _ = yym3423 if false { } else if z.HasExtensions() && z.DecExt(x.UID) { } else { @@ -43409,9 +43612,9 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } default: - z.DecStructFieldNotFound(-1, yys3405) - } // end switch yys3405 - } // end for yyj3405 + z.DecStructFieldNotFound(-1, yys3421) + } // end switch yys3421 + } // end for yyj3421 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -43419,16 +43622,16 @@ func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3408 int - var yyb3408 bool - var yyhl3408 bool = l >= 0 - yyj3408++ - if yyhl3408 { - yyb3408 = yyj3408 > l + var yyj3424 int + var yyb3424 bool + var yyhl3424 bool = l >= 0 + yyj3424++ + if yyhl3424 { + yyb3424 = yyj3424 > l } else { - yyb3408 = r.CheckBreak() + yyb3424 = r.CheckBreak() } - if yyb3408 { + if yyb3424 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43441,8 +43644,8 @@ func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.UID == nil { x.UID = new(pkg1_types.UID) } - yym3410 := z.DecBinary() - _ = yym3410 + yym3426 := z.DecBinary() + _ = yym3426 if false { } else if z.HasExtensions() && z.DecExt(x.UID) { } else { @@ -43450,17 +43653,17 @@ func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } } for { - yyj3408++ - if yyhl3408 { - yyb3408 = yyj3408 > l + yyj3424++ + if yyhl3424 { + yyb3424 = yyj3424 > l } else { - yyb3408 = r.CheckBreak() + yyb3424 = r.CheckBreak() } - if yyb3408 { + if yyb3424 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3408-1, "") + z.DecStructFieldNotFound(yyj3424-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -43472,39 +43675,39 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3411 := z.EncBinary() - _ = yym3411 + yym3427 := z.EncBinary() + _ = yym3427 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3412 := !z.EncBinary() - yy2arr3412 := z.EncBasicHandle().StructToArray - var yyq3412 [5]bool - _, _, _ = yysep3412, yyq3412, yy2arr3412 - const yyr3412 bool = false - yyq3412[0] = x.Kind != "" - yyq3412[1] = x.APIVersion != "" - yyq3412[2] = x.GracePeriodSeconds != nil - yyq3412[3] = x.Preconditions != nil - yyq3412[4] = x.OrphanDependents != nil - var yynn3412 int - if yyr3412 || yy2arr3412 { + yysep3428 := !z.EncBinary() + yy2arr3428 := z.EncBasicHandle().StructToArray + var yyq3428 [5]bool + _, _, _ = yysep3428, yyq3428, yy2arr3428 + const yyr3428 bool = false + yyq3428[0] = x.Kind != "" + yyq3428[1] = x.APIVersion != "" + yyq3428[2] = x.GracePeriodSeconds != nil + yyq3428[3] = x.Preconditions != nil + yyq3428[4] = x.OrphanDependents != nil + var yynn3428 int + if yyr3428 || yy2arr3428 { r.EncodeArrayStart(5) } else { - yynn3412 = 0 - for _, b := range yyq3412 { + yynn3428 = 0 + for _, b := range yyq3428 { if b { - yynn3412++ + yynn3428++ } } - r.EncodeMapStart(yynn3412) - yynn3412 = 0 + r.EncodeMapStart(yynn3428) + yynn3428 = 0 } - if yyr3412 || yy2arr3412 { + if yyr3428 || yy2arr3428 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3412[0] { - yym3414 := z.EncBinary() - _ = yym3414 + if yyq3428[0] { + yym3430 := z.EncBinary() + _ = yym3430 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -43513,23 +43716,23 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3412[0] { + if yyq3428[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3415 := z.EncBinary() - _ = yym3415 + yym3431 := z.EncBinary() + _ = yym3431 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3412 || yy2arr3412 { + if yyr3428 || yy2arr3428 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3412[1] { - yym3417 := z.EncBinary() - _ = yym3417 + if yyq3428[1] { + yym3433 := z.EncBinary() + _ = yym3433 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -43538,56 +43741,56 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3412[1] { + if yyq3428[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3418 := z.EncBinary() - _ = yym3418 + yym3434 := z.EncBinary() + _ = yym3434 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3412 || yy2arr3412 { + if yyr3428 || yy2arr3428 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3412[2] { + if yyq3428[2] { if x.GracePeriodSeconds == nil { r.EncodeNil() } else { - yy3420 := *x.GracePeriodSeconds - yym3421 := z.EncBinary() - _ = yym3421 + yy3436 := *x.GracePeriodSeconds + yym3437 := z.EncBinary() + _ = yym3437 if false { } else { - r.EncodeInt(int64(yy3420)) + r.EncodeInt(int64(yy3436)) } } } else { r.EncodeNil() } } else { - if yyq3412[2] { + if yyq3428[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("gracePeriodSeconds")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.GracePeriodSeconds == nil { r.EncodeNil() } else { - yy3422 := *x.GracePeriodSeconds - yym3423 := z.EncBinary() - _ = yym3423 + yy3438 := *x.GracePeriodSeconds + yym3439 := z.EncBinary() + _ = yym3439 if false { } else { - r.EncodeInt(int64(yy3422)) + r.EncodeInt(int64(yy3438)) } } } } - if yyr3412 || yy2arr3412 { + if yyr3428 || yy2arr3428 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3412[3] { + if yyq3428[3] { if x.Preconditions == nil { r.EncodeNil() } else { @@ -43597,7 +43800,7 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq3412[3] { + if yyq3428[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("preconditions")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -43608,42 +43811,42 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3412 || yy2arr3412 { + if yyr3428 || yy2arr3428 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3412[4] { + if yyq3428[4] { if x.OrphanDependents == nil { r.EncodeNil() } else { - yy3426 := *x.OrphanDependents - yym3427 := z.EncBinary() - _ = yym3427 + yy3442 := *x.OrphanDependents + yym3443 := z.EncBinary() + _ = yym3443 if false { } else { - r.EncodeBool(bool(yy3426)) + r.EncodeBool(bool(yy3442)) } } } else { r.EncodeNil() } } else { - if yyq3412[4] { + if yyq3428[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("orphanDependents")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.OrphanDependents == nil { r.EncodeNil() } else { - yy3428 := *x.OrphanDependents - yym3429 := z.EncBinary() - _ = yym3429 + yy3444 := *x.OrphanDependents + yym3445 := z.EncBinary() + _ = yym3445 if false { } else { - r.EncodeBool(bool(yy3428)) + r.EncodeBool(bool(yy3444)) } } } } - if yyr3412 || yy2arr3412 { + if yyr3428 || yy2arr3428 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -43656,25 +43859,25 @@ func (x *DeleteOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3430 := z.DecBinary() - _ = yym3430 + yym3446 := z.DecBinary() + _ = yym3446 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3431 := r.ContainerType() - if yyct3431 == codecSelferValueTypeMap1234 { - yyl3431 := r.ReadMapStart() - if yyl3431 == 0 { + yyct3447 := r.ContainerType() + if yyct3447 == codecSelferValueTypeMap1234 { + yyl3447 := r.ReadMapStart() + if yyl3447 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3431, d) + x.codecDecodeSelfFromMap(yyl3447, d) } - } else if yyct3431 == codecSelferValueTypeArray1234 { - yyl3431 := r.ReadArrayStart() - if yyl3431 == 0 { + } else if yyct3447 == codecSelferValueTypeArray1234 { + yyl3447 := r.ReadArrayStart() + if yyl3447 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3431, d) + x.codecDecodeSelfFromArray(yyl3447, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -43686,12 +43889,12 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3432Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3432Slc - var yyhl3432 bool = l >= 0 - for yyj3432 := 0; ; yyj3432++ { - if yyhl3432 { - if yyj3432 >= l { + var yys3448Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3448Slc + var yyhl3448 bool = l >= 0 + for yyj3448 := 0; ; yyj3448++ { + if yyhl3448 { + if yyj3448 >= l { break } } else { @@ -43700,10 +43903,10 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3432Slc = r.DecodeBytes(yys3432Slc, true, true) - yys3432 := string(yys3432Slc) + yys3448Slc = r.DecodeBytes(yys3448Slc, true, true) + yys3448 := string(yys3448Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3432 { + switch yys3448 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -43725,8 +43928,8 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.GracePeriodSeconds == nil { x.GracePeriodSeconds = new(int64) } - yym3436 := z.DecBinary() - _ = yym3436 + yym3452 := z.DecBinary() + _ = yym3452 if false { } else { *((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64)) @@ -43752,17 +43955,17 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.OrphanDependents == nil { x.OrphanDependents = new(bool) } - yym3439 := z.DecBinary() - _ = yym3439 + yym3455 := z.DecBinary() + _ = yym3455 if false { } else { *((*bool)(x.OrphanDependents)) = r.DecodeBool() } } default: - z.DecStructFieldNotFound(-1, yys3432) - } // end switch yys3432 - } // end for yyj3432 + z.DecStructFieldNotFound(-1, yys3448) + } // end switch yys3448 + } // end for yyj3448 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -43770,16 +43973,16 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3440 int - var yyb3440 bool - var yyhl3440 bool = l >= 0 - yyj3440++ - if yyhl3440 { - yyb3440 = yyj3440 > l + var yyj3456 int + var yyb3456 bool + var yyhl3456 bool = l >= 0 + yyj3456++ + if yyhl3456 { + yyb3456 = yyj3456 > l } else { - yyb3440 = r.CheckBreak() + yyb3456 = r.CheckBreak() } - if yyb3440 { + if yyb3456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43789,13 +43992,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3440++ - if yyhl3440 { - yyb3440 = yyj3440 > l + yyj3456++ + if yyhl3456 { + yyb3456 = yyj3456 > l } else { - yyb3440 = r.CheckBreak() + yyb3456 = r.CheckBreak() } - if yyb3440 { + if yyb3456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43805,13 +44008,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3440++ - if yyhl3440 { - yyb3440 = yyj3440 > l + yyj3456++ + if yyhl3456 { + yyb3456 = yyj3456 > l } else { - yyb3440 = r.CheckBreak() + yyb3456 = r.CheckBreak() } - if yyb3440 { + if yyb3456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43824,20 +44027,20 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.GracePeriodSeconds == nil { x.GracePeriodSeconds = new(int64) } - yym3444 := z.DecBinary() - _ = yym3444 + yym3460 := z.DecBinary() + _ = yym3460 if false { } else { *((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64)) } } - yyj3440++ - if yyhl3440 { - yyb3440 = yyj3440 > l + yyj3456++ + if yyhl3456 { + yyb3456 = yyj3456 > l } else { - yyb3440 = r.CheckBreak() + yyb3456 = r.CheckBreak() } - if yyb3440 { + if yyb3456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43852,13 +44055,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } x.Preconditions.CodecDecodeSelf(d) } - yyj3440++ - if yyhl3440 { - yyb3440 = yyj3440 > l + yyj3456++ + if yyhl3456 { + yyb3456 = yyj3456 > l } else { - yyb3440 = r.CheckBreak() + yyb3456 = r.CheckBreak() } - if yyb3440 { + if yyb3456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -43871,25 +44074,25 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.OrphanDependents == nil { x.OrphanDependents = new(bool) } - yym3447 := z.DecBinary() - _ = yym3447 + yym3463 := z.DecBinary() + _ = yym3463 if false { } else { *((*bool)(x.OrphanDependents)) = r.DecodeBool() } } for { - yyj3440++ - if yyhl3440 { - yyb3440 = yyj3440 > l + yyj3456++ + if yyhl3456 { + yyb3456 = yyj3456 > l } else { - yyb3440 = r.CheckBreak() + yyb3456 = r.CheckBreak() } - if yyb3440 { + if yyb3456 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3440-1, "") + z.DecStructFieldNotFound(yyj3456-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -43901,36 +44104,36 @@ func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3448 := z.EncBinary() - _ = yym3448 + yym3464 := z.EncBinary() + _ = yym3464 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3449 := !z.EncBinary() - yy2arr3449 := z.EncBasicHandle().StructToArray - var yyq3449 [4]bool - _, _, _ = yysep3449, yyq3449, yy2arr3449 - const yyr3449 bool = false - yyq3449[0] = x.Kind != "" - yyq3449[1] = x.APIVersion != "" - var yynn3449 int - if yyr3449 || yy2arr3449 { + yysep3465 := !z.EncBinary() + yy2arr3465 := z.EncBasicHandle().StructToArray + var yyq3465 [4]bool + _, _, _ = yysep3465, yyq3465, yy2arr3465 + const yyr3465 bool = false + yyq3465[0] = x.Kind != "" + yyq3465[1] = x.APIVersion != "" + var yynn3465 int + if yyr3465 || yy2arr3465 { r.EncodeArrayStart(4) } else { - yynn3449 = 2 - for _, b := range yyq3449 { + yynn3465 = 2 + for _, b := range yyq3465 { if b { - yynn3449++ + yynn3465++ } } - r.EncodeMapStart(yynn3449) - yynn3449 = 0 + r.EncodeMapStart(yynn3465) + yynn3465 = 0 } - if yyr3449 || yy2arr3449 { + if yyr3465 || yy2arr3465 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3449[0] { - yym3451 := z.EncBinary() - _ = yym3451 + if yyq3465[0] { + yym3467 := z.EncBinary() + _ = yym3467 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -43939,23 +44142,23 @@ func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3449[0] { + if yyq3465[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3452 := z.EncBinary() - _ = yym3452 + yym3468 := z.EncBinary() + _ = yym3468 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3449 || yy2arr3449 { + if yyr3465 || yy2arr3465 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3449[1] { - yym3454 := z.EncBinary() - _ = yym3454 + if yyq3465[1] { + yym3470 := z.EncBinary() + _ = yym3470 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -43964,22 +44167,22 @@ func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3449[1] { + if yyq3465[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3455 := z.EncBinary() - _ = yym3455 + yym3471 := z.EncBinary() + _ = yym3471 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3449 || yy2arr3449 { + if yyr3465 || yy2arr3465 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3457 := z.EncBinary() - _ = yym3457 + yym3473 := z.EncBinary() + _ = yym3473 if false { } else { r.EncodeBool(bool(x.Export)) @@ -43988,17 +44191,17 @@ func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("export")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3458 := z.EncBinary() - _ = yym3458 + yym3474 := z.EncBinary() + _ = yym3474 if false { } else { r.EncodeBool(bool(x.Export)) } } - if yyr3449 || yy2arr3449 { + if yyr3465 || yy2arr3465 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3460 := z.EncBinary() - _ = yym3460 + yym3476 := z.EncBinary() + _ = yym3476 if false { } else { r.EncodeBool(bool(x.Exact)) @@ -44007,14 +44210,14 @@ func (x *ExportOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("exact")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3461 := z.EncBinary() - _ = yym3461 + yym3477 := z.EncBinary() + _ = yym3477 if false { } else { r.EncodeBool(bool(x.Exact)) } } - if yyr3449 || yy2arr3449 { + if yyr3465 || yy2arr3465 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -44027,25 +44230,25 @@ func (x *ExportOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3462 := z.DecBinary() - _ = yym3462 + yym3478 := z.DecBinary() + _ = yym3478 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3463 := r.ContainerType() - if yyct3463 == codecSelferValueTypeMap1234 { - yyl3463 := r.ReadMapStart() - if yyl3463 == 0 { + yyct3479 := r.ContainerType() + if yyct3479 == codecSelferValueTypeMap1234 { + yyl3479 := r.ReadMapStart() + if yyl3479 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3463, d) + x.codecDecodeSelfFromMap(yyl3479, d) } - } else if yyct3463 == codecSelferValueTypeArray1234 { - yyl3463 := r.ReadArrayStart() - if yyl3463 == 0 { + } else if yyct3479 == codecSelferValueTypeArray1234 { + yyl3479 := r.ReadArrayStart() + if yyl3479 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3463, d) + x.codecDecodeSelfFromArray(yyl3479, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -44057,12 +44260,12 @@ func (x *ExportOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3464Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3464Slc - var yyhl3464 bool = l >= 0 - for yyj3464 := 0; ; yyj3464++ { - if yyhl3464 { - if yyj3464 >= l { + var yys3480Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3480Slc + var yyhl3480 bool = l >= 0 + for yyj3480 := 0; ; yyj3480++ { + if yyhl3480 { + if yyj3480 >= l { break } } else { @@ -44071,10 +44274,10 @@ func (x *ExportOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3464Slc = r.DecodeBytes(yys3464Slc, true, true) - yys3464 := string(yys3464Slc) + yys3480Slc = r.DecodeBytes(yys3480Slc, true, true) + yys3480 := string(yys3480Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3464 { + switch yys3480 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -44100,9 +44303,9 @@ func (x *ExportOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Exact = bool(r.DecodeBool()) } default: - z.DecStructFieldNotFound(-1, yys3464) - } // end switch yys3464 - } // end for yyj3464 + z.DecStructFieldNotFound(-1, yys3480) + } // end switch yys3480 + } // end for yyj3480 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -44110,16 +44313,16 @@ func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3469 int - var yyb3469 bool - var yyhl3469 bool = l >= 0 - yyj3469++ - if yyhl3469 { - yyb3469 = yyj3469 > l + var yyj3485 int + var yyb3485 bool + var yyhl3485 bool = l >= 0 + yyj3485++ + if yyhl3485 { + yyb3485 = yyj3485 > l } else { - yyb3469 = r.CheckBreak() + yyb3485 = r.CheckBreak() } - if yyb3469 { + if yyb3485 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44129,13 +44332,13 @@ func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3469++ - if yyhl3469 { - yyb3469 = yyj3469 > l + yyj3485++ + if yyhl3485 { + yyb3485 = yyj3485 > l } else { - yyb3469 = r.CheckBreak() + yyb3485 = r.CheckBreak() } - if yyb3469 { + if yyb3485 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44145,13 +44348,13 @@ func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3469++ - if yyhl3469 { - yyb3469 = yyj3469 > l + yyj3485++ + if yyhl3485 { + yyb3485 = yyj3485 > l } else { - yyb3469 = r.CheckBreak() + yyb3485 = r.CheckBreak() } - if yyb3469 { + if yyb3485 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44161,13 +44364,13 @@ func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Export = bool(r.DecodeBool()) } - yyj3469++ - if yyhl3469 { - yyb3469 = yyj3469 > l + yyj3485++ + if yyhl3485 { + yyb3485 = yyj3485 > l } else { - yyb3469 = r.CheckBreak() + yyb3485 = r.CheckBreak() } - if yyb3469 { + if yyb3485 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44178,17 +44381,17 @@ func (x *ExportOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Exact = bool(r.DecodeBool()) } for { - yyj3469++ - if yyhl3469 { - yyb3469 = yyj3469 > l + yyj3485++ + if yyhl3485 { + yyb3485 = yyj3485 > l } else { - yyb3469 = r.CheckBreak() + yyb3485 = r.CheckBreak() } - if yyb3469 { + if yyb3485 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3469-1, "") + z.DecStructFieldNotFound(yyj3485-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -44200,36 +44403,36 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3474 := z.EncBinary() - _ = yym3474 + yym3490 := z.EncBinary() + _ = yym3490 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3475 := !z.EncBinary() - yy2arr3475 := z.EncBasicHandle().StructToArray - var yyq3475 [7]bool - _, _, _ = yysep3475, yyq3475, yy2arr3475 - const yyr3475 bool = false - yyq3475[0] = x.Kind != "" - yyq3475[1] = x.APIVersion != "" - var yynn3475 int - if yyr3475 || yy2arr3475 { + yysep3491 := !z.EncBinary() + yy2arr3491 := z.EncBasicHandle().StructToArray + var yyq3491 [7]bool + _, _, _ = yysep3491, yyq3491, yy2arr3491 + const yyr3491 bool = false + yyq3491[0] = x.Kind != "" + yyq3491[1] = x.APIVersion != "" + var yynn3491 int + if yyr3491 || yy2arr3491 { r.EncodeArrayStart(7) } else { - yynn3475 = 5 - for _, b := range yyq3475 { + yynn3491 = 5 + for _, b := range yyq3491 { if b { - yynn3475++ + yynn3491++ } } - r.EncodeMapStart(yynn3475) - yynn3475 = 0 + r.EncodeMapStart(yynn3491) + yynn3491 = 0 } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3475[0] { - yym3477 := z.EncBinary() - _ = yym3477 + if yyq3491[0] { + yym3493 := z.EncBinary() + _ = yym3493 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -44238,23 +44441,23 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3475[0] { + if yyq3491[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3478 := z.EncBinary() - _ = yym3478 + yym3494 := z.EncBinary() + _ = yym3494 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3475[1] { - yym3480 := z.EncBinary() - _ = yym3480 + if yyq3491[1] { + yym3496 := z.EncBinary() + _ = yym3496 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -44263,25 +44466,25 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3475[1] { + if yyq3491[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3481 := z.EncBinary() - _ = yym3481 + yym3497 := z.EncBinary() + _ = yym3497 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.LabelSelector == nil { r.EncodeNil() } else { - yym3483 := z.EncBinary() - _ = yym3483 + yym3499 := z.EncBinary() + _ = yym3499 if false { } else if z.HasExtensions() && z.EncExt(x.LabelSelector) { } else { @@ -44295,8 +44498,8 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.LabelSelector == nil { r.EncodeNil() } else { - yym3484 := z.EncBinary() - _ = yym3484 + yym3500 := z.EncBinary() + _ = yym3500 if false { } else if z.HasExtensions() && z.EncExt(x.LabelSelector) { } else { @@ -44304,13 +44507,13 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.FieldSelector == nil { r.EncodeNil() } else { - yym3486 := z.EncBinary() - _ = yym3486 + yym3502 := z.EncBinary() + _ = yym3502 if false { } else if z.HasExtensions() && z.EncExt(x.FieldSelector) { } else { @@ -44324,8 +44527,8 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.FieldSelector == nil { r.EncodeNil() } else { - yym3487 := z.EncBinary() - _ = yym3487 + yym3503 := z.EncBinary() + _ = yym3503 if false { } else if z.HasExtensions() && z.EncExt(x.FieldSelector) { } else { @@ -44333,10 +44536,10 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3489 := z.EncBinary() - _ = yym3489 + yym3505 := z.EncBinary() + _ = yym3505 if false { } else { r.EncodeBool(bool(x.Watch)) @@ -44345,17 +44548,17 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Watch")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3490 := z.EncBinary() - _ = yym3490 + yym3506 := z.EncBinary() + _ = yym3506 if false { } else { r.EncodeBool(bool(x.Watch)) } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3492 := z.EncBinary() - _ = yym3492 + yym3508 := z.EncBinary() + _ = yym3508 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion)) @@ -44364,24 +44567,24 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("ResourceVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3493 := z.EncBinary() - _ = yym3493 + yym3509 := z.EncBinary() + _ = yym3509 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion)) } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.TimeoutSeconds == nil { r.EncodeNil() } else { - yy3495 := *x.TimeoutSeconds - yym3496 := z.EncBinary() - _ = yym3496 + yy3511 := *x.TimeoutSeconds + yym3512 := z.EncBinary() + _ = yym3512 if false { } else { - r.EncodeInt(int64(yy3495)) + r.EncodeInt(int64(yy3511)) } } } else { @@ -44391,16 +44594,16 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.TimeoutSeconds == nil { r.EncodeNil() } else { - yy3497 := *x.TimeoutSeconds - yym3498 := z.EncBinary() - _ = yym3498 + yy3513 := *x.TimeoutSeconds + yym3514 := z.EncBinary() + _ = yym3514 if false { } else { - r.EncodeInt(int64(yy3497)) + r.EncodeInt(int64(yy3513)) } } } - if yyr3475 || yy2arr3475 { + if yyr3491 || yy2arr3491 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -44413,25 +44616,25 @@ func (x *ListOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3499 := z.DecBinary() - _ = yym3499 + yym3515 := z.DecBinary() + _ = yym3515 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3500 := r.ContainerType() - if yyct3500 == codecSelferValueTypeMap1234 { - yyl3500 := r.ReadMapStart() - if yyl3500 == 0 { + yyct3516 := r.ContainerType() + if yyct3516 == codecSelferValueTypeMap1234 { + yyl3516 := r.ReadMapStart() + if yyl3516 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3500, d) + x.codecDecodeSelfFromMap(yyl3516, d) } - } else if yyct3500 == codecSelferValueTypeArray1234 { - yyl3500 := r.ReadArrayStart() - if yyl3500 == 0 { + } else if yyct3516 == codecSelferValueTypeArray1234 { + yyl3516 := r.ReadArrayStart() + if yyl3516 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3500, d) + x.codecDecodeSelfFromArray(yyl3516, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -44443,12 +44646,12 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3501Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3501Slc - var yyhl3501 bool = l >= 0 - for yyj3501 := 0; ; yyj3501++ { - if yyhl3501 { - if yyj3501 >= l { + var yys3517Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3517Slc + var yyhl3517 bool = l >= 0 + for yyj3517 := 0; ; yyj3517++ { + if yyhl3517 { + if yyj3517 >= l { break } } else { @@ -44457,10 +44660,10 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3501Slc = r.DecodeBytes(yys3501Slc, true, true) - yys3501 := string(yys3501Slc) + yys3517Slc = r.DecodeBytes(yys3517Slc, true, true) + yys3517 := string(yys3517Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3501 { + switch yys3517 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -44477,26 +44680,26 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LabelSelector = nil } else { - yyv3504 := &x.LabelSelector - yym3505 := z.DecBinary() - _ = yym3505 + yyv3520 := &x.LabelSelector + yym3521 := z.DecBinary() + _ = yym3521 if false { - } else if z.HasExtensions() && z.DecExt(yyv3504) { + } else if z.HasExtensions() && z.DecExt(yyv3520) { } else { - z.DecFallback(yyv3504, true) + z.DecFallback(yyv3520, true) } } case "FieldSelector": if r.TryDecodeAsNil() { x.FieldSelector = nil } else { - yyv3506 := &x.FieldSelector - yym3507 := z.DecBinary() - _ = yym3507 + yyv3522 := &x.FieldSelector + yym3523 := z.DecBinary() + _ = yym3523 if false { - } else if z.HasExtensions() && z.DecExt(yyv3506) { + } else if z.HasExtensions() && z.DecExt(yyv3522) { } else { - z.DecFallback(yyv3506, true) + z.DecFallback(yyv3522, true) } } case "Watch": @@ -44520,17 +44723,17 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.TimeoutSeconds == nil { x.TimeoutSeconds = new(int64) } - yym3511 := z.DecBinary() - _ = yym3511 + yym3527 := z.DecBinary() + _ = yym3527 if false { } else { *((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64)) } } default: - z.DecStructFieldNotFound(-1, yys3501) - } // end switch yys3501 - } // end for yyj3501 + z.DecStructFieldNotFound(-1, yys3517) + } // end switch yys3517 + } // end for yyj3517 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -44538,16 +44741,16 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3512 int - var yyb3512 bool - var yyhl3512 bool = l >= 0 - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + var yyj3528 int + var yyb3528 bool + var yyhl3528 bool = l >= 0 + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44557,13 +44760,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44573,13 +44776,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44587,22 +44790,22 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LabelSelector = nil } else { - yyv3515 := &x.LabelSelector - yym3516 := z.DecBinary() - _ = yym3516 + yyv3531 := &x.LabelSelector + yym3532 := z.DecBinary() + _ = yym3532 if false { - } else if z.HasExtensions() && z.DecExt(yyv3515) { + } else if z.HasExtensions() && z.DecExt(yyv3531) { } else { - z.DecFallback(yyv3515, true) + z.DecFallback(yyv3531, true) } } - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44610,22 +44813,22 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.FieldSelector = nil } else { - yyv3517 := &x.FieldSelector - yym3518 := z.DecBinary() - _ = yym3518 + yyv3533 := &x.FieldSelector + yym3534 := z.DecBinary() + _ = yym3534 if false { - } else if z.HasExtensions() && z.DecExt(yyv3517) { + } else if z.HasExtensions() && z.DecExt(yyv3533) { } else { - z.DecFallback(yyv3517, true) + z.DecFallback(yyv3533, true) } } - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44635,13 +44838,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Watch = bool(r.DecodeBool()) } - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44651,13 +44854,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.ResourceVersion = string(r.DecodeString()) } - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -44670,25 +44873,25 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.TimeoutSeconds == nil { x.TimeoutSeconds = new(int64) } - yym3522 := z.DecBinary() - _ = yym3522 + yym3538 := z.DecBinary() + _ = yym3538 if false { } else { *((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64)) } } for { - yyj3512++ - if yyhl3512 { - yyb3512 = yyj3512 > l + yyj3528++ + if yyhl3528 { + yyb3528 = yyj3528 > l } else { - yyb3512 = r.CheckBreak() + yyb3528 = r.CheckBreak() } - if yyb3512 { + if yyb3528 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3512-1, "") + z.DecStructFieldNotFound(yyj3528-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -44700,36 +44903,36 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3523 := z.EncBinary() - _ = yym3523 + yym3539 := z.EncBinary() + _ = yym3539 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3524 := !z.EncBinary() - yy2arr3524 := z.EncBasicHandle().StructToArray - var yyq3524 [10]bool - _, _, _ = yysep3524, yyq3524, yy2arr3524 - const yyr3524 bool = false - yyq3524[0] = x.Kind != "" - yyq3524[1] = x.APIVersion != "" - var yynn3524 int - if yyr3524 || yy2arr3524 { + yysep3540 := !z.EncBinary() + yy2arr3540 := z.EncBasicHandle().StructToArray + var yyq3540 [10]bool + _, _, _ = yysep3540, yyq3540, yy2arr3540 + const yyr3540 bool = false + yyq3540[0] = x.Kind != "" + yyq3540[1] = x.APIVersion != "" + var yynn3540 int + if yyr3540 || yy2arr3540 { r.EncodeArrayStart(10) } else { - yynn3524 = 8 - for _, b := range yyq3524 { + yynn3540 = 8 + for _, b := range yyq3540 { if b { - yynn3524++ + yynn3540++ } } - r.EncodeMapStart(yynn3524) - yynn3524 = 0 + r.EncodeMapStart(yynn3540) + yynn3540 = 0 } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3524[0] { - yym3526 := z.EncBinary() - _ = yym3526 + if yyq3540[0] { + yym3542 := z.EncBinary() + _ = yym3542 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -44738,23 +44941,23 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3524[0] { + if yyq3540[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3527 := z.EncBinary() - _ = yym3527 + yym3543 := z.EncBinary() + _ = yym3543 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3524[1] { - yym3529 := z.EncBinary() - _ = yym3529 + if yyq3540[1] { + yym3545 := z.EncBinary() + _ = yym3545 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -44763,22 +44966,22 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3524[1] { + if yyq3540[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3530 := z.EncBinary() - _ = yym3530 + yym3546 := z.EncBinary() + _ = yym3546 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3532 := z.EncBinary() - _ = yym3532 + yym3548 := z.EncBinary() + _ = yym3548 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Container)) @@ -44787,17 +44990,17 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Container")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3533 := z.EncBinary() - _ = yym3533 + yym3549 := z.EncBinary() + _ = yym3549 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Container)) } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3535 := z.EncBinary() - _ = yym3535 + yym3551 := z.EncBinary() + _ = yym3551 if false { } else { r.EncodeBool(bool(x.Follow)) @@ -44806,17 +45009,17 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Follow")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3536 := z.EncBinary() - _ = yym3536 + yym3552 := z.EncBinary() + _ = yym3552 if false { } else { r.EncodeBool(bool(x.Follow)) } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3538 := z.EncBinary() - _ = yym3538 + yym3554 := z.EncBinary() + _ = yym3554 if false { } else { r.EncodeBool(bool(x.Previous)) @@ -44825,24 +45028,24 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Previous")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3539 := z.EncBinary() - _ = yym3539 + yym3555 := z.EncBinary() + _ = yym3555 if false { } else { r.EncodeBool(bool(x.Previous)) } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.SinceSeconds == nil { r.EncodeNil() } else { - yy3541 := *x.SinceSeconds - yym3542 := z.EncBinary() - _ = yym3542 + yy3557 := *x.SinceSeconds + yym3558 := z.EncBinary() + _ = yym3558 if false { } else { - r.EncodeInt(int64(yy3541)) + r.EncodeInt(int64(yy3557)) } } } else { @@ -44852,27 +45055,27 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.SinceSeconds == nil { r.EncodeNil() } else { - yy3543 := *x.SinceSeconds - yym3544 := z.EncBinary() - _ = yym3544 + yy3559 := *x.SinceSeconds + yym3560 := z.EncBinary() + _ = yym3560 if false { } else { - r.EncodeInt(int64(yy3543)) + r.EncodeInt(int64(yy3559)) } } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.SinceTime == nil { r.EncodeNil() } else { - yym3546 := z.EncBinary() - _ = yym3546 + yym3562 := z.EncBinary() + _ = yym3562 if false { } else if z.HasExtensions() && z.EncExt(x.SinceTime) { - } else if yym3546 { + } else if yym3562 { z.EncBinaryMarshal(x.SinceTime) - } else if !yym3546 && z.IsJSONHandle() { + } else if !yym3562 && z.IsJSONHandle() { z.EncJSONMarshal(x.SinceTime) } else { z.EncFallback(x.SinceTime) @@ -44885,23 +45088,23 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.SinceTime == nil { r.EncodeNil() } else { - yym3547 := z.EncBinary() - _ = yym3547 + yym3563 := z.EncBinary() + _ = yym3563 if false { } else if z.HasExtensions() && z.EncExt(x.SinceTime) { - } else if yym3547 { + } else if yym3563 { z.EncBinaryMarshal(x.SinceTime) - } else if !yym3547 && z.IsJSONHandle() { + } else if !yym3563 && z.IsJSONHandle() { z.EncJSONMarshal(x.SinceTime) } else { z.EncFallback(x.SinceTime) } } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3549 := z.EncBinary() - _ = yym3549 + yym3565 := z.EncBinary() + _ = yym3565 if false { } else { r.EncodeBool(bool(x.Timestamps)) @@ -44910,24 +45113,24 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Timestamps")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3550 := z.EncBinary() - _ = yym3550 + yym3566 := z.EncBinary() + _ = yym3566 if false { } else { r.EncodeBool(bool(x.Timestamps)) } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.TailLines == nil { r.EncodeNil() } else { - yy3552 := *x.TailLines - yym3553 := z.EncBinary() - _ = yym3553 + yy3568 := *x.TailLines + yym3569 := z.EncBinary() + _ = yym3569 if false { } else { - r.EncodeInt(int64(yy3552)) + r.EncodeInt(int64(yy3568)) } } } else { @@ -44937,26 +45140,26 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.TailLines == nil { r.EncodeNil() } else { - yy3554 := *x.TailLines - yym3555 := z.EncBinary() - _ = yym3555 + yy3570 := *x.TailLines + yym3571 := z.EncBinary() + _ = yym3571 if false { } else { - r.EncodeInt(int64(yy3554)) + r.EncodeInt(int64(yy3570)) } } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.LimitBytes == nil { r.EncodeNil() } else { - yy3557 := *x.LimitBytes - yym3558 := z.EncBinary() - _ = yym3558 + yy3573 := *x.LimitBytes + yym3574 := z.EncBinary() + _ = yym3574 if false { } else { - r.EncodeInt(int64(yy3557)) + r.EncodeInt(int64(yy3573)) } } } else { @@ -44966,16 +45169,16 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.LimitBytes == nil { r.EncodeNil() } else { - yy3559 := *x.LimitBytes - yym3560 := z.EncBinary() - _ = yym3560 + yy3575 := *x.LimitBytes + yym3576 := z.EncBinary() + _ = yym3576 if false { } else { - r.EncodeInt(int64(yy3559)) + r.EncodeInt(int64(yy3575)) } } } - if yyr3524 || yy2arr3524 { + if yyr3540 || yy2arr3540 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -44988,25 +45191,25 @@ func (x *PodLogOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3561 := z.DecBinary() - _ = yym3561 + yym3577 := z.DecBinary() + _ = yym3577 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3562 := r.ContainerType() - if yyct3562 == codecSelferValueTypeMap1234 { - yyl3562 := r.ReadMapStart() - if yyl3562 == 0 { + yyct3578 := r.ContainerType() + if yyct3578 == codecSelferValueTypeMap1234 { + yyl3578 := r.ReadMapStart() + if yyl3578 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3562, d) + x.codecDecodeSelfFromMap(yyl3578, d) } - } else if yyct3562 == codecSelferValueTypeArray1234 { - yyl3562 := r.ReadArrayStart() - if yyl3562 == 0 { + } else if yyct3578 == codecSelferValueTypeArray1234 { + yyl3578 := r.ReadArrayStart() + if yyl3578 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3562, d) + x.codecDecodeSelfFromArray(yyl3578, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -45018,12 +45221,12 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3563Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3563Slc - var yyhl3563 bool = l >= 0 - for yyj3563 := 0; ; yyj3563++ { - if yyhl3563 { - if yyj3563 >= l { + var yys3579Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3579Slc + var yyhl3579 bool = l >= 0 + for yyj3579 := 0; ; yyj3579++ { + if yyhl3579 { + if yyj3579 >= l { break } } else { @@ -45032,10 +45235,10 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3563Slc = r.DecodeBytes(yys3563Slc, true, true) - yys3563 := string(yys3563Slc) + yys3579Slc = r.DecodeBytes(yys3579Slc, true, true) + yys3579 := string(yys3579Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3563 { + switch yys3579 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -45075,8 +45278,8 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.SinceSeconds == nil { x.SinceSeconds = new(int64) } - yym3570 := z.DecBinary() - _ = yym3570 + yym3586 := z.DecBinary() + _ = yym3586 if false { } else { *((*int64)(x.SinceSeconds)) = int64(r.DecodeInt(64)) @@ -45091,13 +45294,13 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.SinceTime == nil { x.SinceTime = new(pkg2_unversioned.Time) } - yym3572 := z.DecBinary() - _ = yym3572 + yym3588 := z.DecBinary() + _ = yym3588 if false { } else if z.HasExtensions() && z.DecExt(x.SinceTime) { - } else if yym3572 { + } else if yym3588 { z.DecBinaryUnmarshal(x.SinceTime) - } else if !yym3572 && z.IsJSONHandle() { + } else if !yym3588 && z.IsJSONHandle() { z.DecJSONUnmarshal(x.SinceTime) } else { z.DecFallback(x.SinceTime, false) @@ -45118,8 +45321,8 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.TailLines == nil { x.TailLines = new(int64) } - yym3575 := z.DecBinary() - _ = yym3575 + yym3591 := z.DecBinary() + _ = yym3591 if false { } else { *((*int64)(x.TailLines)) = int64(r.DecodeInt(64)) @@ -45134,17 +45337,17 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.LimitBytes == nil { x.LimitBytes = new(int64) } - yym3577 := z.DecBinary() - _ = yym3577 + yym3593 := z.DecBinary() + _ = yym3593 if false { } else { *((*int64)(x.LimitBytes)) = int64(r.DecodeInt(64)) } } default: - z.DecStructFieldNotFound(-1, yys3563) - } // end switch yys3563 - } // end for yyj3563 + z.DecStructFieldNotFound(-1, yys3579) + } // end switch yys3579 + } // end for yyj3579 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -45152,16 +45355,16 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3578 int - var yyb3578 bool - var yyhl3578 bool = l >= 0 - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + var yyj3594 int + var yyb3594 bool + var yyhl3594 bool = l >= 0 + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45171,13 +45374,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45187,13 +45390,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45203,13 +45406,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Container = string(r.DecodeString()) } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45219,13 +45422,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Follow = bool(r.DecodeBool()) } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45235,13 +45438,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Previous = bool(r.DecodeBool()) } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45254,20 +45457,20 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.SinceSeconds == nil { x.SinceSeconds = new(int64) } - yym3585 := z.DecBinary() - _ = yym3585 + yym3601 := z.DecBinary() + _ = yym3601 if false { } else { *((*int64)(x.SinceSeconds)) = int64(r.DecodeInt(64)) } } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45280,25 +45483,25 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.SinceTime == nil { x.SinceTime = new(pkg2_unversioned.Time) } - yym3587 := z.DecBinary() - _ = yym3587 + yym3603 := z.DecBinary() + _ = yym3603 if false { } else if z.HasExtensions() && z.DecExt(x.SinceTime) { - } else if yym3587 { + } else if yym3603 { z.DecBinaryUnmarshal(x.SinceTime) - } else if !yym3587 && z.IsJSONHandle() { + } else if !yym3603 && z.IsJSONHandle() { z.DecJSONUnmarshal(x.SinceTime) } else { z.DecFallback(x.SinceTime, false) } } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45308,13 +45511,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Timestamps = bool(r.DecodeBool()) } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45327,20 +45530,20 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.TailLines == nil { x.TailLines = new(int64) } - yym3590 := z.DecBinary() - _ = yym3590 + yym3606 := z.DecBinary() + _ = yym3606 if false { } else { *((*int64)(x.TailLines)) = int64(r.DecodeInt(64)) } } - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45353,25 +45556,25 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.LimitBytes == nil { x.LimitBytes = new(int64) } - yym3592 := z.DecBinary() - _ = yym3592 + yym3608 := z.DecBinary() + _ = yym3608 if false { } else { *((*int64)(x.LimitBytes)) = int64(r.DecodeInt(64)) } } for { - yyj3578++ - if yyhl3578 { - yyb3578 = yyj3578 > l + yyj3594++ + if yyhl3594 { + yyb3594 = yyj3594 > l } else { - yyb3578 = r.CheckBreak() + yyb3594 = r.CheckBreak() } - if yyb3578 { + if yyb3594 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3578-1, "") + z.DecStructFieldNotFound(yyj3594-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -45383,191 +45586,191 @@ func (x *PodAttachOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3593 := z.EncBinary() - _ = yym3593 + yym3609 := z.EncBinary() + _ = yym3609 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3594 := !z.EncBinary() - yy2arr3594 := z.EncBasicHandle().StructToArray - var yyq3594 [7]bool - _, _, _ = yysep3594, yyq3594, yy2arr3594 - const yyr3594 bool = false - yyq3594[0] = x.Kind != "" - yyq3594[1] = x.APIVersion != "" - yyq3594[2] = x.Stdin != false - yyq3594[3] = x.Stdout != false - yyq3594[4] = x.Stderr != false - yyq3594[5] = x.TTY != false - yyq3594[6] = x.Container != "" - var yynn3594 int - if yyr3594 || yy2arr3594 { + yysep3610 := !z.EncBinary() + yy2arr3610 := z.EncBasicHandle().StructToArray + var yyq3610 [7]bool + _, _, _ = yysep3610, yyq3610, yy2arr3610 + const yyr3610 bool = false + yyq3610[0] = x.Kind != "" + yyq3610[1] = x.APIVersion != "" + yyq3610[2] = x.Stdin != false + yyq3610[3] = x.Stdout != false + yyq3610[4] = x.Stderr != false + yyq3610[5] = x.TTY != false + yyq3610[6] = x.Container != "" + var yynn3610 int + if yyr3610 || yy2arr3610 { r.EncodeArrayStart(7) } else { - yynn3594 = 0 - for _, b := range yyq3594 { + yynn3610 = 0 + for _, b := range yyq3610 { if b { - yynn3594++ + yynn3610++ } } - r.EncodeMapStart(yynn3594) - yynn3594 = 0 + r.EncodeMapStart(yynn3610) + yynn3610 = 0 } - if yyr3594 || yy2arr3594 { + if yyr3610 || yy2arr3610 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[0] { - yym3596 := z.EncBinary() - _ = yym3596 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3594[0] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("kind")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3597 := z.EncBinary() - _ = yym3597 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) - } - } - } - if yyr3594 || yy2arr3594 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[1] { - yym3599 := z.EncBinary() - _ = yym3599 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3594[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3600 := z.EncBinary() - _ = yym3600 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) - } - } - } - if yyr3594 || yy2arr3594 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[2] { - yym3602 := z.EncBinary() - _ = yym3602 - if false { - } else { - r.EncodeBool(bool(x.Stdin)) - } - } else { - r.EncodeBool(false) - } - } else { - if yyq3594[2] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("stdin")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3603 := z.EncBinary() - _ = yym3603 - if false { - } else { - r.EncodeBool(bool(x.Stdin)) - } - } - } - if yyr3594 || yy2arr3594 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[3] { - yym3605 := z.EncBinary() - _ = yym3605 - if false { - } else { - r.EncodeBool(bool(x.Stdout)) - } - } else { - r.EncodeBool(false) - } - } else { - if yyq3594[3] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("stdout")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3606 := z.EncBinary() - _ = yym3606 - if false { - } else { - r.EncodeBool(bool(x.Stdout)) - } - } - } - if yyr3594 || yy2arr3594 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[4] { - yym3608 := z.EncBinary() - _ = yym3608 - if false { - } else { - r.EncodeBool(bool(x.Stderr)) - } - } else { - r.EncodeBool(false) - } - } else { - if yyq3594[4] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("stderr")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3609 := z.EncBinary() - _ = yym3609 - if false { - } else { - r.EncodeBool(bool(x.Stderr)) - } - } - } - if yyr3594 || yy2arr3594 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[5] { - yym3611 := z.EncBinary() - _ = yym3611 - if false { - } else { - r.EncodeBool(bool(x.TTY)) - } - } else { - r.EncodeBool(false) - } - } else { - if yyq3594[5] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("tty")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) + if yyq3610[0] { yym3612 := z.EncBinary() _ = yym3612 if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3610[0] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kind")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3613 := z.EncBinary() + _ = yym3613 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } + } + if yyr3610 || yy2arr3610 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3610[1] { + yym3615 := z.EncBinary() + _ = yym3615 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3610[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3616 := z.EncBinary() + _ = yym3616 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } + } + if yyr3610 || yy2arr3610 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3610[2] { + yym3618 := z.EncBinary() + _ = yym3618 + if false { + } else { + r.EncodeBool(bool(x.Stdin)) + } + } else { + r.EncodeBool(false) + } + } else { + if yyq3610[2] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("stdin")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3619 := z.EncBinary() + _ = yym3619 + if false { + } else { + r.EncodeBool(bool(x.Stdin)) + } + } + } + if yyr3610 || yy2arr3610 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3610[3] { + yym3621 := z.EncBinary() + _ = yym3621 + if false { + } else { + r.EncodeBool(bool(x.Stdout)) + } + } else { + r.EncodeBool(false) + } + } else { + if yyq3610[3] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("stdout")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3622 := z.EncBinary() + _ = yym3622 + if false { + } else { + r.EncodeBool(bool(x.Stdout)) + } + } + } + if yyr3610 || yy2arr3610 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3610[4] { + yym3624 := z.EncBinary() + _ = yym3624 + if false { + } else { + r.EncodeBool(bool(x.Stderr)) + } + } else { + r.EncodeBool(false) + } + } else { + if yyq3610[4] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("stderr")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3625 := z.EncBinary() + _ = yym3625 + if false { + } else { + r.EncodeBool(bool(x.Stderr)) + } + } + } + if yyr3610 || yy2arr3610 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3610[5] { + yym3627 := z.EncBinary() + _ = yym3627 + if false { + } else { + r.EncodeBool(bool(x.TTY)) + } + } else { + r.EncodeBool(false) + } + } else { + if yyq3610[5] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("tty")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3628 := z.EncBinary() + _ = yym3628 + if false { } else { r.EncodeBool(bool(x.TTY)) } } } - if yyr3594 || yy2arr3594 { + if yyr3610 || yy2arr3610 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3594[6] { - yym3614 := z.EncBinary() - _ = yym3614 + if yyq3610[6] { + yym3630 := z.EncBinary() + _ = yym3630 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Container)) @@ -45576,19 +45779,19 @@ func (x *PodAttachOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3594[6] { + if yyq3610[6] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("container")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3615 := z.EncBinary() - _ = yym3615 + yym3631 := z.EncBinary() + _ = yym3631 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Container)) } } } - if yyr3594 || yy2arr3594 { + if yyr3610 || yy2arr3610 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -45601,25 +45804,25 @@ func (x *PodAttachOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3616 := z.DecBinary() - _ = yym3616 + yym3632 := z.DecBinary() + _ = yym3632 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3617 := r.ContainerType() - if yyct3617 == codecSelferValueTypeMap1234 { - yyl3617 := r.ReadMapStart() - if yyl3617 == 0 { + yyct3633 := r.ContainerType() + if yyct3633 == codecSelferValueTypeMap1234 { + yyl3633 := r.ReadMapStart() + if yyl3633 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3617, d) + x.codecDecodeSelfFromMap(yyl3633, d) } - } else if yyct3617 == codecSelferValueTypeArray1234 { - yyl3617 := r.ReadArrayStart() - if yyl3617 == 0 { + } else if yyct3633 == codecSelferValueTypeArray1234 { + yyl3633 := r.ReadArrayStart() + if yyl3633 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3617, d) + x.codecDecodeSelfFromArray(yyl3633, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -45631,12 +45834,12 @@ func (x *PodAttachOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3618Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3618Slc - var yyhl3618 bool = l >= 0 - for yyj3618 := 0; ; yyj3618++ { - if yyhl3618 { - if yyj3618 >= l { + var yys3634Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3634Slc + var yyhl3634 bool = l >= 0 + for yyj3634 := 0; ; yyj3634++ { + if yyhl3634 { + if yyj3634 >= l { break } } else { @@ -45645,10 +45848,10 @@ func (x *PodAttachOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3618Slc = r.DecodeBytes(yys3618Slc, true, true) - yys3618 := string(yys3618Slc) + yys3634Slc = r.DecodeBytes(yys3634Slc, true, true) + yys3634 := string(yys3634Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3618 { + switch yys3634 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -45692,9 +45895,9 @@ func (x *PodAttachOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Container = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3618) - } // end switch yys3618 - } // end for yyj3618 + z.DecStructFieldNotFound(-1, yys3634) + } // end switch yys3634 + } // end for yyj3634 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -45702,16 +45905,16 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3626 int - var yyb3626 bool - var yyhl3626 bool = l >= 0 - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + var yyj3642 int + var yyb3642 bool + var yyhl3642 bool = l >= 0 + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45721,13 +45924,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45737,13 +45940,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45753,13 +45956,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Stdin = bool(r.DecodeBool()) } - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45769,13 +45972,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Stdout = bool(r.DecodeBool()) } - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45785,13 +45988,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Stderr = bool(r.DecodeBool()) } - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45801,13 +46004,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.TTY = bool(r.DecodeBool()) } - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -45818,17 +46021,17 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) x.Container = string(r.DecodeString()) } for { - yyj3626++ - if yyhl3626 { - yyb3626 = yyj3626 > l + yyj3642++ + if yyhl3642 { + yyb3642 = yyj3642 > l } else { - yyb3626 = r.CheckBreak() + yyb3642 = r.CheckBreak() } - if yyb3626 { + if yyb3642 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3626-1, "") + z.DecStructFieldNotFound(yyj3642-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -45840,36 +46043,36 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3634 := z.EncBinary() - _ = yym3634 + yym3650 := z.EncBinary() + _ = yym3650 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3635 := !z.EncBinary() - yy2arr3635 := z.EncBasicHandle().StructToArray - var yyq3635 [8]bool - _, _, _ = yysep3635, yyq3635, yy2arr3635 - const yyr3635 bool = false - yyq3635[0] = x.Kind != "" - yyq3635[1] = x.APIVersion != "" - var yynn3635 int - if yyr3635 || yy2arr3635 { + yysep3651 := !z.EncBinary() + yy2arr3651 := z.EncBasicHandle().StructToArray + var yyq3651 [8]bool + _, _, _ = yysep3651, yyq3651, yy2arr3651 + const yyr3651 bool = false + yyq3651[0] = x.Kind != "" + yyq3651[1] = x.APIVersion != "" + var yynn3651 int + if yyr3651 || yy2arr3651 { r.EncodeArrayStart(8) } else { - yynn3635 = 6 - for _, b := range yyq3635 { + yynn3651 = 6 + for _, b := range yyq3651 { if b { - yynn3635++ + yynn3651++ } } - r.EncodeMapStart(yynn3635) - yynn3635 = 0 + r.EncodeMapStart(yynn3651) + yynn3651 = 0 } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3635[0] { - yym3637 := z.EncBinary() - _ = yym3637 + if yyq3651[0] { + yym3653 := z.EncBinary() + _ = yym3653 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -45878,23 +46081,23 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3635[0] { + if yyq3651[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3638 := z.EncBinary() - _ = yym3638 + yym3654 := z.EncBinary() + _ = yym3654 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3635[1] { - yym3640 := z.EncBinary() - _ = yym3640 + if yyq3651[1] { + yym3656 := z.EncBinary() + _ = yym3656 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -45903,22 +46106,22 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3635[1] { + if yyq3651[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3641 := z.EncBinary() - _ = yym3641 + yym3657 := z.EncBinary() + _ = yym3657 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3643 := z.EncBinary() - _ = yym3643 + yym3659 := z.EncBinary() + _ = yym3659 if false { } else { r.EncodeBool(bool(x.Stdin)) @@ -45927,17 +46130,17 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Stdin")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3644 := z.EncBinary() - _ = yym3644 + yym3660 := z.EncBinary() + _ = yym3660 if false { } else { r.EncodeBool(bool(x.Stdin)) } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3646 := z.EncBinary() - _ = yym3646 + yym3662 := z.EncBinary() + _ = yym3662 if false { } else { r.EncodeBool(bool(x.Stdout)) @@ -45946,17 +46149,17 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Stdout")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3647 := z.EncBinary() - _ = yym3647 + yym3663 := z.EncBinary() + _ = yym3663 if false { } else { r.EncodeBool(bool(x.Stdout)) } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3649 := z.EncBinary() - _ = yym3649 + yym3665 := z.EncBinary() + _ = yym3665 if false { } else { r.EncodeBool(bool(x.Stderr)) @@ -45965,17 +46168,17 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Stderr")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3650 := z.EncBinary() - _ = yym3650 + yym3666 := z.EncBinary() + _ = yym3666 if false { } else { r.EncodeBool(bool(x.Stderr)) } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3652 := z.EncBinary() - _ = yym3652 + yym3668 := z.EncBinary() + _ = yym3668 if false { } else { r.EncodeBool(bool(x.TTY)) @@ -45984,17 +46187,17 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("TTY")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3653 := z.EncBinary() - _ = yym3653 + yym3669 := z.EncBinary() + _ = yym3669 if false { } else { r.EncodeBool(bool(x.TTY)) } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3655 := z.EncBinary() - _ = yym3655 + yym3671 := z.EncBinary() + _ = yym3671 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Container)) @@ -46003,20 +46206,20 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Container")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3656 := z.EncBinary() - _ = yym3656 + yym3672 := z.EncBinary() + _ = yym3672 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Container)) } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Command == nil { r.EncodeNil() } else { - yym3658 := z.EncBinary() - _ = yym3658 + yym3674 := z.EncBinary() + _ = yym3674 if false { } else { z.F.EncSliceStringV(x.Command, false, e) @@ -46029,15 +46232,15 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x.Command == nil { r.EncodeNil() } else { - yym3659 := z.EncBinary() - _ = yym3659 + yym3675 := z.EncBinary() + _ = yym3675 if false { } else { z.F.EncSliceStringV(x.Command, false, e) } } } - if yyr3635 || yy2arr3635 { + if yyr3651 || yy2arr3651 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -46050,25 +46253,25 @@ func (x *PodExecOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3660 := z.DecBinary() - _ = yym3660 + yym3676 := z.DecBinary() + _ = yym3676 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3661 := r.ContainerType() - if yyct3661 == codecSelferValueTypeMap1234 { - yyl3661 := r.ReadMapStart() - if yyl3661 == 0 { + yyct3677 := r.ContainerType() + if yyct3677 == codecSelferValueTypeMap1234 { + yyl3677 := r.ReadMapStart() + if yyl3677 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3661, d) + x.codecDecodeSelfFromMap(yyl3677, d) } - } else if yyct3661 == codecSelferValueTypeArray1234 { - yyl3661 := r.ReadArrayStart() - if yyl3661 == 0 { + } else if yyct3677 == codecSelferValueTypeArray1234 { + yyl3677 := r.ReadArrayStart() + if yyl3677 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3661, d) + x.codecDecodeSelfFromArray(yyl3677, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -46080,12 +46283,12 @@ func (x *PodExecOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3662Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3662Slc - var yyhl3662 bool = l >= 0 - for yyj3662 := 0; ; yyj3662++ { - if yyhl3662 { - if yyj3662 >= l { + var yys3678Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3678Slc + var yyhl3678 bool = l >= 0 + for yyj3678 := 0; ; yyj3678++ { + if yyhl3678 { + if yyj3678 >= l { break } } else { @@ -46094,10 +46297,10 @@ func (x *PodExecOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3662Slc = r.DecodeBytes(yys3662Slc, true, true) - yys3662 := string(yys3662Slc) + yys3678Slc = r.DecodeBytes(yys3678Slc, true, true) + yys3678 := string(yys3678Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3662 { + switch yys3678 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -46144,18 +46347,18 @@ func (x *PodExecOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Command = nil } else { - yyv3670 := &x.Command - yym3671 := z.DecBinary() - _ = yym3671 + yyv3686 := &x.Command + yym3687 := z.DecBinary() + _ = yym3687 if false { } else { - z.F.DecSliceStringX(yyv3670, false, d) + z.F.DecSliceStringX(yyv3686, false, d) } } default: - z.DecStructFieldNotFound(-1, yys3662) - } // end switch yys3662 - } // end for yyj3662 + z.DecStructFieldNotFound(-1, yys3678) + } // end switch yys3678 + } // end for yyj3678 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -46163,16 +46366,16 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3672 int - var yyb3672 bool - var yyhl3672 bool = l >= 0 - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + var yyj3688 int + var yyb3688 bool + var yyhl3688 bool = l >= 0 + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46182,13 +46385,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46198,13 +46401,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46214,13 +46417,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Stdin = bool(r.DecodeBool()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46230,13 +46433,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Stdout = bool(r.DecodeBool()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46246,13 +46449,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Stderr = bool(r.DecodeBool()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46262,13 +46465,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.TTY = bool(r.DecodeBool()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46278,13 +46481,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Container = string(r.DecodeString()) } - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46292,26 +46495,26 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Command = nil } else { - yyv3680 := &x.Command - yym3681 := z.DecBinary() - _ = yym3681 + yyv3696 := &x.Command + yym3697 := z.DecBinary() + _ = yym3697 if false { } else { - z.F.DecSliceStringX(yyv3680, false, d) + z.F.DecSliceStringX(yyv3696, false, d) } } for { - yyj3672++ - if yyhl3672 { - yyb3672 = yyj3672 > l + yyj3688++ + if yyhl3688 { + yyb3688 = yyj3688 > l } else { - yyb3672 = r.CheckBreak() + yyb3688 = r.CheckBreak() } - if yyb3672 { + if yyb3688 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3672-1, "") + z.DecStructFieldNotFound(yyj3688-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -46323,36 +46526,36 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3682 := z.EncBinary() - _ = yym3682 + yym3698 := z.EncBinary() + _ = yym3698 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3683 := !z.EncBinary() - yy2arr3683 := z.EncBasicHandle().StructToArray - var yyq3683 [3]bool - _, _, _ = yysep3683, yyq3683, yy2arr3683 - const yyr3683 bool = false - yyq3683[0] = x.Kind != "" - yyq3683[1] = x.APIVersion != "" - var yynn3683 int - if yyr3683 || yy2arr3683 { + yysep3699 := !z.EncBinary() + yy2arr3699 := z.EncBasicHandle().StructToArray + var yyq3699 [3]bool + _, _, _ = yysep3699, yyq3699, yy2arr3699 + const yyr3699 bool = false + yyq3699[0] = x.Kind != "" + yyq3699[1] = x.APIVersion != "" + var yynn3699 int + if yyr3699 || yy2arr3699 { r.EncodeArrayStart(3) } else { - yynn3683 = 1 - for _, b := range yyq3683 { + yynn3699 = 1 + for _, b := range yyq3699 { if b { - yynn3683++ + yynn3699++ } } - r.EncodeMapStart(yynn3683) - yynn3683 = 0 + r.EncodeMapStart(yynn3699) + yynn3699 = 0 } - if yyr3683 || yy2arr3683 { + if yyr3699 || yy2arr3699 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3683[0] { - yym3685 := z.EncBinary() - _ = yym3685 + if yyq3699[0] { + yym3701 := z.EncBinary() + _ = yym3701 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -46361,23 +46564,23 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3683[0] { + if yyq3699[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3686 := z.EncBinary() - _ = yym3686 + yym3702 := z.EncBinary() + _ = yym3702 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3683 || yy2arr3683 { + if yyr3699 || yy2arr3699 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3683[1] { - yym3688 := z.EncBinary() - _ = yym3688 + if yyq3699[1] { + yym3704 := z.EncBinary() + _ = yym3704 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -46386,22 +46589,22 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3683[1] { + if yyq3699[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3689 := z.EncBinary() - _ = yym3689 + yym3705 := z.EncBinary() + _ = yym3705 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3683 || yy2arr3683 { + if yyr3699 || yy2arr3699 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3691 := z.EncBinary() - _ = yym3691 + yym3707 := z.EncBinary() + _ = yym3707 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Path)) @@ -46410,14 +46613,14 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Path")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3692 := z.EncBinary() - _ = yym3692 + yym3708 := z.EncBinary() + _ = yym3708 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Path)) } } - if yyr3683 || yy2arr3683 { + if yyr3699 || yy2arr3699 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -46430,25 +46633,25 @@ func (x *PodProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3693 := z.DecBinary() - _ = yym3693 + yym3709 := z.DecBinary() + _ = yym3709 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3694 := r.ContainerType() - if yyct3694 == codecSelferValueTypeMap1234 { - yyl3694 := r.ReadMapStart() - if yyl3694 == 0 { + yyct3710 := r.ContainerType() + if yyct3710 == codecSelferValueTypeMap1234 { + yyl3710 := r.ReadMapStart() + if yyl3710 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3694, d) + x.codecDecodeSelfFromMap(yyl3710, d) } - } else if yyct3694 == codecSelferValueTypeArray1234 { - yyl3694 := r.ReadArrayStart() - if yyl3694 == 0 { + } else if yyct3710 == codecSelferValueTypeArray1234 { + yyl3710 := r.ReadArrayStart() + if yyl3710 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3694, d) + x.codecDecodeSelfFromArray(yyl3710, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -46460,12 +46663,12 @@ func (x *PodProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3695Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3695Slc - var yyhl3695 bool = l >= 0 - for yyj3695 := 0; ; yyj3695++ { - if yyhl3695 { - if yyj3695 >= l { + var yys3711Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3711Slc + var yyhl3711 bool = l >= 0 + for yyj3711 := 0; ; yyj3711++ { + if yyhl3711 { + if yyj3711 >= l { break } } else { @@ -46474,10 +46677,10 @@ func (x *PodProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3695Slc = r.DecodeBytes(yys3695Slc, true, true) - yys3695 := string(yys3695Slc) + yys3711Slc = r.DecodeBytes(yys3711Slc, true, true) + yys3711 := string(yys3711Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3695 { + switch yys3711 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -46497,9 +46700,9 @@ func (x *PodProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Path = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3695) - } // end switch yys3695 - } // end for yyj3695 + z.DecStructFieldNotFound(-1, yys3711) + } // end switch yys3711 + } // end for yyj3711 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -46507,16 +46710,16 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3699 int - var yyb3699 bool - var yyhl3699 bool = l >= 0 - yyj3699++ - if yyhl3699 { - yyb3699 = yyj3699 > l + var yyj3715 int + var yyb3715 bool + var yyhl3715 bool = l >= 0 + yyj3715++ + if yyhl3715 { + yyb3715 = yyj3715 > l } else { - yyb3699 = r.CheckBreak() + yyb3715 = r.CheckBreak() } - if yyb3699 { + if yyb3715 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46526,13 +46729,13 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj3699++ - if yyhl3699 { - yyb3699 = yyj3699 > l + yyj3715++ + if yyhl3715 { + yyb3715 = yyj3715 > l } else { - yyb3699 = r.CheckBreak() + yyb3715 = r.CheckBreak() } - if yyb3699 { + if yyb3715 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46542,13 +46745,13 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj3699++ - if yyhl3699 { - yyb3699 = yyj3699 > l + yyj3715++ + if yyhl3715 { + yyb3715 = yyj3715 > l } else { - yyb3699 = r.CheckBreak() + yyb3715 = r.CheckBreak() } - if yyb3699 { + if yyb3715 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46559,17 +46762,17 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) x.Path = string(r.DecodeString()) } for { - yyj3699++ - if yyhl3699 { - yyb3699 = yyj3699 > l + yyj3715++ + if yyhl3715 { + yyb3715 = yyj3715 > l } else { - yyb3699 = r.CheckBreak() + yyb3715 = r.CheckBreak() } - if yyb3699 { + if yyb3715 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3699-1, "") + z.DecStructFieldNotFound(yyj3715-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -46581,36 +46784,36 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3703 := z.EncBinary() - _ = yym3703 + yym3719 := z.EncBinary() + _ = yym3719 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3704 := !z.EncBinary() - yy2arr3704 := z.EncBasicHandle().StructToArray - var yyq3704 [3]bool - _, _, _ = yysep3704, yyq3704, yy2arr3704 - const yyr3704 bool = false - yyq3704[0] = x.Kind != "" - yyq3704[1] = x.APIVersion != "" - var yynn3704 int - if yyr3704 || yy2arr3704 { + yysep3720 := !z.EncBinary() + yy2arr3720 := z.EncBasicHandle().StructToArray + var yyq3720 [3]bool + _, _, _ = yysep3720, yyq3720, yy2arr3720 + const yyr3720 bool = false + yyq3720[0] = x.Kind != "" + yyq3720[1] = x.APIVersion != "" + var yynn3720 int + if yyr3720 || yy2arr3720 { r.EncodeArrayStart(3) } else { - yynn3704 = 1 - for _, b := range yyq3704 { + yynn3720 = 1 + for _, b := range yyq3720 { if b { - yynn3704++ + yynn3720++ } } - r.EncodeMapStart(yynn3704) - yynn3704 = 0 + r.EncodeMapStart(yynn3720) + yynn3720 = 0 } - if yyr3704 || yy2arr3704 { + if yyr3720 || yy2arr3720 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3704[0] { - yym3706 := z.EncBinary() - _ = yym3706 + if yyq3720[0] { + yym3722 := z.EncBinary() + _ = yym3722 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -46619,23 +46822,23 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3704[0] { + if yyq3720[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3707 := z.EncBinary() - _ = yym3707 + yym3723 := z.EncBinary() + _ = yym3723 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3704 || yy2arr3704 { + if yyr3720 || yy2arr3720 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3704[1] { - yym3709 := z.EncBinary() - _ = yym3709 + if yyq3720[1] { + yym3725 := z.EncBinary() + _ = yym3725 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -46644,22 +46847,22 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3704[1] { + if yyq3720[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3710 := z.EncBinary() - _ = yym3710 + yym3726 := z.EncBinary() + _ = yym3726 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3704 || yy2arr3704 { + if yyr3720 || yy2arr3720 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3712 := z.EncBinary() - _ = yym3712 + yym3728 := z.EncBinary() + _ = yym3728 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Path)) @@ -46668,14 +46871,14 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Path")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3713 := z.EncBinary() - _ = yym3713 + yym3729 := z.EncBinary() + _ = yym3729 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Path)) } } - if yyr3704 || yy2arr3704 { + if yyr3720 || yy2arr3720 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -46688,25 +46891,25 @@ func (x *NodeProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3714 := z.DecBinary() - _ = yym3714 + yym3730 := z.DecBinary() + _ = yym3730 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3715 := r.ContainerType() - if yyct3715 == codecSelferValueTypeMap1234 { - yyl3715 := r.ReadMapStart() - if yyl3715 == 0 { + yyct3731 := r.ContainerType() + if yyct3731 == codecSelferValueTypeMap1234 { + yyl3731 := r.ReadMapStart() + if yyl3731 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3715, d) + x.codecDecodeSelfFromMap(yyl3731, d) } - } else if yyct3715 == codecSelferValueTypeArray1234 { - yyl3715 := r.ReadArrayStart() - if yyl3715 == 0 { + } else if yyct3731 == codecSelferValueTypeArray1234 { + yyl3731 := r.ReadArrayStart() + if yyl3731 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3715, d) + x.codecDecodeSelfFromArray(yyl3731, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -46718,12 +46921,12 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3716Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3716Slc - var yyhl3716 bool = l >= 0 - for yyj3716 := 0; ; yyj3716++ { - if yyhl3716 { - if yyj3716 >= l { + var yys3732Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3732Slc + var yyhl3732 bool = l >= 0 + for yyj3732 := 0; ; yyj3732++ { + if yyhl3732 { + if yyj3732 >= l { break } } else { @@ -46732,10 +46935,10 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3716Slc = r.DecodeBytes(yys3716Slc, true, true) - yys3716 := string(yys3716Slc) + yys3732Slc = r.DecodeBytes(yys3732Slc, true, true) + yys3732 := string(yys3732Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3716 { + switch yys3732 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -46755,9 +46958,9 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Path = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3716) - } // end switch yys3716 - } // end for yyj3716 + z.DecStructFieldNotFound(-1, yys3732) + } // end switch yys3732 + } // end for yyj3732 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -46765,16 +46968,16 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3720 int - var yyb3720 bool - var yyhl3720 bool = l >= 0 - yyj3720++ - if yyhl3720 { - yyb3720 = yyj3720 > l + var yyj3736 int + var yyb3736 bool + var yyhl3736 bool = l >= 0 + yyj3736++ + if yyhl3736 { + yyb3736 = yyj3736 > l } else { - yyb3720 = r.CheckBreak() + yyb3736 = r.CheckBreak() } - if yyb3720 { + if yyb3736 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46784,13 +46987,13 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj3720++ - if yyhl3720 { - yyb3720 = yyj3720 > l + yyj3736++ + if yyhl3736 { + yyb3736 = yyj3736 > l } else { - yyb3720 = r.CheckBreak() + yyb3736 = r.CheckBreak() } - if yyb3720 { + if yyb3736 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46800,13 +47003,13 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj3720++ - if yyhl3720 { - yyb3720 = yyj3720 > l + yyj3736++ + if yyhl3736 { + yyb3736 = yyj3736 > l } else { - yyb3720 = r.CheckBreak() + yyb3736 = r.CheckBreak() } - if yyb3720 { + if yyb3736 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -46817,17 +47020,17 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) x.Path = string(r.DecodeString()) } for { - yyj3720++ - if yyhl3720 { - yyb3720 = yyj3720 > l + yyj3736++ + if yyhl3736 { + yyb3736 = yyj3736 > l } else { - yyb3720 = r.CheckBreak() + yyb3736 = r.CheckBreak() } - if yyb3720 { + if yyb3736 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3720-1, "") + z.DecStructFieldNotFound(yyj3736-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -46839,36 +47042,36 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3724 := z.EncBinary() - _ = yym3724 + yym3740 := z.EncBinary() + _ = yym3740 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3725 := !z.EncBinary() - yy2arr3725 := z.EncBasicHandle().StructToArray - var yyq3725 [3]bool - _, _, _ = yysep3725, yyq3725, yy2arr3725 - const yyr3725 bool = false - yyq3725[0] = x.Kind != "" - yyq3725[1] = x.APIVersion != "" - var yynn3725 int - if yyr3725 || yy2arr3725 { + yysep3741 := !z.EncBinary() + yy2arr3741 := z.EncBasicHandle().StructToArray + var yyq3741 [3]bool + _, _, _ = yysep3741, yyq3741, yy2arr3741 + const yyr3741 bool = false + yyq3741[0] = x.Kind != "" + yyq3741[1] = x.APIVersion != "" + var yynn3741 int + if yyr3741 || yy2arr3741 { r.EncodeArrayStart(3) } else { - yynn3725 = 1 - for _, b := range yyq3725 { + yynn3741 = 1 + for _, b := range yyq3741 { if b { - yynn3725++ + yynn3741++ } } - r.EncodeMapStart(yynn3725) - yynn3725 = 0 + r.EncodeMapStart(yynn3741) + yynn3741 = 0 } - if yyr3725 || yy2arr3725 { + if yyr3741 || yy2arr3741 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3725[0] { - yym3727 := z.EncBinary() - _ = yym3727 + if yyq3741[0] { + yym3743 := z.EncBinary() + _ = yym3743 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -46877,23 +47080,23 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3725[0] { + if yyq3741[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3728 := z.EncBinary() - _ = yym3728 + yym3744 := z.EncBinary() + _ = yym3744 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3725 || yy2arr3725 { + if yyr3741 || yy2arr3741 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3725[1] { - yym3730 := z.EncBinary() - _ = yym3730 + if yyq3741[1] { + yym3746 := z.EncBinary() + _ = yym3746 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -46902,22 +47105,22 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3725[1] { + if yyq3741[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3731 := z.EncBinary() - _ = yym3731 + yym3747 := z.EncBinary() + _ = yym3747 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3725 || yy2arr3725 { + if yyr3741 || yy2arr3741 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3733 := z.EncBinary() - _ = yym3733 + yym3749 := z.EncBinary() + _ = yym3749 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Path)) @@ -46926,14 +47129,14 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Path")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3734 := z.EncBinary() - _ = yym3734 + yym3750 := z.EncBinary() + _ = yym3750 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Path)) } } - if yyr3725 || yy2arr3725 { + if yyr3741 || yy2arr3741 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -46946,25 +47149,25 @@ func (x *ServiceProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3735 := z.DecBinary() - _ = yym3735 + yym3751 := z.DecBinary() + _ = yym3751 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3736 := r.ContainerType() - if yyct3736 == codecSelferValueTypeMap1234 { - yyl3736 := r.ReadMapStart() - if yyl3736 == 0 { + yyct3752 := r.ContainerType() + if yyct3752 == codecSelferValueTypeMap1234 { + yyl3752 := r.ReadMapStart() + if yyl3752 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3736, d) + x.codecDecodeSelfFromMap(yyl3752, d) } - } else if yyct3736 == codecSelferValueTypeArray1234 { - yyl3736 := r.ReadArrayStart() - if yyl3736 == 0 { + } else if yyct3752 == codecSelferValueTypeArray1234 { + yyl3752 := r.ReadArrayStart() + if yyl3752 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3736, d) + x.codecDecodeSelfFromArray(yyl3752, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -46976,12 +47179,12 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3737Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3737Slc - var yyhl3737 bool = l >= 0 - for yyj3737 := 0; ; yyj3737++ { - if yyhl3737 { - if yyj3737 >= l { + var yys3753Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3753Slc + var yyhl3753 bool = l >= 0 + for yyj3753 := 0; ; yyj3753++ { + if yyhl3753 { + if yyj3753 >= l { break } } else { @@ -46990,10 +47193,10 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3737Slc = r.DecodeBytes(yys3737Slc, true, true) - yys3737 := string(yys3737Slc) + yys3753Slc = r.DecodeBytes(yys3753Slc, true, true) + yys3753 := string(yys3753Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3737 { + switch yys3753 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -47013,9 +47216,9 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder x.Path = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3737) - } // end switch yys3737 - } // end for yyj3737 + z.DecStructFieldNotFound(-1, yys3753) + } // end switch yys3753 + } // end for yyj3753 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -47023,16 +47226,16 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3741 int - var yyb3741 bool - var yyhl3741 bool = l >= 0 - yyj3741++ - if yyhl3741 { - yyb3741 = yyj3741 > l + var yyj3757 int + var yyb3757 bool + var yyhl3757 bool = l >= 0 + yyj3757++ + if yyhl3757 { + yyb3757 = yyj3757 > l } else { - yyb3741 = r.CheckBreak() + yyb3757 = r.CheckBreak() } - if yyb3741 { + if yyb3757 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47042,13 +47245,13 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.Kind = string(r.DecodeString()) } - yyj3741++ - if yyhl3741 { - yyb3741 = yyj3741 > l + yyj3757++ + if yyhl3757 { + yyb3757 = yyj3757 > l } else { - yyb3741 = r.CheckBreak() + yyb3757 = r.CheckBreak() } - if yyb3741 { + if yyb3757 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47058,13 +47261,13 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.APIVersion = string(r.DecodeString()) } - yyj3741++ - if yyhl3741 { - yyb3741 = yyj3741 > l + yyj3757++ + if yyhl3757 { + yyb3757 = yyj3757 > l } else { - yyb3741 = r.CheckBreak() + yyb3757 = r.CheckBreak() } - if yyb3741 { + if yyb3757 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47075,17 +47278,17 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod x.Path = string(r.DecodeString()) } for { - yyj3741++ - if yyhl3741 { - yyb3741 = yyj3741 > l + yyj3757++ + if yyhl3757 { + yyb3757 = yyj3757 > l } else { - yyb3741 = r.CheckBreak() + yyb3757 = r.CheckBreak() } - if yyb3741 { + if yyb3757 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3741-1, "") + z.DecStructFieldNotFound(yyj3757-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -47097,34 +47300,34 @@ func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3745 := z.EncBinary() - _ = yym3745 + yym3761 := z.EncBinary() + _ = yym3761 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3746 := !z.EncBinary() - yy2arr3746 := z.EncBasicHandle().StructToArray - var yyq3746 [5]bool - _, _, _ = yysep3746, yyq3746, yy2arr3746 - const yyr3746 bool = false - yyq3746[4] = x.Controller != nil - var yynn3746 int - if yyr3746 || yy2arr3746 { + yysep3762 := !z.EncBinary() + yy2arr3762 := z.EncBasicHandle().StructToArray + var yyq3762 [5]bool + _, _, _ = yysep3762, yyq3762, yy2arr3762 + const yyr3762 bool = false + yyq3762[4] = x.Controller != nil + var yynn3762 int + if yyr3762 || yy2arr3762 { r.EncodeArrayStart(5) } else { - yynn3746 = 4 - for _, b := range yyq3746 { + yynn3762 = 4 + for _, b := range yyq3762 { if b { - yynn3746++ + yynn3762++ } } - r.EncodeMapStart(yynn3746) - yynn3746 = 0 + r.EncodeMapStart(yynn3762) + yynn3762 = 0 } - if yyr3746 || yy2arr3746 { + if yyr3762 || yy2arr3762 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3748 := z.EncBinary() - _ = yym3748 + yym3764 := z.EncBinary() + _ = yym3764 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -47133,17 +47336,17 @@ func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3749 := z.EncBinary() - _ = yym3749 + yym3765 := z.EncBinary() + _ = yym3765 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } - if yyr3746 || yy2arr3746 { + if yyr3762 || yy2arr3762 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3751 := z.EncBinary() - _ = yym3751 + yym3767 := z.EncBinary() + _ = yym3767 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -47152,17 +47355,17 @@ func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3752 := z.EncBinary() - _ = yym3752 + yym3768 := z.EncBinary() + _ = yym3768 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } - if yyr3746 || yy2arr3746 { + if yyr3762 || yy2arr3762 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3754 := z.EncBinary() - _ = yym3754 + yym3770 := z.EncBinary() + _ = yym3770 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) @@ -47171,17 +47374,17 @@ func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("name")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3755 := z.EncBinary() - _ = yym3755 + yym3771 := z.EncBinary() + _ = yym3771 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) } } - if yyr3746 || yy2arr3746 { + if yyr3762 || yy2arr3762 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3757 := z.EncBinary() - _ = yym3757 + yym3773 := z.EncBinary() + _ = yym3773 if false { } else if z.HasExtensions() && z.EncExt(x.UID) { } else { @@ -47191,50 +47394,50 @@ func (x *OwnerReference) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("uid")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3758 := z.EncBinary() - _ = yym3758 + yym3774 := z.EncBinary() + _ = yym3774 if false { } else if z.HasExtensions() && z.EncExt(x.UID) { } else { r.EncodeString(codecSelferC_UTF81234, string(x.UID)) } } - if yyr3746 || yy2arr3746 { + if yyr3762 || yy2arr3762 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3746[4] { + if yyq3762[4] { if x.Controller == nil { r.EncodeNil() } else { - yy3760 := *x.Controller - yym3761 := z.EncBinary() - _ = yym3761 + yy3776 := *x.Controller + yym3777 := z.EncBinary() + _ = yym3777 if false { } else { - r.EncodeBool(bool(yy3760)) + r.EncodeBool(bool(yy3776)) } } } else { r.EncodeNil() } } else { - if yyq3746[4] { + if yyq3762[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("controller")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.Controller == nil { r.EncodeNil() } else { - yy3762 := *x.Controller - yym3763 := z.EncBinary() - _ = yym3763 + yy3778 := *x.Controller + yym3779 := z.EncBinary() + _ = yym3779 if false { } else { - r.EncodeBool(bool(yy3762)) + r.EncodeBool(bool(yy3778)) } } } } - if yyr3746 || yy2arr3746 { + if yyr3762 || yy2arr3762 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -47247,25 +47450,25 @@ func (x *OwnerReference) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3764 := z.DecBinary() - _ = yym3764 + yym3780 := z.DecBinary() + _ = yym3780 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3765 := r.ContainerType() - if yyct3765 == codecSelferValueTypeMap1234 { - yyl3765 := r.ReadMapStart() - if yyl3765 == 0 { + yyct3781 := r.ContainerType() + if yyct3781 == codecSelferValueTypeMap1234 { + yyl3781 := r.ReadMapStart() + if yyl3781 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3765, d) + x.codecDecodeSelfFromMap(yyl3781, d) } - } else if yyct3765 == codecSelferValueTypeArray1234 { - yyl3765 := r.ReadArrayStart() - if yyl3765 == 0 { + } else if yyct3781 == codecSelferValueTypeArray1234 { + yyl3781 := r.ReadArrayStart() + if yyl3781 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3765, d) + x.codecDecodeSelfFromArray(yyl3781, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -47277,12 +47480,12 @@ func (x *OwnerReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3766Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3766Slc - var yyhl3766 bool = l >= 0 - for yyj3766 := 0; ; yyj3766++ { - if yyhl3766 { - if yyj3766 >= l { + var yys3782Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3782Slc + var yyhl3782 bool = l >= 0 + for yyj3782 := 0; ; yyj3782++ { + if yyhl3782 { + if yyj3782 >= l { break } } else { @@ -47291,10 +47494,10 @@ func (x *OwnerReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3766Slc = r.DecodeBytes(yys3766Slc, true, true) - yys3766 := string(yys3766Slc) + yys3782Slc = r.DecodeBytes(yys3782Slc, true, true) + yys3782 := string(yys3782Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3766 { + switch yys3782 { case "apiVersion": if r.TryDecodeAsNil() { x.APIVersion = "" @@ -47328,17 +47531,17 @@ func (x *OwnerReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.Controller == nil { x.Controller = new(bool) } - yym3772 := z.DecBinary() - _ = yym3772 + yym3788 := z.DecBinary() + _ = yym3788 if false { } else { *((*bool)(x.Controller)) = r.DecodeBool() } } default: - z.DecStructFieldNotFound(-1, yys3766) - } // end switch yys3766 - } // end for yyj3766 + z.DecStructFieldNotFound(-1, yys3782) + } // end switch yys3782 + } // end for yyj3782 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -47346,16 +47549,16 @@ func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3773 int - var yyb3773 bool - var yyhl3773 bool = l >= 0 - yyj3773++ - if yyhl3773 { - yyb3773 = yyj3773 > l + var yyj3789 int + var yyb3789 bool + var yyhl3789 bool = l >= 0 + yyj3789++ + if yyhl3789 { + yyb3789 = yyj3789 > l } else { - yyb3773 = r.CheckBreak() + yyb3789 = r.CheckBreak() } - if yyb3773 { + if yyb3789 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47365,13 +47568,13 @@ func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3773++ - if yyhl3773 { - yyb3773 = yyj3773 > l + yyj3789++ + if yyhl3789 { + yyb3789 = yyj3789 > l } else { - yyb3773 = r.CheckBreak() + yyb3789 = r.CheckBreak() } - if yyb3773 { + if yyb3789 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47381,13 +47584,13 @@ func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3773++ - if yyhl3773 { - yyb3773 = yyj3773 > l + yyj3789++ + if yyhl3789 { + yyb3789 = yyj3789 > l } else { - yyb3773 = r.CheckBreak() + yyb3789 = r.CheckBreak() } - if yyb3773 { + if yyb3789 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47397,13 +47600,13 @@ func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Name = string(r.DecodeString()) } - yyj3773++ - if yyhl3773 { - yyb3773 = yyj3773 > l + yyj3789++ + if yyhl3789 { + yyb3789 = yyj3789 > l } else { - yyb3773 = r.CheckBreak() + yyb3789 = r.CheckBreak() } - if yyb3773 { + if yyb3789 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47413,13 +47616,13 @@ func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.UID = pkg1_types.UID(r.DecodeString()) } - yyj3773++ - if yyhl3773 { - yyb3773 = yyj3773 > l + yyj3789++ + if yyhl3789 { + yyb3789 = yyj3789 > l } else { - yyb3773 = r.CheckBreak() + yyb3789 = r.CheckBreak() } - if yyb3773 { + if yyb3789 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47432,25 +47635,25 @@ func (x *OwnerReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if x.Controller == nil { x.Controller = new(bool) } - yym3779 := z.DecBinary() - _ = yym3779 + yym3795 := z.DecBinary() + _ = yym3795 if false { } else { *((*bool)(x.Controller)) = r.DecodeBool() } } for { - yyj3773++ - if yyhl3773 { - yyb3773 = yyj3773 > l + yyj3789++ + if yyhl3789 { + yyb3789 = yyj3789 > l } else { - yyb3773 = r.CheckBreak() + yyb3789 = r.CheckBreak() } - if yyb3773 { + if yyb3789 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3773-1, "") + z.DecStructFieldNotFound(yyj3789-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -47462,193 +47665,193 @@ func (x *ObjectReference) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3780 := z.EncBinary() - _ = yym3780 + yym3796 := z.EncBinary() + _ = yym3796 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3781 := !z.EncBinary() - yy2arr3781 := z.EncBasicHandle().StructToArray - var yyq3781 [7]bool - _, _, _ = yysep3781, yyq3781, yy2arr3781 - const yyr3781 bool = false - yyq3781[0] = x.Kind != "" - yyq3781[1] = x.Namespace != "" - yyq3781[2] = x.Name != "" - yyq3781[3] = x.UID != "" - yyq3781[4] = x.APIVersion != "" - yyq3781[5] = x.ResourceVersion != "" - yyq3781[6] = x.FieldPath != "" - var yynn3781 int - if yyr3781 || yy2arr3781 { + yysep3797 := !z.EncBinary() + yy2arr3797 := z.EncBasicHandle().StructToArray + var yyq3797 [7]bool + _, _, _ = yysep3797, yyq3797, yy2arr3797 + const yyr3797 bool = false + yyq3797[0] = x.Kind != "" + yyq3797[1] = x.Namespace != "" + yyq3797[2] = x.Name != "" + yyq3797[3] = x.UID != "" + yyq3797[4] = x.APIVersion != "" + yyq3797[5] = x.ResourceVersion != "" + yyq3797[6] = x.FieldPath != "" + var yynn3797 int + if yyr3797 || yy2arr3797 { r.EncodeArrayStart(7) } else { - yynn3781 = 0 - for _, b := range yyq3781 { + yynn3797 = 0 + for _, b := range yyq3797 { if b { - yynn3781++ + yynn3797++ } } - r.EncodeMapStart(yynn3781) - yynn3781 = 0 + r.EncodeMapStart(yynn3797) + yynn3797 = 0 } - if yyr3781 || yy2arr3781 { + if yyr3797 || yy2arr3797 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[0] { - yym3783 := z.EncBinary() - _ = yym3783 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3781[0] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("kind")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3784 := z.EncBinary() - _ = yym3784 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) - } - } - } - if yyr3781 || yy2arr3781 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[1] { - yym3786 := z.EncBinary() - _ = yym3786 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Namespace)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3781[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("namespace")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3787 := z.EncBinary() - _ = yym3787 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Namespace)) - } - } - } - if yyr3781 || yy2arr3781 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[2] { - yym3789 := z.EncBinary() - _ = yym3789 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Name)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3781[2] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("name")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3790 := z.EncBinary() - _ = yym3790 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Name)) - } - } - } - if yyr3781 || yy2arr3781 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[3] { - yym3792 := z.EncBinary() - _ = yym3792 - if false { - } else if z.HasExtensions() && z.EncExt(x.UID) { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.UID)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3781[3] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("uid")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3793 := z.EncBinary() - _ = yym3793 - if false { - } else if z.HasExtensions() && z.EncExt(x.UID) { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.UID)) - } - } - } - if yyr3781 || yy2arr3781 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[4] { - yym3795 := z.EncBinary() - _ = yym3795 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3781[4] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3796 := z.EncBinary() - _ = yym3796 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) - } - } - } - if yyr3781 || yy2arr3781 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[5] { - yym3798 := z.EncBinary() - _ = yym3798 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3781[5] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("resourceVersion")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) + if yyq3797[0] { yym3799 := z.EncBinary() _ = yym3799 if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3797[0] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kind")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3800 := z.EncBinary() + _ = yym3800 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } + } + if yyr3797 || yy2arr3797 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3797[1] { + yym3802 := z.EncBinary() + _ = yym3802 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Namespace)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3797[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("namespace")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3803 := z.EncBinary() + _ = yym3803 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Namespace)) + } + } + } + if yyr3797 || yy2arr3797 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3797[2] { + yym3805 := z.EncBinary() + _ = yym3805 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Name)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3797[2] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("name")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3806 := z.EncBinary() + _ = yym3806 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Name)) + } + } + } + if yyr3797 || yy2arr3797 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3797[3] { + yym3808 := z.EncBinary() + _ = yym3808 + if false { + } else if z.HasExtensions() && z.EncExt(x.UID) { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.UID)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3797[3] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("uid")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3809 := z.EncBinary() + _ = yym3809 + if false { + } else if z.HasExtensions() && z.EncExt(x.UID) { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.UID)) + } + } + } + if yyr3797 || yy2arr3797 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3797[4] { + yym3811 := z.EncBinary() + _ = yym3811 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3797[4] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3812 := z.EncBinary() + _ = yym3812 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } + } + if yyr3797 || yy2arr3797 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3797[5] { + yym3814 := z.EncBinary() + _ = yym3814 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3797[5] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("resourceVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3815 := z.EncBinary() + _ = yym3815 + if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion)) } } } - if yyr3781 || yy2arr3781 { + if yyr3797 || yy2arr3797 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3781[6] { - yym3801 := z.EncBinary() - _ = yym3801 + if yyq3797[6] { + yym3817 := z.EncBinary() + _ = yym3817 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.FieldPath)) @@ -47657,19 +47860,19 @@ func (x *ObjectReference) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3781[6] { + if yyq3797[6] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("fieldPath")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3802 := z.EncBinary() - _ = yym3802 + yym3818 := z.EncBinary() + _ = yym3818 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.FieldPath)) } } } - if yyr3781 || yy2arr3781 { + if yyr3797 || yy2arr3797 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -47682,25 +47885,25 @@ func (x *ObjectReference) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3803 := z.DecBinary() - _ = yym3803 + yym3819 := z.DecBinary() + _ = yym3819 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3804 := r.ContainerType() - if yyct3804 == codecSelferValueTypeMap1234 { - yyl3804 := r.ReadMapStart() - if yyl3804 == 0 { + yyct3820 := r.ContainerType() + if yyct3820 == codecSelferValueTypeMap1234 { + yyl3820 := r.ReadMapStart() + if yyl3820 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3804, d) + x.codecDecodeSelfFromMap(yyl3820, d) } - } else if yyct3804 == codecSelferValueTypeArray1234 { - yyl3804 := r.ReadArrayStart() - if yyl3804 == 0 { + } else if yyct3820 == codecSelferValueTypeArray1234 { + yyl3820 := r.ReadArrayStart() + if yyl3820 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3804, d) + x.codecDecodeSelfFromArray(yyl3820, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -47712,12 +47915,12 @@ func (x *ObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3805Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3805Slc - var yyhl3805 bool = l >= 0 - for yyj3805 := 0; ; yyj3805++ { - if yyhl3805 { - if yyj3805 >= l { + var yys3821Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3821Slc + var yyhl3821 bool = l >= 0 + for yyj3821 := 0; ; yyj3821++ { + if yyhl3821 { + if yyj3821 >= l { break } } else { @@ -47726,10 +47929,10 @@ func (x *ObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3805Slc = r.DecodeBytes(yys3805Slc, true, true) - yys3805 := string(yys3805Slc) + yys3821Slc = r.DecodeBytes(yys3821Slc, true, true) + yys3821 := string(yys3821Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3805 { + switch yys3821 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -47773,9 +47976,9 @@ func (x *ObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.FieldPath = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3805) - } // end switch yys3805 - } // end for yyj3805 + z.DecStructFieldNotFound(-1, yys3821) + } // end switch yys3821 + } // end for yyj3821 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -47783,16 +47986,16 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3813 int - var yyb3813 bool - var yyhl3813 bool = l >= 0 - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + var yyj3829 int + var yyb3829 bool + var yyhl3829 bool = l >= 0 + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47802,13 +48005,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47818,13 +48021,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Namespace = string(r.DecodeString()) } - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47834,13 +48037,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Name = string(r.DecodeString()) } - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47850,13 +48053,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.UID = pkg1_types.UID(r.DecodeString()) } - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47866,13 +48069,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47882,13 +48085,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.ResourceVersion = string(r.DecodeString()) } - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -47899,17 +48102,17 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) x.FieldPath = string(r.DecodeString()) } for { - yyj3813++ - if yyhl3813 { - yyb3813 = yyj3813 > l + yyj3829++ + if yyhl3829 { + yyb3829 = yyj3829 > l } else { - yyb3813 = r.CheckBreak() + yyb3829 = r.CheckBreak() } - if yyb3813 { + if yyb3829 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3813-1, "") + z.DecStructFieldNotFound(yyj3829-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -47921,33 +48124,33 @@ func (x *LocalObjectReference) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3821 := z.EncBinary() - _ = yym3821 + yym3837 := z.EncBinary() + _ = yym3837 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3822 := !z.EncBinary() - yy2arr3822 := z.EncBasicHandle().StructToArray - var yyq3822 [1]bool - _, _, _ = yysep3822, yyq3822, yy2arr3822 - const yyr3822 bool = false - var yynn3822 int - if yyr3822 || yy2arr3822 { + yysep3838 := !z.EncBinary() + yy2arr3838 := z.EncBasicHandle().StructToArray + var yyq3838 [1]bool + _, _, _ = yysep3838, yyq3838, yy2arr3838 + const yyr3838 bool = false + var yynn3838 int + if yyr3838 || yy2arr3838 { r.EncodeArrayStart(1) } else { - yynn3822 = 1 - for _, b := range yyq3822 { + yynn3838 = 1 + for _, b := range yyq3838 { if b { - yynn3822++ + yynn3838++ } } - r.EncodeMapStart(yynn3822) - yynn3822 = 0 + r.EncodeMapStart(yynn3838) + yynn3838 = 0 } - if yyr3822 || yy2arr3822 { + if yyr3838 || yy2arr3838 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym3824 := z.EncBinary() - _ = yym3824 + yym3840 := z.EncBinary() + _ = yym3840 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) @@ -47956,14 +48159,14 @@ func (x *LocalObjectReference) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("Name")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3825 := z.EncBinary() - _ = yym3825 + yym3841 := z.EncBinary() + _ = yym3841 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Name)) } } - if yyr3822 || yy2arr3822 { + if yyr3838 || yy2arr3838 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -47976,25 +48179,25 @@ func (x *LocalObjectReference) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3826 := z.DecBinary() - _ = yym3826 + yym3842 := z.DecBinary() + _ = yym3842 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3827 := r.ContainerType() - if yyct3827 == codecSelferValueTypeMap1234 { - yyl3827 := r.ReadMapStart() - if yyl3827 == 0 { + yyct3843 := r.ContainerType() + if yyct3843 == codecSelferValueTypeMap1234 { + yyl3843 := r.ReadMapStart() + if yyl3843 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3827, d) + x.codecDecodeSelfFromMap(yyl3843, d) } - } else if yyct3827 == codecSelferValueTypeArray1234 { - yyl3827 := r.ReadArrayStart() - if yyl3827 == 0 { + } else if yyct3843 == codecSelferValueTypeArray1234 { + yyl3843 := r.ReadArrayStart() + if yyl3843 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3827, d) + x.codecDecodeSelfFromArray(yyl3843, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -48006,12 +48209,12 @@ func (x *LocalObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3828Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3828Slc - var yyhl3828 bool = l >= 0 - for yyj3828 := 0; ; yyj3828++ { - if yyhl3828 { - if yyj3828 >= l { + var yys3844Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3844Slc + var yyhl3844 bool = l >= 0 + for yyj3844 := 0; ; yyj3844++ { + if yyhl3844 { + if yyj3844 >= l { break } } else { @@ -48020,10 +48223,10 @@ func (x *LocalObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3828Slc = r.DecodeBytes(yys3828Slc, true, true) - yys3828 := string(yys3828Slc) + yys3844Slc = r.DecodeBytes(yys3844Slc, true, true) + yys3844 := string(yys3844Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3828 { + switch yys3844 { case "Name": if r.TryDecodeAsNil() { x.Name = "" @@ -48031,9 +48234,9 @@ func (x *LocalObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode x.Name = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3828) - } // end switch yys3828 - } // end for yyj3828 + z.DecStructFieldNotFound(-1, yys3844) + } // end switch yys3844 + } // end for yyj3844 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -48041,16 +48244,16 @@ func (x *LocalObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Deco var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3830 int - var yyb3830 bool - var yyhl3830 bool = l >= 0 - yyj3830++ - if yyhl3830 { - yyb3830 = yyj3830 > l + var yyj3846 int + var yyb3846 bool + var yyhl3846 bool = l >= 0 + yyj3846++ + if yyhl3846 { + yyb3846 = yyj3846 > l } else { - yyb3830 = r.CheckBreak() + yyb3846 = r.CheckBreak() } - if yyb3830 { + if yyb3846 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -48061,17 +48264,17 @@ func (x *LocalObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Deco x.Name = string(r.DecodeString()) } for { - yyj3830++ - if yyhl3830 { - yyb3830 = yyj3830 > l + yyj3846++ + if yyhl3846 { + yyb3846 = yyj3846 > l } else { - yyb3830 = r.CheckBreak() + yyb3846 = r.CheckBreak() } - if yyb3830 { + if yyb3846 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3830-1, "") + z.DecStructFieldNotFound(yyj3846-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -48083,37 +48286,37 @@ func (x *SerializedReference) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3832 := z.EncBinary() - _ = yym3832 + yym3848 := z.EncBinary() + _ = yym3848 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3833 := !z.EncBinary() - yy2arr3833 := z.EncBasicHandle().StructToArray - var yyq3833 [3]bool - _, _, _ = yysep3833, yyq3833, yy2arr3833 - const yyr3833 bool = false - yyq3833[0] = x.Kind != "" - yyq3833[1] = x.APIVersion != "" - yyq3833[2] = true - var yynn3833 int - if yyr3833 || yy2arr3833 { + yysep3849 := !z.EncBinary() + yy2arr3849 := z.EncBasicHandle().StructToArray + var yyq3849 [3]bool + _, _, _ = yysep3849, yyq3849, yy2arr3849 + const yyr3849 bool = false + yyq3849[0] = x.Kind != "" + yyq3849[1] = x.APIVersion != "" + yyq3849[2] = true + var yynn3849 int + if yyr3849 || yy2arr3849 { r.EncodeArrayStart(3) } else { - yynn3833 = 0 - for _, b := range yyq3833 { + yynn3849 = 0 + for _, b := range yyq3849 { if b { - yynn3833++ + yynn3849++ } } - r.EncodeMapStart(yynn3833) - yynn3833 = 0 + r.EncodeMapStart(yynn3849) + yynn3849 = 0 } - if yyr3833 || yy2arr3833 { + if yyr3849 || yy2arr3849 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3833[0] { - yym3835 := z.EncBinary() - _ = yym3835 + if yyq3849[0] { + yym3851 := z.EncBinary() + _ = yym3851 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -48122,23 +48325,23 @@ func (x *SerializedReference) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3833[0] { + if yyq3849[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3836 := z.EncBinary() - _ = yym3836 + yym3852 := z.EncBinary() + _ = yym3852 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3833 || yy2arr3833 { + if yyr3849 || yy2arr3849 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3833[1] { - yym3838 := z.EncBinary() - _ = yym3838 + if yyq3849[1] { + yym3854 := z.EncBinary() + _ = yym3854 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -48147,36 +48350,36 @@ func (x *SerializedReference) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3833[1] { + if yyq3849[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3839 := z.EncBinary() - _ = yym3839 + yym3855 := z.EncBinary() + _ = yym3855 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3833 || yy2arr3833 { + if yyr3849 || yy2arr3849 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3833[2] { - yy3841 := &x.Reference - yy3841.CodecEncodeSelf(e) + if yyq3849[2] { + yy3857 := &x.Reference + yy3857.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq3833[2] { + if yyq3849[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("reference")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3842 := &x.Reference - yy3842.CodecEncodeSelf(e) + yy3858 := &x.Reference + yy3858.CodecEncodeSelf(e) } } - if yyr3833 || yy2arr3833 { + if yyr3849 || yy2arr3849 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -48189,25 +48392,25 @@ func (x *SerializedReference) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3843 := z.DecBinary() - _ = yym3843 + yym3859 := z.DecBinary() + _ = yym3859 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3844 := r.ContainerType() - if yyct3844 == codecSelferValueTypeMap1234 { - yyl3844 := r.ReadMapStart() - if yyl3844 == 0 { + yyct3860 := r.ContainerType() + if yyct3860 == codecSelferValueTypeMap1234 { + yyl3860 := r.ReadMapStart() + if yyl3860 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3844, d) + x.codecDecodeSelfFromMap(yyl3860, d) } - } else if yyct3844 == codecSelferValueTypeArray1234 { - yyl3844 := r.ReadArrayStart() - if yyl3844 == 0 { + } else if yyct3860 == codecSelferValueTypeArray1234 { + yyl3860 := r.ReadArrayStart() + if yyl3860 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3844, d) + x.codecDecodeSelfFromArray(yyl3860, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -48219,12 +48422,12 @@ func (x *SerializedReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3845Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3845Slc - var yyhl3845 bool = l >= 0 - for yyj3845 := 0; ; yyj3845++ { - if yyhl3845 { - if yyj3845 >= l { + var yys3861Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3861Slc + var yyhl3861 bool = l >= 0 + for yyj3861 := 0; ; yyj3861++ { + if yyhl3861 { + if yyj3861 >= l { break } } else { @@ -48233,10 +48436,10 @@ func (x *SerializedReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3845Slc = r.DecodeBytes(yys3845Slc, true, true) - yys3845 := string(yys3845Slc) + yys3861Slc = r.DecodeBytes(yys3861Slc, true, true) + yys3861 := string(yys3861Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3845 { + switch yys3861 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -48253,13 +48456,13 @@ func (x *SerializedReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder if r.TryDecodeAsNil() { x.Reference = ObjectReference{} } else { - yyv3848 := &x.Reference - yyv3848.CodecDecodeSelf(d) + yyv3864 := &x.Reference + yyv3864.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys3845) - } // end switch yys3845 - } // end for yyj3845 + z.DecStructFieldNotFound(-1, yys3861) + } // end switch yys3861 + } // end for yyj3861 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -48267,16 +48470,16 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3849 int - var yyb3849 bool - var yyhl3849 bool = l >= 0 - yyj3849++ - if yyhl3849 { - yyb3849 = yyj3849 > l + var yyj3865 int + var yyb3865 bool + var yyhl3865 bool = l >= 0 + yyj3865++ + if yyhl3865 { + yyb3865 = yyj3865 > l } else { - yyb3849 = r.CheckBreak() + yyb3865 = r.CheckBreak() } - if yyb3849 { + if yyb3865 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -48286,13 +48489,13 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.Kind = string(r.DecodeString()) } - yyj3849++ - if yyhl3849 { - yyb3849 = yyj3849 > l + yyj3865++ + if yyhl3865 { + yyb3865 = yyj3865 > l } else { - yyb3849 = r.CheckBreak() + yyb3865 = r.CheckBreak() } - if yyb3849 { + if yyb3865 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -48302,13 +48505,13 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.APIVersion = string(r.DecodeString()) } - yyj3849++ - if yyhl3849 { - yyb3849 = yyj3849 > l + yyj3865++ + if yyhl3865 { + yyb3865 = yyj3865 > l } else { - yyb3849 = r.CheckBreak() + yyb3865 = r.CheckBreak() } - if yyb3849 { + if yyb3865 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -48316,243 +48519,26 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.Reference = ObjectReference{} } else { - yyv3852 := &x.Reference - yyv3852.CodecDecodeSelf(d) + yyv3868 := &x.Reference + yyv3868.CodecDecodeSelf(d) } for { - yyj3849++ - if yyhl3849 { - yyb3849 = yyj3849 > l + yyj3865++ + if yyhl3865 { + yyb3865 = yyj3865 > l } else { - yyb3849 = r.CheckBreak() + yyb3865 = r.CheckBreak() } - if yyb3849 { + if yyb3865 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3849-1, "") + z.DecStructFieldNotFound(yyj3865-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } func (x *EventSource) CodecEncodeSelf(e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - if x == nil { - r.EncodeNil() - } else { - yym3853 := z.EncBinary() - _ = yym3853 - if false { - } else if z.HasExtensions() && z.EncExt(x) { - } else { - yysep3854 := !z.EncBinary() - yy2arr3854 := z.EncBasicHandle().StructToArray - var yyq3854 [2]bool - _, _, _ = yysep3854, yyq3854, yy2arr3854 - const yyr3854 bool = false - yyq3854[0] = x.Component != "" - yyq3854[1] = x.Host != "" - var yynn3854 int - if yyr3854 || yy2arr3854 { - r.EncodeArrayStart(2) - } else { - yynn3854 = 0 - for _, b := range yyq3854 { - if b { - yynn3854++ - } - } - r.EncodeMapStart(yynn3854) - yynn3854 = 0 - } - if yyr3854 || yy2arr3854 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3854[0] { - yym3856 := z.EncBinary() - _ = yym3856 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Component)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3854[0] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("component")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3857 := z.EncBinary() - _ = yym3857 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Component)) - } - } - } - if yyr3854 || yy2arr3854 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3854[1] { - yym3859 := z.EncBinary() - _ = yym3859 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Host)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3854[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("host")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3860 := z.EncBinary() - _ = yym3860 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Host)) - } - } - } - if yyr3854 || yy2arr3854 { - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - z.EncSendContainerState(codecSelfer_containerMapEnd1234) - } - } - } -} - -func (x *EventSource) CodecDecodeSelf(d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - yym3861 := z.DecBinary() - _ = yym3861 - if false { - } else if z.HasExtensions() && z.DecExt(x) { - } else { - yyct3862 := r.ContainerType() - if yyct3862 == codecSelferValueTypeMap1234 { - yyl3862 := r.ReadMapStart() - if yyl3862 == 0 { - z.DecSendContainerState(codecSelfer_containerMapEnd1234) - } else { - x.codecDecodeSelfFromMap(yyl3862, d) - } - } else if yyct3862 == codecSelferValueTypeArray1234 { - yyl3862 := r.ReadArrayStart() - if yyl3862 == 0 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - x.codecDecodeSelfFromArray(yyl3862, d) - } - } else { - panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) - } - } -} - -func (x *EventSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yys3863Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3863Slc - var yyhl3863 bool = l >= 0 - for yyj3863 := 0; ; yyj3863++ { - if yyhl3863 { - if yyj3863 >= l { - break - } - } else { - if r.CheckBreak() { - break - } - } - z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3863Slc = r.DecodeBytes(yys3863Slc, true, true) - yys3863 := string(yys3863Slc) - z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3863 { - case "component": - if r.TryDecodeAsNil() { - x.Component = "" - } else { - x.Component = string(r.DecodeString()) - } - case "host": - if r.TryDecodeAsNil() { - x.Host = "" - } else { - x.Host = string(r.DecodeString()) - } - default: - z.DecStructFieldNotFound(-1, yys3863) - } // end switch yys3863 - } // end for yyj3863 - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x *EventSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yyj3866 int - var yyb3866 bool - var yyhl3866 bool = l >= 0 - yyj3866++ - if yyhl3866 { - yyb3866 = yyj3866 > l - } else { - yyb3866 = r.CheckBreak() - } - if yyb3866 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Component = "" - } else { - x.Component = string(r.DecodeString()) - } - yyj3866++ - if yyhl3866 { - yyb3866 = yyj3866 > l - } else { - yyb3866 = r.CheckBreak() - } - if yyb3866 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Host = "" - } else { - x.Host = string(r.DecodeString()) - } - for { - yyj3866++ - if yyhl3866 { - yyb3866 = yyj3866 > l - } else { - yyb3866 = r.CheckBreak() - } - if yyb3866 { - break - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3866-1, "") - } - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -48566,23 +48552,14 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { } else { yysep3870 := !z.EncBinary() yy2arr3870 := z.EncBasicHandle().StructToArray - var yyq3870 [11]bool + var yyq3870 [2]bool _, _, _ = yysep3870, yyq3870, yy2arr3870 const yyr3870 bool = false - yyq3870[0] = x.Kind != "" - yyq3870[1] = x.APIVersion != "" - yyq3870[2] = true - yyq3870[3] = true - yyq3870[4] = x.Reason != "" - yyq3870[5] = x.Message != "" - yyq3870[6] = true - yyq3870[7] = true - yyq3870[8] = true - yyq3870[9] = x.Count != 0 - yyq3870[10] = x.Type != "" + yyq3870[0] = x.Component != "" + yyq3870[1] = x.Host != "" var yynn3870 int if yyr3870 || yy2arr3870 { - r.EncodeArrayStart(11) + r.EncodeArrayStart(2) } else { yynn3870 = 0 for _, b := range yyq3870 { @@ -48600,7 +48577,7 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { _ = yym3872 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + r.EncodeString(codecSelferC_UTF81234, string(x.Component)) } } else { r.EncodeString(codecSelferC_UTF81234, "") @@ -48608,13 +48585,13 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { } else { if yyq3870[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("kind")) + r.EncodeString(codecSelferC_UTF81234, string("component")) z.EncSendContainerState(codecSelfer_containerMapValue1234) yym3873 := z.EncBinary() _ = yym3873 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + r.EncodeString(codecSelferC_UTF81234, string(x.Component)) } } } @@ -48625,7 +48602,7 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { _ = yym3875 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + r.EncodeString(codecSelferC_UTF81234, string(x.Host)) } } else { r.EncodeString(codecSelferC_UTF81234, "") @@ -48633,238 +48610,13 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { } else { if yyq3870[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + r.EncodeString(codecSelferC_UTF81234, string("host")) z.EncSendContainerState(codecSelfer_containerMapValue1234) yym3876 := z.EncBinary() _ = yym3876 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) - } - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[2] { - yy3878 := &x.ObjectMeta - yy3878.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq3870[2] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("metadata")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3879 := &x.ObjectMeta - yy3879.CodecEncodeSelf(e) - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[3] { - yy3881 := &x.InvolvedObject - yy3881.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq3870[3] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("involvedObject")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3882 := &x.InvolvedObject - yy3882.CodecEncodeSelf(e) - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[4] { - yym3884 := z.EncBinary() - _ = yym3884 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3870[4] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("reason")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3885 := z.EncBinary() - _ = yym3885 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) - } - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[5] { - yym3887 := z.EncBinary() - _ = yym3887 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Message)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3870[5] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("message")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3888 := z.EncBinary() - _ = yym3888 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Message)) - } - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[6] { - yy3890 := &x.Source - yy3890.CodecEncodeSelf(e) - } else { - r.EncodeNil() - } - } else { - if yyq3870[6] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("source")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3891 := &x.Source - yy3891.CodecEncodeSelf(e) - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[7] { - yy3893 := &x.FirstTimestamp - yym3894 := z.EncBinary() - _ = yym3894 - if false { - } else if z.HasExtensions() && z.EncExt(yy3893) { - } else if yym3894 { - z.EncBinaryMarshal(yy3893) - } else if !yym3894 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3893) - } else { - z.EncFallback(yy3893) - } - } else { - r.EncodeNil() - } - } else { - if yyq3870[7] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("firstTimestamp")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3895 := &x.FirstTimestamp - yym3896 := z.EncBinary() - _ = yym3896 - if false { - } else if z.HasExtensions() && z.EncExt(yy3895) { - } else if yym3896 { - z.EncBinaryMarshal(yy3895) - } else if !yym3896 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3895) - } else { - z.EncFallback(yy3895) - } - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[8] { - yy3898 := &x.LastTimestamp - yym3899 := z.EncBinary() - _ = yym3899 - if false { - } else if z.HasExtensions() && z.EncExt(yy3898) { - } else if yym3899 { - z.EncBinaryMarshal(yy3898) - } else if !yym3899 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3898) - } else { - z.EncFallback(yy3898) - } - } else { - r.EncodeNil() - } - } else { - if yyq3870[8] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("lastTimestamp")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3900 := &x.LastTimestamp - yym3901 := z.EncBinary() - _ = yym3901 - if false { - } else if z.HasExtensions() && z.EncExt(yy3900) { - } else if yym3901 { - z.EncBinaryMarshal(yy3900) - } else if !yym3901 && z.IsJSONHandle() { - z.EncJSONMarshal(yy3900) - } else { - z.EncFallback(yy3900) - } - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[9] { - yym3903 := z.EncBinary() - _ = yym3903 - if false { - } else { - r.EncodeInt(int64(x.Count)) - } - } else { - r.EncodeInt(0) - } - } else { - if yyq3870[9] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("count")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3904 := z.EncBinary() - _ = yym3904 - if false { - } else { - r.EncodeInt(int64(x.Count)) - } - } - } - if yyr3870 || yy2arr3870 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3870[10] { - yym3906 := z.EncBinary() - _ = yym3906 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Type)) - } - } else { - r.EncodeString(codecSelferC_UTF81234, "") - } - } else { - if yyq3870[10] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("type")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3907 := z.EncBinary() - _ = yym3907 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(x.Type)) + r.EncodeString(codecSelferC_UTF81234, string(x.Host)) } } } @@ -48877,29 +48629,480 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { } } +func (x *EventSource) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym3877 := z.DecBinary() + _ = yym3877 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct3878 := r.ContainerType() + if yyct3878 == codecSelferValueTypeMap1234 { + yyl3878 := r.ReadMapStart() + if yyl3878 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl3878, d) + } + } else if yyct3878 == codecSelferValueTypeArray1234 { + yyl3878 := r.ReadArrayStart() + if yyl3878 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl3878, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *EventSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3879Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3879Slc + var yyhl3879 bool = l >= 0 + for yyj3879 := 0; ; yyj3879++ { + if yyhl3879 { + if yyj3879 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys3879Slc = r.DecodeBytes(yys3879Slc, true, true) + yys3879 := string(yys3879Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys3879 { + case "component": + if r.TryDecodeAsNil() { + x.Component = "" + } else { + x.Component = string(r.DecodeString()) + } + case "host": + if r.TryDecodeAsNil() { + x.Host = "" + } else { + x.Host = string(r.DecodeString()) + } + default: + z.DecStructFieldNotFound(-1, yys3879) + } // end switch yys3879 + } // end for yyj3879 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *EventSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj3882 int + var yyb3882 bool + var yyhl3882 bool = l >= 0 + yyj3882++ + if yyhl3882 { + yyb3882 = yyj3882 > l + } else { + yyb3882 = r.CheckBreak() + } + if yyb3882 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Component = "" + } else { + x.Component = string(r.DecodeString()) + } + yyj3882++ + if yyhl3882 { + yyb3882 = yyj3882 > l + } else { + yyb3882 = r.CheckBreak() + } + if yyb3882 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Host = "" + } else { + x.Host = string(r.DecodeString()) + } + for { + yyj3882++ + if yyhl3882 { + yyb3882 = yyj3882 > l + } else { + yyb3882 = r.CheckBreak() + } + if yyb3882 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj3882-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym3885 := z.EncBinary() + _ = yym3885 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep3886 := !z.EncBinary() + yy2arr3886 := z.EncBasicHandle().StructToArray + var yyq3886 [11]bool + _, _, _ = yysep3886, yyq3886, yy2arr3886 + const yyr3886 bool = false + yyq3886[0] = x.Kind != "" + yyq3886[1] = x.APIVersion != "" + yyq3886[2] = true + yyq3886[3] = true + yyq3886[4] = x.Reason != "" + yyq3886[5] = x.Message != "" + yyq3886[6] = true + yyq3886[7] = true + yyq3886[8] = true + yyq3886[9] = x.Count != 0 + yyq3886[10] = x.Type != "" + var yynn3886 int + if yyr3886 || yy2arr3886 { + r.EncodeArrayStart(11) + } else { + yynn3886 = 0 + for _, b := range yyq3886 { + if b { + yynn3886++ + } + } + r.EncodeMapStart(yynn3886) + yynn3886 = 0 + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[0] { + yym3888 := z.EncBinary() + _ = yym3888 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3886[0] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("kind")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3889 := z.EncBinary() + _ = yym3889 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[1] { + yym3891 := z.EncBinary() + _ = yym3891 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3886[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3892 := z.EncBinary() + _ = yym3892 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[2] { + yy3894 := &x.ObjectMeta + yy3894.CodecEncodeSelf(e) + } else { + r.EncodeNil() + } + } else { + if yyq3886[2] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("metadata")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3895 := &x.ObjectMeta + yy3895.CodecEncodeSelf(e) + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[3] { + yy3897 := &x.InvolvedObject + yy3897.CodecEncodeSelf(e) + } else { + r.EncodeNil() + } + } else { + if yyq3886[3] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("involvedObject")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3898 := &x.InvolvedObject + yy3898.CodecEncodeSelf(e) + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[4] { + yym3900 := z.EncBinary() + _ = yym3900 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3886[4] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("reason")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3901 := z.EncBinary() + _ = yym3901 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Reason)) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[5] { + yym3903 := z.EncBinary() + _ = yym3903 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Message)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3886[5] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("message")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3904 := z.EncBinary() + _ = yym3904 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Message)) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[6] { + yy3906 := &x.Source + yy3906.CodecEncodeSelf(e) + } else { + r.EncodeNil() + } + } else { + if yyq3886[6] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("source")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3907 := &x.Source + yy3907.CodecEncodeSelf(e) + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[7] { + yy3909 := &x.FirstTimestamp + yym3910 := z.EncBinary() + _ = yym3910 + if false { + } else if z.HasExtensions() && z.EncExt(yy3909) { + } else if yym3910 { + z.EncBinaryMarshal(yy3909) + } else if !yym3910 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3909) + } else { + z.EncFallback(yy3909) + } + } else { + r.EncodeNil() + } + } else { + if yyq3886[7] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("firstTimestamp")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3911 := &x.FirstTimestamp + yym3912 := z.EncBinary() + _ = yym3912 + if false { + } else if z.HasExtensions() && z.EncExt(yy3911) { + } else if yym3912 { + z.EncBinaryMarshal(yy3911) + } else if !yym3912 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3911) + } else { + z.EncFallback(yy3911) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[8] { + yy3914 := &x.LastTimestamp + yym3915 := z.EncBinary() + _ = yym3915 + if false { + } else if z.HasExtensions() && z.EncExt(yy3914) { + } else if yym3915 { + z.EncBinaryMarshal(yy3914) + } else if !yym3915 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3914) + } else { + z.EncFallback(yy3914) + } + } else { + r.EncodeNil() + } + } else { + if yyq3886[8] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("lastTimestamp")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy3916 := &x.LastTimestamp + yym3917 := z.EncBinary() + _ = yym3917 + if false { + } else if z.HasExtensions() && z.EncExt(yy3916) { + } else if yym3917 { + z.EncBinaryMarshal(yy3916) + } else if !yym3917 && z.IsJSONHandle() { + z.EncJSONMarshal(yy3916) + } else { + z.EncFallback(yy3916) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[9] { + yym3919 := z.EncBinary() + _ = yym3919 + if false { + } else { + r.EncodeInt(int64(x.Count)) + } + } else { + r.EncodeInt(0) + } + } else { + if yyq3886[9] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("count")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3920 := z.EncBinary() + _ = yym3920 + if false { + } else { + r.EncodeInt(int64(x.Count)) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq3886[10] { + yym3922 := z.EncBinary() + _ = yym3922 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Type)) + } + } else { + r.EncodeString(codecSelferC_UTF81234, "") + } + } else { + if yyq3886[10] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("type")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yym3923 := z.EncBinary() + _ = yym3923 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(x.Type)) + } + } + } + if yyr3886 || yy2arr3886 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + func (x *Event) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3908 := z.DecBinary() - _ = yym3908 + yym3924 := z.DecBinary() + _ = yym3924 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3909 := r.ContainerType() - if yyct3909 == codecSelferValueTypeMap1234 { - yyl3909 := r.ReadMapStart() - if yyl3909 == 0 { + yyct3925 := r.ContainerType() + if yyct3925 == codecSelferValueTypeMap1234 { + yyl3925 := r.ReadMapStart() + if yyl3925 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3909, d) + x.codecDecodeSelfFromMap(yyl3925, d) } - } else if yyct3909 == codecSelferValueTypeArray1234 { - yyl3909 := r.ReadArrayStart() - if yyl3909 == 0 { + } else if yyct3925 == codecSelferValueTypeArray1234 { + yyl3925 := r.ReadArrayStart() + if yyl3925 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3909, d) + x.codecDecodeSelfFromArray(yyl3925, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -48911,12 +49114,12 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3910Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3910Slc - var yyhl3910 bool = l >= 0 - for yyj3910 := 0; ; yyj3910++ { - if yyhl3910 { - if yyj3910 >= l { + var yys3926Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3926Slc + var yyhl3926 bool = l >= 0 + for yyj3926 := 0; ; yyj3926++ { + if yyhl3926 { + if yyj3926 >= l { break } } else { @@ -48925,10 +49128,10 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3910Slc = r.DecodeBytes(yys3910Slc, true, true) - yys3910 := string(yys3910Slc) + yys3926Slc = r.DecodeBytes(yys3926Slc, true, true) + yys3926 := string(yys3926Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3910 { + switch yys3926 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -48945,15 +49148,15 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3913 := &x.ObjectMeta - yyv3913.CodecDecodeSelf(d) + yyv3929 := &x.ObjectMeta + yyv3929.CodecDecodeSelf(d) } case "involvedObject": if r.TryDecodeAsNil() { x.InvolvedObject = ObjectReference{} } else { - yyv3914 := &x.InvolvedObject - yyv3914.CodecDecodeSelf(d) + yyv3930 := &x.InvolvedObject + yyv3930.CodecDecodeSelf(d) } case "reason": if r.TryDecodeAsNil() { @@ -48971,41 +49174,41 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Source = EventSource{} } else { - yyv3917 := &x.Source - yyv3917.CodecDecodeSelf(d) + yyv3933 := &x.Source + yyv3933.CodecDecodeSelf(d) } case "firstTimestamp": if r.TryDecodeAsNil() { x.FirstTimestamp = pkg2_unversioned.Time{} } else { - yyv3918 := &x.FirstTimestamp - yym3919 := z.DecBinary() - _ = yym3919 + yyv3934 := &x.FirstTimestamp + yym3935 := z.DecBinary() + _ = yym3935 if false { - } else if z.HasExtensions() && z.DecExt(yyv3918) { - } else if yym3919 { - z.DecBinaryUnmarshal(yyv3918) - } else if !yym3919 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3918) + } else if z.HasExtensions() && z.DecExt(yyv3934) { + } else if yym3935 { + z.DecBinaryUnmarshal(yyv3934) + } else if !yym3935 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3934) } else { - z.DecFallback(yyv3918, false) + z.DecFallback(yyv3934, false) } } case "lastTimestamp": if r.TryDecodeAsNil() { x.LastTimestamp = pkg2_unversioned.Time{} } else { - yyv3920 := &x.LastTimestamp - yym3921 := z.DecBinary() - _ = yym3921 + yyv3936 := &x.LastTimestamp + yym3937 := z.DecBinary() + _ = yym3937 if false { - } else if z.HasExtensions() && z.DecExt(yyv3920) { - } else if yym3921 { - z.DecBinaryUnmarshal(yyv3920) - } else if !yym3921 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3920) + } else if z.HasExtensions() && z.DecExt(yyv3936) { + } else if yym3937 { + z.DecBinaryUnmarshal(yyv3936) + } else if !yym3937 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3936) } else { - z.DecFallback(yyv3920, false) + z.DecFallback(yyv3936, false) } } case "count": @@ -49021,9 +49224,9 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Type = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys3910) - } // end switch yys3910 - } // end for yyj3910 + z.DecStructFieldNotFound(-1, yys3926) + } // end switch yys3926 + } // end for yyj3926 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -49031,16 +49234,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3924 int - var yyb3924 bool - var yyhl3924 bool = l >= 0 - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + var yyj3940 int + var yyb3940 bool + var yyhl3940 bool = l >= 0 + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49050,13 +49253,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49066,13 +49269,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49080,16 +49283,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv3927 := &x.ObjectMeta - yyv3927.CodecDecodeSelf(d) + yyv3943 := &x.ObjectMeta + yyv3943.CodecDecodeSelf(d) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49097,16 +49300,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.InvolvedObject = ObjectReference{} } else { - yyv3928 := &x.InvolvedObject - yyv3928.CodecDecodeSelf(d) + yyv3944 := &x.InvolvedObject + yyv3944.CodecDecodeSelf(d) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49116,13 +49319,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Reason = string(r.DecodeString()) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49132,13 +49335,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Message = string(r.DecodeString()) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49146,16 +49349,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Source = EventSource{} } else { - yyv3931 := &x.Source - yyv3931.CodecDecodeSelf(d) + yyv3947 := &x.Source + yyv3947.CodecDecodeSelf(d) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49163,26 +49366,26 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.FirstTimestamp = pkg2_unversioned.Time{} } else { - yyv3932 := &x.FirstTimestamp - yym3933 := z.DecBinary() - _ = yym3933 + yyv3948 := &x.FirstTimestamp + yym3949 := z.DecBinary() + _ = yym3949 if false { - } else if z.HasExtensions() && z.DecExt(yyv3932) { - } else if yym3933 { - z.DecBinaryUnmarshal(yyv3932) - } else if !yym3933 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3932) + } else if z.HasExtensions() && z.DecExt(yyv3948) { + } else if yym3949 { + z.DecBinaryUnmarshal(yyv3948) + } else if !yym3949 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3948) } else { - z.DecFallback(yyv3932, false) + z.DecFallback(yyv3948, false) } } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49190,26 +49393,26 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.LastTimestamp = pkg2_unversioned.Time{} } else { - yyv3934 := &x.LastTimestamp - yym3935 := z.DecBinary() - _ = yym3935 + yyv3950 := &x.LastTimestamp + yym3951 := z.DecBinary() + _ = yym3951 if false { - } else if z.HasExtensions() && z.DecExt(yyv3934) { - } else if yym3935 { - z.DecBinaryUnmarshal(yyv3934) - } else if !yym3935 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv3934) + } else if z.HasExtensions() && z.DecExt(yyv3950) { + } else if yym3951 { + z.DecBinaryUnmarshal(yyv3950) + } else if !yym3951 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv3950) } else { - z.DecFallback(yyv3934, false) + z.DecFallback(yyv3950, false) } } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49219,13 +49422,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Count = int32(r.DecodeInt(32)) } - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49236,17 +49439,17 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Type = string(r.DecodeString()) } for { - yyj3924++ - if yyhl3924 { - yyb3924 = yyj3924 > l + yyj3940++ + if yyhl3940 { + yyb3940 = yyj3940 > l } else { - yyb3924 = r.CheckBreak() + yyb3940 = r.CheckBreak() } - if yyb3924 { + if yyb3940 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3924-1, "") + z.DecStructFieldNotFound(yyj3940-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -49258,37 +49461,37 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3938 := z.EncBinary() - _ = yym3938 + yym3954 := z.EncBinary() + _ = yym3954 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3939 := !z.EncBinary() - yy2arr3939 := z.EncBasicHandle().StructToArray - var yyq3939 [4]bool - _, _, _ = yysep3939, yyq3939, yy2arr3939 - const yyr3939 bool = false - yyq3939[0] = x.Kind != "" - yyq3939[1] = x.APIVersion != "" - yyq3939[2] = true - var yynn3939 int - if yyr3939 || yy2arr3939 { + yysep3955 := !z.EncBinary() + yy2arr3955 := z.EncBasicHandle().StructToArray + var yyq3955 [4]bool + _, _, _ = yysep3955, yyq3955, yy2arr3955 + const yyr3955 bool = false + yyq3955[0] = x.Kind != "" + yyq3955[1] = x.APIVersion != "" + yyq3955[2] = true + var yynn3955 int + if yyr3955 || yy2arr3955 { r.EncodeArrayStart(4) } else { - yynn3939 = 1 - for _, b := range yyq3939 { + yynn3955 = 1 + for _, b := range yyq3955 { if b { - yynn3939++ + yynn3955++ } } - r.EncodeMapStart(yynn3939) - yynn3939 = 0 + r.EncodeMapStart(yynn3955) + yynn3955 = 0 } - if yyr3939 || yy2arr3939 { + if yyr3955 || yy2arr3955 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3939[0] { - yym3941 := z.EncBinary() - _ = yym3941 + if yyq3955[0] { + yym3957 := z.EncBinary() + _ = yym3957 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -49297,23 +49500,23 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3939[0] { + if yyq3955[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3942 := z.EncBinary() - _ = yym3942 + yym3958 := z.EncBinary() + _ = yym3958 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3939 || yy2arr3939 { + if yyr3955 || yy2arr3955 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3939[1] { - yym3944 := z.EncBinary() - _ = yym3944 + if yyq3955[1] { + yym3960 := z.EncBinary() + _ = yym3960 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -49322,54 +49525,54 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3939[1] { + if yyq3955[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3945 := z.EncBinary() - _ = yym3945 + yym3961 := z.EncBinary() + _ = yym3961 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3939 || yy2arr3939 { + if yyr3955 || yy2arr3955 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3939[2] { - yy3947 := &x.ListMeta - yym3948 := z.EncBinary() - _ = yym3948 + if yyq3955[2] { + yy3963 := &x.ListMeta + yym3964 := z.EncBinary() + _ = yym3964 if false { - } else if z.HasExtensions() && z.EncExt(yy3947) { + } else if z.HasExtensions() && z.EncExt(yy3963) { } else { - z.EncFallback(yy3947) + z.EncFallback(yy3963) } } else { r.EncodeNil() } } else { - if yyq3939[2] { + if yyq3955[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3949 := &x.ListMeta - yym3950 := z.EncBinary() - _ = yym3950 + yy3965 := &x.ListMeta + yym3966 := z.EncBinary() + _ = yym3966 if false { - } else if z.HasExtensions() && z.EncExt(yy3949) { + } else if z.HasExtensions() && z.EncExt(yy3965) { } else { - z.EncFallback(yy3949) + z.EncFallback(yy3965) } } } - if yyr3939 || yy2arr3939 { + if yyr3955 || yy2arr3955 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym3952 := z.EncBinary() - _ = yym3952 + yym3968 := z.EncBinary() + _ = yym3968 if false { } else { h.encSliceEvent(([]Event)(x.Items), e) @@ -49382,15 +49585,15 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym3953 := z.EncBinary() - _ = yym3953 + yym3969 := z.EncBinary() + _ = yym3969 if false { } else { h.encSliceEvent(([]Event)(x.Items), e) } } } - if yyr3939 || yy2arr3939 { + if yyr3955 || yy2arr3955 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -49403,25 +49606,25 @@ func (x *EventList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3954 := z.DecBinary() - _ = yym3954 + yym3970 := z.DecBinary() + _ = yym3970 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3955 := r.ContainerType() - if yyct3955 == codecSelferValueTypeMap1234 { - yyl3955 := r.ReadMapStart() - if yyl3955 == 0 { + yyct3971 := r.ContainerType() + if yyct3971 == codecSelferValueTypeMap1234 { + yyl3971 := r.ReadMapStart() + if yyl3971 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3955, d) + x.codecDecodeSelfFromMap(yyl3971, d) } - } else if yyct3955 == codecSelferValueTypeArray1234 { - yyl3955 := r.ReadArrayStart() - if yyl3955 == 0 { + } else if yyct3971 == codecSelferValueTypeArray1234 { + yyl3971 := r.ReadArrayStart() + if yyl3971 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3955, d) + x.codecDecodeSelfFromArray(yyl3971, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -49433,12 +49636,12 @@ func (x *EventList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3956Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3956Slc - var yyhl3956 bool = l >= 0 - for yyj3956 := 0; ; yyj3956++ { - if yyhl3956 { - if yyj3956 >= l { + var yys3972Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3972Slc + var yyhl3972 bool = l >= 0 + for yyj3972 := 0; ; yyj3972++ { + if yyhl3972 { + if yyj3972 >= l { break } } else { @@ -49447,10 +49650,10 @@ func (x *EventList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3956Slc = r.DecodeBytes(yys3956Slc, true, true) - yys3956 := string(yys3956Slc) + yys3972Slc = r.DecodeBytes(yys3972Slc, true, true) + yys3972 := string(yys3972Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3956 { + switch yys3972 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -49467,31 +49670,31 @@ func (x *EventList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3959 := &x.ListMeta - yym3960 := z.DecBinary() - _ = yym3960 + yyv3975 := &x.ListMeta + yym3976 := z.DecBinary() + _ = yym3976 if false { - } else if z.HasExtensions() && z.DecExt(yyv3959) { + } else if z.HasExtensions() && z.DecExt(yyv3975) { } else { - z.DecFallback(yyv3959, false) + z.DecFallback(yyv3975, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3961 := &x.Items - yym3962 := z.DecBinary() - _ = yym3962 + yyv3977 := &x.Items + yym3978 := z.DecBinary() + _ = yym3978 if false { } else { - h.decSliceEvent((*[]Event)(yyv3961), d) + h.decSliceEvent((*[]Event)(yyv3977), d) } } default: - z.DecStructFieldNotFound(-1, yys3956) - } // end switch yys3956 - } // end for yyj3956 + z.DecStructFieldNotFound(-1, yys3972) + } // end switch yys3972 + } // end for yyj3972 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -49499,16 +49702,16 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3963 int - var yyb3963 bool - var yyhl3963 bool = l >= 0 - yyj3963++ - if yyhl3963 { - yyb3963 = yyj3963 > l + var yyj3979 int + var yyb3979 bool + var yyhl3979 bool = l >= 0 + yyj3979++ + if yyhl3979 { + yyb3979 = yyj3979 > l } else { - yyb3963 = r.CheckBreak() + yyb3979 = r.CheckBreak() } - if yyb3963 { + if yyb3979 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49518,13 +49721,13 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3963++ - if yyhl3963 { - yyb3963 = yyj3963 > l + yyj3979++ + if yyhl3979 { + yyb3979 = yyj3979 > l } else { - yyb3963 = r.CheckBreak() + yyb3979 = r.CheckBreak() } - if yyb3963 { + if yyb3979 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49534,13 +49737,13 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3963++ - if yyhl3963 { - yyb3963 = yyj3963 > l + yyj3979++ + if yyhl3979 { + yyb3979 = yyj3979 > l } else { - yyb3963 = r.CheckBreak() + yyb3979 = r.CheckBreak() } - if yyb3963 { + if yyb3979 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49548,22 +49751,22 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3966 := &x.ListMeta - yym3967 := z.DecBinary() - _ = yym3967 + yyv3982 := &x.ListMeta + yym3983 := z.DecBinary() + _ = yym3983 if false { - } else if z.HasExtensions() && z.DecExt(yyv3966) { + } else if z.HasExtensions() && z.DecExt(yyv3982) { } else { - z.DecFallback(yyv3966, false) + z.DecFallback(yyv3982, false) } } - yyj3963++ - if yyhl3963 { - yyb3963 = yyj3963 > l + yyj3979++ + if yyhl3979 { + yyb3979 = yyj3979 > l } else { - yyb3963 = r.CheckBreak() + yyb3979 = r.CheckBreak() } - if yyb3963 { + if yyb3979 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49571,26 +49774,26 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3968 := &x.Items - yym3969 := z.DecBinary() - _ = yym3969 + yyv3984 := &x.Items + yym3985 := z.DecBinary() + _ = yym3985 if false { } else { - h.decSliceEvent((*[]Event)(yyv3968), d) + h.decSliceEvent((*[]Event)(yyv3984), d) } } for { - yyj3963++ - if yyhl3963 { - yyb3963 = yyj3963 > l + yyj3979++ + if yyhl3979 { + yyb3979 = yyj3979 > l } else { - yyb3963 = r.CheckBreak() + yyb3979 = r.CheckBreak() } - if yyb3963 { + if yyb3979 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3963-1, "") + z.DecStructFieldNotFound(yyj3979-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -49602,37 +49805,37 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym3970 := z.EncBinary() - _ = yym3970 + yym3986 := z.EncBinary() + _ = yym3986 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep3971 := !z.EncBinary() - yy2arr3971 := z.EncBasicHandle().StructToArray - var yyq3971 [4]bool - _, _, _ = yysep3971, yyq3971, yy2arr3971 - const yyr3971 bool = false - yyq3971[0] = x.Kind != "" - yyq3971[1] = x.APIVersion != "" - yyq3971[2] = true - var yynn3971 int - if yyr3971 || yy2arr3971 { + yysep3987 := !z.EncBinary() + yy2arr3987 := z.EncBasicHandle().StructToArray + var yyq3987 [4]bool + _, _, _ = yysep3987, yyq3987, yy2arr3987 + const yyr3987 bool = false + yyq3987[0] = x.Kind != "" + yyq3987[1] = x.APIVersion != "" + yyq3987[2] = true + var yynn3987 int + if yyr3987 || yy2arr3987 { r.EncodeArrayStart(4) } else { - yynn3971 = 1 - for _, b := range yyq3971 { + yynn3987 = 1 + for _, b := range yyq3987 { if b { - yynn3971++ + yynn3987++ } } - r.EncodeMapStart(yynn3971) - yynn3971 = 0 + r.EncodeMapStart(yynn3987) + yynn3987 = 0 } - if yyr3971 || yy2arr3971 { + if yyr3987 || yy2arr3987 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3971[0] { - yym3973 := z.EncBinary() - _ = yym3973 + if yyq3987[0] { + yym3989 := z.EncBinary() + _ = yym3989 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -49641,23 +49844,23 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3971[0] { + if yyq3987[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3974 := z.EncBinary() - _ = yym3974 + yym3990 := z.EncBinary() + _ = yym3990 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr3971 || yy2arr3971 { + if yyr3987 || yy2arr3987 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3971[1] { - yym3976 := z.EncBinary() - _ = yym3976 + if yyq3987[1] { + yym3992 := z.EncBinary() + _ = yym3992 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -49666,54 +49869,54 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq3971[1] { + if yyq3987[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym3977 := z.EncBinary() - _ = yym3977 + yym3993 := z.EncBinary() + _ = yym3993 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr3971 || yy2arr3971 { + if yyr3987 || yy2arr3987 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq3971[2] { - yy3979 := &x.ListMeta - yym3980 := z.EncBinary() - _ = yym3980 + if yyq3987[2] { + yy3995 := &x.ListMeta + yym3996 := z.EncBinary() + _ = yym3996 if false { - } else if z.HasExtensions() && z.EncExt(yy3979) { + } else if z.HasExtensions() && z.EncExt(yy3995) { } else { - z.EncFallback(yy3979) + z.EncFallback(yy3995) } } else { r.EncodeNil() } } else { - if yyq3971[2] { + if yyq3987[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy3981 := &x.ListMeta - yym3982 := z.EncBinary() - _ = yym3982 + yy3997 := &x.ListMeta + yym3998 := z.EncBinary() + _ = yym3998 if false { - } else if z.HasExtensions() && z.EncExt(yy3981) { + } else if z.HasExtensions() && z.EncExt(yy3997) { } else { - z.EncFallback(yy3981) + z.EncFallback(yy3997) } } } - if yyr3971 || yy2arr3971 { + if yyr3987 || yy2arr3987 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym3984 := z.EncBinary() - _ = yym3984 + yym4000 := z.EncBinary() + _ = yym4000 if false { } else { h.encSliceruntime_Object(([]pkg7_runtime.Object)(x.Items), e) @@ -49726,15 +49929,15 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym3985 := z.EncBinary() - _ = yym3985 + yym4001 := z.EncBinary() + _ = yym4001 if false { } else { h.encSliceruntime_Object(([]pkg7_runtime.Object)(x.Items), e) } } } - if yyr3971 || yy2arr3971 { + if yyr3987 || yy2arr3987 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -49747,25 +49950,25 @@ func (x *List) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym3986 := z.DecBinary() - _ = yym3986 + yym4002 := z.DecBinary() + _ = yym4002 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct3987 := r.ContainerType() - if yyct3987 == codecSelferValueTypeMap1234 { - yyl3987 := r.ReadMapStart() - if yyl3987 == 0 { + yyct4003 := r.ContainerType() + if yyct4003 == codecSelferValueTypeMap1234 { + yyl4003 := r.ReadMapStart() + if yyl4003 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl3987, d) + x.codecDecodeSelfFromMap(yyl4003, d) } - } else if yyct3987 == codecSelferValueTypeArray1234 { - yyl3987 := r.ReadArrayStart() - if yyl3987 == 0 { + } else if yyct4003 == codecSelferValueTypeArray1234 { + yyl4003 := r.ReadArrayStart() + if yyl4003 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl3987, d) + x.codecDecodeSelfFromArray(yyl4003, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -49777,12 +49980,12 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys3988Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys3988Slc - var yyhl3988 bool = l >= 0 - for yyj3988 := 0; ; yyj3988++ { - if yyhl3988 { - if yyj3988 >= l { + var yys4004Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4004Slc + var yyhl4004 bool = l >= 0 + for yyj4004 := 0; ; yyj4004++ { + if yyhl4004 { + if yyj4004 >= l { break } } else { @@ -49791,10 +49994,10 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys3988Slc = r.DecodeBytes(yys3988Slc, true, true) - yys3988 := string(yys3988Slc) + yys4004Slc = r.DecodeBytes(yys4004Slc, true, true) + yys4004 := string(yys4004Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys3988 { + switch yys4004 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -49811,31 +50014,31 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3991 := &x.ListMeta - yym3992 := z.DecBinary() - _ = yym3992 + yyv4007 := &x.ListMeta + yym4008 := z.DecBinary() + _ = yym4008 if false { - } else if z.HasExtensions() && z.DecExt(yyv3991) { + } else if z.HasExtensions() && z.DecExt(yyv4007) { } else { - z.DecFallback(yyv3991, false) + z.DecFallback(yyv4007, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv3993 := &x.Items - yym3994 := z.DecBinary() - _ = yym3994 + yyv4009 := &x.Items + yym4010 := z.DecBinary() + _ = yym4010 if false { } else { - h.decSliceruntime_Object((*[]pkg7_runtime.Object)(yyv3993), d) + h.decSliceruntime_Object((*[]pkg7_runtime.Object)(yyv4009), d) } } default: - z.DecStructFieldNotFound(-1, yys3988) - } // end switch yys3988 - } // end for yyj3988 + z.DecStructFieldNotFound(-1, yys4004) + } // end switch yys4004 + } // end for yyj4004 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -49843,16 +50046,16 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj3995 int - var yyb3995 bool - var yyhl3995 bool = l >= 0 - yyj3995++ - if yyhl3995 { - yyb3995 = yyj3995 > l + var yyj4011 int + var yyb4011 bool + var yyhl4011 bool = l >= 0 + yyj4011++ + if yyhl4011 { + yyb4011 = yyj4011 > l } else { - yyb3995 = r.CheckBreak() + yyb4011 = r.CheckBreak() } - if yyb3995 { + if yyb4011 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49862,13 +50065,13 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj3995++ - if yyhl3995 { - yyb3995 = yyj3995 > l + yyj4011++ + if yyhl4011 { + yyb4011 = yyj4011 > l } else { - yyb3995 = r.CheckBreak() + yyb4011 = r.CheckBreak() } - if yyb3995 { + if yyb4011 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49878,13 +50081,13 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj3995++ - if yyhl3995 { - yyb3995 = yyj3995 > l + yyj4011++ + if yyhl4011 { + yyb4011 = yyj4011 > l } else { - yyb3995 = r.CheckBreak() + yyb4011 = r.CheckBreak() } - if yyb3995 { + if yyb4011 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49892,22 +50095,22 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv3998 := &x.ListMeta - yym3999 := z.DecBinary() - _ = yym3999 + yyv4014 := &x.ListMeta + yym4015 := z.DecBinary() + _ = yym4015 if false { - } else if z.HasExtensions() && z.DecExt(yyv3998) { + } else if z.HasExtensions() && z.DecExt(yyv4014) { } else { - z.DecFallback(yyv3998, false) + z.DecFallback(yyv4014, false) } } - yyj3995++ - if yyhl3995 { - yyb3995 = yyj3995 > l + yyj4011++ + if yyhl4011 { + yyb4011 = yyj4011 > l } else { - yyb3995 = r.CheckBreak() + yyb4011 = r.CheckBreak() } - if yyb3995 { + if yyb4011 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -49915,26 +50118,26 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4000 := &x.Items - yym4001 := z.DecBinary() - _ = yym4001 + yyv4016 := &x.Items + yym4017 := z.DecBinary() + _ = yym4017 if false { } else { - h.decSliceruntime_Object((*[]pkg7_runtime.Object)(yyv4000), d) + h.decSliceruntime_Object((*[]pkg7_runtime.Object)(yyv4016), d) } } for { - yyj3995++ - if yyhl3995 { - yyb3995 = yyj3995 > l + yyj4011++ + if yyhl4011 { + yyb4011 = yyj4011 > l } else { - yyb3995 = r.CheckBreak() + yyb4011 = r.CheckBreak() } - if yyb3995 { + if yyb4011 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj3995-1, "") + z.DecStructFieldNotFound(yyj4011-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -49943,8 +50146,8 @@ func (x LimitType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym4002 := z.EncBinary() - _ = yym4002 + yym4018 := z.EncBinary() + _ = yym4018 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -49956,8 +50159,8 @@ func (x *LimitType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4003 := z.DecBinary() - _ = yym4003 + yym4019 := z.DecBinary() + _ = yym4019 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -49972,53 +50175,53 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4004 := z.EncBinary() - _ = yym4004 + yym4020 := z.EncBinary() + _ = yym4020 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4005 := !z.EncBinary() - yy2arr4005 := z.EncBasicHandle().StructToArray - var yyq4005 [6]bool - _, _, _ = yysep4005, yyq4005, yy2arr4005 - const yyr4005 bool = false - yyq4005[0] = x.Type != "" - yyq4005[1] = len(x.Max) != 0 - yyq4005[2] = len(x.Min) != 0 - yyq4005[3] = len(x.Default) != 0 - yyq4005[4] = len(x.DefaultRequest) != 0 - yyq4005[5] = len(x.MaxLimitRequestRatio) != 0 - var yynn4005 int - if yyr4005 || yy2arr4005 { + yysep4021 := !z.EncBinary() + yy2arr4021 := z.EncBasicHandle().StructToArray + var yyq4021 [6]bool + _, _, _ = yysep4021, yyq4021, yy2arr4021 + const yyr4021 bool = false + yyq4021[0] = x.Type != "" + yyq4021[1] = len(x.Max) != 0 + yyq4021[2] = len(x.Min) != 0 + yyq4021[3] = len(x.Default) != 0 + yyq4021[4] = len(x.DefaultRequest) != 0 + yyq4021[5] = len(x.MaxLimitRequestRatio) != 0 + var yynn4021 int + if yyr4021 || yy2arr4021 { r.EncodeArrayStart(6) } else { - yynn4005 = 0 - for _, b := range yyq4005 { + yynn4021 = 0 + for _, b := range yyq4021 { if b { - yynn4005++ + yynn4021++ } } - r.EncodeMapStart(yynn4005) - yynn4005 = 0 + r.EncodeMapStart(yynn4021) + yynn4021 = 0 } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4005[0] { + if yyq4021[0] { x.Type.CodecEncodeSelf(e) } else { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4005[0] { + if yyq4021[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("type")) z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Type.CodecEncodeSelf(e) } } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4005[1] { + if yyq4021[1] { if x.Max == nil { r.EncodeNil() } else { @@ -50028,7 +50231,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4005[1] { + if yyq4021[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("max")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -50039,9 +50242,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4005[2] { + if yyq4021[2] { if x.Min == nil { r.EncodeNil() } else { @@ -50051,7 +50254,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4005[2] { + if yyq4021[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("min")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -50062,9 +50265,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4005[3] { + if yyq4021[3] { if x.Default == nil { r.EncodeNil() } else { @@ -50074,7 +50277,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4005[3] { + if yyq4021[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("default")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -50085,9 +50288,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4005[4] { + if yyq4021[4] { if x.DefaultRequest == nil { r.EncodeNil() } else { @@ -50097,7 +50300,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4005[4] { + if yyq4021[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("defaultRequest")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -50108,9 +50311,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4005[5] { + if yyq4021[5] { if x.MaxLimitRequestRatio == nil { r.EncodeNil() } else { @@ -50120,7 +50323,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4005[5] { + if yyq4021[5] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("maxLimitRequestRatio")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -50131,7 +50334,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4005 || yy2arr4005 { + if yyr4021 || yy2arr4021 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -50144,25 +50347,25 @@ func (x *LimitRangeItem) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4012 := z.DecBinary() - _ = yym4012 + yym4028 := z.DecBinary() + _ = yym4028 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4013 := r.ContainerType() - if yyct4013 == codecSelferValueTypeMap1234 { - yyl4013 := r.ReadMapStart() - if yyl4013 == 0 { + yyct4029 := r.ContainerType() + if yyct4029 == codecSelferValueTypeMap1234 { + yyl4029 := r.ReadMapStart() + if yyl4029 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4013, d) + x.codecDecodeSelfFromMap(yyl4029, d) } - } else if yyct4013 == codecSelferValueTypeArray1234 { - yyl4013 := r.ReadArrayStart() - if yyl4013 == 0 { + } else if yyct4029 == codecSelferValueTypeArray1234 { + yyl4029 := r.ReadArrayStart() + if yyl4029 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4013, d) + x.codecDecodeSelfFromArray(yyl4029, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -50174,12 +50377,12 @@ func (x *LimitRangeItem) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4014Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4014Slc - var yyhl4014 bool = l >= 0 - for yyj4014 := 0; ; yyj4014++ { - if yyhl4014 { - if yyj4014 >= l { + var yys4030Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4030Slc + var yyhl4030 bool = l >= 0 + for yyj4030 := 0; ; yyj4030++ { + if yyhl4030 { + if yyj4030 >= l { break } } else { @@ -50188,10 +50391,10 @@ func (x *LimitRangeItem) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4014Slc = r.DecodeBytes(yys4014Slc, true, true) - yys4014 := string(yys4014Slc) + yys4030Slc = r.DecodeBytes(yys4030Slc, true, true) + yys4030 := string(yys4030Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4014 { + switch yys4030 { case "type": if r.TryDecodeAsNil() { x.Type = "" @@ -50202,41 +50405,41 @@ func (x *LimitRangeItem) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Max = nil } else { - yyv4016 := &x.Max - yyv4016.CodecDecodeSelf(d) + yyv4032 := &x.Max + yyv4032.CodecDecodeSelf(d) } case "min": if r.TryDecodeAsNil() { x.Min = nil } else { - yyv4017 := &x.Min - yyv4017.CodecDecodeSelf(d) + yyv4033 := &x.Min + yyv4033.CodecDecodeSelf(d) } case "default": if r.TryDecodeAsNil() { x.Default = nil } else { - yyv4018 := &x.Default - yyv4018.CodecDecodeSelf(d) + yyv4034 := &x.Default + yyv4034.CodecDecodeSelf(d) } case "defaultRequest": if r.TryDecodeAsNil() { x.DefaultRequest = nil } else { - yyv4019 := &x.DefaultRequest - yyv4019.CodecDecodeSelf(d) + yyv4035 := &x.DefaultRequest + yyv4035.CodecDecodeSelf(d) } case "maxLimitRequestRatio": if r.TryDecodeAsNil() { x.MaxLimitRequestRatio = nil } else { - yyv4020 := &x.MaxLimitRequestRatio - yyv4020.CodecDecodeSelf(d) + yyv4036 := &x.MaxLimitRequestRatio + yyv4036.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys4014) - } // end switch yys4014 - } // end for yyj4014 + z.DecStructFieldNotFound(-1, yys4030) + } // end switch yys4030 + } // end for yyj4030 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -50244,16 +50447,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4021 int - var yyb4021 bool - var yyhl4021 bool = l >= 0 - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + var yyj4037 int + var yyb4037 bool + var yyhl4037 bool = l >= 0 + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50263,13 +50466,13 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Type = LimitType(r.DecodeString()) } - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50277,16 +50480,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Max = nil } else { - yyv4023 := &x.Max - yyv4023.CodecDecodeSelf(d) + yyv4039 := &x.Max + yyv4039.CodecDecodeSelf(d) } - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50294,16 +50497,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Min = nil } else { - yyv4024 := &x.Min - yyv4024.CodecDecodeSelf(d) + yyv4040 := &x.Min + yyv4040.CodecDecodeSelf(d) } - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50311,16 +50514,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Default = nil } else { - yyv4025 := &x.Default - yyv4025.CodecDecodeSelf(d) + yyv4041 := &x.Default + yyv4041.CodecDecodeSelf(d) } - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50328,16 +50531,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.DefaultRequest = nil } else { - yyv4026 := &x.DefaultRequest - yyv4026.CodecDecodeSelf(d) + yyv4042 := &x.DefaultRequest + yyv4042.CodecDecodeSelf(d) } - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50345,21 +50548,21 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.MaxLimitRequestRatio = nil } else { - yyv4027 := &x.MaxLimitRequestRatio - yyv4027.CodecDecodeSelf(d) + yyv4043 := &x.MaxLimitRequestRatio + yyv4043.CodecDecodeSelf(d) } for { - yyj4021++ - if yyhl4021 { - yyb4021 = yyj4021 > l + yyj4037++ + if yyhl4037 { + yyb4037 = yyj4037 > l } else { - yyb4021 = r.CheckBreak() + yyb4037 = r.CheckBreak() } - if yyb4021 { + if yyb4037 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4021-1, "") + z.DecStructFieldNotFound(yyj4037-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -50371,36 +50574,36 @@ func (x *LimitRangeSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4028 := z.EncBinary() - _ = yym4028 + yym4044 := z.EncBinary() + _ = yym4044 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4029 := !z.EncBinary() - yy2arr4029 := z.EncBasicHandle().StructToArray - var yyq4029 [1]bool - _, _, _ = yysep4029, yyq4029, yy2arr4029 - const yyr4029 bool = false - var yynn4029 int - if yyr4029 || yy2arr4029 { + yysep4045 := !z.EncBinary() + yy2arr4045 := z.EncBasicHandle().StructToArray + var yyq4045 [1]bool + _, _, _ = yysep4045, yyq4045, yy2arr4045 + const yyr4045 bool = false + var yynn4045 int + if yyr4045 || yy2arr4045 { r.EncodeArrayStart(1) } else { - yynn4029 = 1 - for _, b := range yyq4029 { + yynn4045 = 1 + for _, b := range yyq4045 { if b { - yynn4029++ + yynn4045++ } } - r.EncodeMapStart(yynn4029) - yynn4029 = 0 + r.EncodeMapStart(yynn4045) + yynn4045 = 0 } - if yyr4029 || yy2arr4029 { + if yyr4045 || yy2arr4045 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Limits == nil { r.EncodeNil() } else { - yym4031 := z.EncBinary() - _ = yym4031 + yym4047 := z.EncBinary() + _ = yym4047 if false { } else { h.encSliceLimitRangeItem(([]LimitRangeItem)(x.Limits), e) @@ -50413,15 +50616,15 @@ func (x *LimitRangeSpec) CodecEncodeSelf(e *codec1978.Encoder) { if x.Limits == nil { r.EncodeNil() } else { - yym4032 := z.EncBinary() - _ = yym4032 + yym4048 := z.EncBinary() + _ = yym4048 if false { } else { h.encSliceLimitRangeItem(([]LimitRangeItem)(x.Limits), e) } } } - if yyr4029 || yy2arr4029 { + if yyr4045 || yy2arr4045 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -50434,25 +50637,25 @@ func (x *LimitRangeSpec) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4033 := z.DecBinary() - _ = yym4033 + yym4049 := z.DecBinary() + _ = yym4049 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4034 := r.ContainerType() - if yyct4034 == codecSelferValueTypeMap1234 { - yyl4034 := r.ReadMapStart() - if yyl4034 == 0 { + yyct4050 := r.ContainerType() + if yyct4050 == codecSelferValueTypeMap1234 { + yyl4050 := r.ReadMapStart() + if yyl4050 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4034, d) + x.codecDecodeSelfFromMap(yyl4050, d) } - } else if yyct4034 == codecSelferValueTypeArray1234 { - yyl4034 := r.ReadArrayStart() - if yyl4034 == 0 { + } else if yyct4050 == codecSelferValueTypeArray1234 { + yyl4050 := r.ReadArrayStart() + if yyl4050 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4034, d) + x.codecDecodeSelfFromArray(yyl4050, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -50464,12 +50667,12 @@ func (x *LimitRangeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4035Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4035Slc - var yyhl4035 bool = l >= 0 - for yyj4035 := 0; ; yyj4035++ { - if yyhl4035 { - if yyj4035 >= l { + var yys4051Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4051Slc + var yyhl4051 bool = l >= 0 + for yyj4051 := 0; ; yyj4051++ { + if yyhl4051 { + if yyj4051 >= l { break } } else { @@ -50478,26 +50681,26 @@ func (x *LimitRangeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4035Slc = r.DecodeBytes(yys4035Slc, true, true) - yys4035 := string(yys4035Slc) + yys4051Slc = r.DecodeBytes(yys4051Slc, true, true) + yys4051 := string(yys4051Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4035 { + switch yys4051 { case "limits": if r.TryDecodeAsNil() { x.Limits = nil } else { - yyv4036 := &x.Limits - yym4037 := z.DecBinary() - _ = yym4037 + yyv4052 := &x.Limits + yym4053 := z.DecBinary() + _ = yym4053 if false { } else { - h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4036), d) + h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4052), d) } } default: - z.DecStructFieldNotFound(-1, yys4035) - } // end switch yys4035 - } // end for yyj4035 + z.DecStructFieldNotFound(-1, yys4051) + } // end switch yys4051 + } // end for yyj4051 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -50505,16 +50708,16 @@ func (x *LimitRangeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4038 int - var yyb4038 bool - var yyhl4038 bool = l >= 0 - yyj4038++ - if yyhl4038 { - yyb4038 = yyj4038 > l + var yyj4054 int + var yyb4054 bool + var yyhl4054 bool = l >= 0 + yyj4054++ + if yyhl4054 { + yyb4054 = yyj4054 > l } else { - yyb4038 = r.CheckBreak() + yyb4054 = r.CheckBreak() } - if yyb4038 { + if yyb4054 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50522,26 +50725,26 @@ func (x *LimitRangeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Limits = nil } else { - yyv4039 := &x.Limits - yym4040 := z.DecBinary() - _ = yym4040 + yyv4055 := &x.Limits + yym4056 := z.DecBinary() + _ = yym4056 if false { } else { - h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4039), d) + h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4055), d) } } for { - yyj4038++ - if yyhl4038 { - yyb4038 = yyj4038 > l + yyj4054++ + if yyhl4054 { + yyb4054 = yyj4054 > l } else { - yyb4038 = r.CheckBreak() + yyb4054 = r.CheckBreak() } - if yyb4038 { + if yyb4054 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4038-1, "") + z.DecStructFieldNotFound(yyj4054-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -50553,38 +50756,38 @@ func (x *LimitRange) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4041 := z.EncBinary() - _ = yym4041 + yym4057 := z.EncBinary() + _ = yym4057 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4042 := !z.EncBinary() - yy2arr4042 := z.EncBasicHandle().StructToArray - var yyq4042 [4]bool - _, _, _ = yysep4042, yyq4042, yy2arr4042 - const yyr4042 bool = false - yyq4042[0] = x.Kind != "" - yyq4042[1] = x.APIVersion != "" - yyq4042[2] = true - yyq4042[3] = true - var yynn4042 int - if yyr4042 || yy2arr4042 { + yysep4058 := !z.EncBinary() + yy2arr4058 := z.EncBasicHandle().StructToArray + var yyq4058 [4]bool + _, _, _ = yysep4058, yyq4058, yy2arr4058 + const yyr4058 bool = false + yyq4058[0] = x.Kind != "" + yyq4058[1] = x.APIVersion != "" + yyq4058[2] = true + yyq4058[3] = true + var yynn4058 int + if yyr4058 || yy2arr4058 { r.EncodeArrayStart(4) } else { - yynn4042 = 0 - for _, b := range yyq4042 { + yynn4058 = 0 + for _, b := range yyq4058 { if b { - yynn4042++ + yynn4058++ } } - r.EncodeMapStart(yynn4042) - yynn4042 = 0 + r.EncodeMapStart(yynn4058) + yynn4058 = 0 } - if yyr4042 || yy2arr4042 { + if yyr4058 || yy2arr4058 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4042[0] { - yym4044 := z.EncBinary() - _ = yym4044 + if yyq4058[0] { + yym4060 := z.EncBinary() + _ = yym4060 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -50593,23 +50796,23 @@ func (x *LimitRange) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4042[0] { + if yyq4058[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4045 := z.EncBinary() - _ = yym4045 + yym4061 := z.EncBinary() + _ = yym4061 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4042 || yy2arr4042 { + if yyr4058 || yy2arr4058 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4042[1] { - yym4047 := z.EncBinary() - _ = yym4047 + if yyq4058[1] { + yym4063 := z.EncBinary() + _ = yym4063 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -50618,53 +50821,53 @@ func (x *LimitRange) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4042[1] { + if yyq4058[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4048 := z.EncBinary() - _ = yym4048 + yym4064 := z.EncBinary() + _ = yym4064 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4042 || yy2arr4042 { + if yyr4058 || yy2arr4058 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4042[2] { - yy4050 := &x.ObjectMeta - yy4050.CodecEncodeSelf(e) + if yyq4058[2] { + yy4066 := &x.ObjectMeta + yy4066.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4042[2] { + if yyq4058[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4051 := &x.ObjectMeta - yy4051.CodecEncodeSelf(e) + yy4067 := &x.ObjectMeta + yy4067.CodecEncodeSelf(e) } } - if yyr4042 || yy2arr4042 { + if yyr4058 || yy2arr4058 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4042[3] { - yy4053 := &x.Spec - yy4053.CodecEncodeSelf(e) + if yyq4058[3] { + yy4069 := &x.Spec + yy4069.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4042[3] { + if yyq4058[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4054 := &x.Spec - yy4054.CodecEncodeSelf(e) + yy4070 := &x.Spec + yy4070.CodecEncodeSelf(e) } } - if yyr4042 || yy2arr4042 { + if yyr4058 || yy2arr4058 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -50677,25 +50880,25 @@ func (x *LimitRange) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4055 := z.DecBinary() - _ = yym4055 + yym4071 := z.DecBinary() + _ = yym4071 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4056 := r.ContainerType() - if yyct4056 == codecSelferValueTypeMap1234 { - yyl4056 := r.ReadMapStart() - if yyl4056 == 0 { + yyct4072 := r.ContainerType() + if yyct4072 == codecSelferValueTypeMap1234 { + yyl4072 := r.ReadMapStart() + if yyl4072 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4056, d) + x.codecDecodeSelfFromMap(yyl4072, d) } - } else if yyct4056 == codecSelferValueTypeArray1234 { - yyl4056 := r.ReadArrayStart() - if yyl4056 == 0 { + } else if yyct4072 == codecSelferValueTypeArray1234 { + yyl4072 := r.ReadArrayStart() + if yyl4072 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4056, d) + x.codecDecodeSelfFromArray(yyl4072, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -50707,12 +50910,12 @@ func (x *LimitRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4057Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4057Slc - var yyhl4057 bool = l >= 0 - for yyj4057 := 0; ; yyj4057++ { - if yyhl4057 { - if yyj4057 >= l { + var yys4073Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4073Slc + var yyhl4073 bool = l >= 0 + for yyj4073 := 0; ; yyj4073++ { + if yyhl4073 { + if yyj4073 >= l { break } } else { @@ -50721,10 +50924,10 @@ func (x *LimitRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4057Slc = r.DecodeBytes(yys4057Slc, true, true) - yys4057 := string(yys4057Slc) + yys4073Slc = r.DecodeBytes(yys4073Slc, true, true) + yys4073 := string(yys4073Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4057 { + switch yys4073 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -50741,20 +50944,20 @@ func (x *LimitRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4060 := &x.ObjectMeta - yyv4060.CodecDecodeSelf(d) + yyv4076 := &x.ObjectMeta + yyv4076.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = LimitRangeSpec{} } else { - yyv4061 := &x.Spec - yyv4061.CodecDecodeSelf(d) + yyv4077 := &x.Spec + yyv4077.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys4057) - } // end switch yys4057 - } // end for yyj4057 + z.DecStructFieldNotFound(-1, yys4073) + } // end switch yys4073 + } // end for yyj4073 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -50762,16 +50965,16 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4062 int - var yyb4062 bool - var yyhl4062 bool = l >= 0 - yyj4062++ - if yyhl4062 { - yyb4062 = yyj4062 > l + var yyj4078 int + var yyb4078 bool + var yyhl4078 bool = l >= 0 + yyj4078++ + if yyhl4078 { + yyb4078 = yyj4078 > l } else { - yyb4062 = r.CheckBreak() + yyb4078 = r.CheckBreak() } - if yyb4062 { + if yyb4078 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50781,13 +50984,13 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4062++ - if yyhl4062 { - yyb4062 = yyj4062 > l + yyj4078++ + if yyhl4078 { + yyb4078 = yyj4078 > l } else { - yyb4062 = r.CheckBreak() + yyb4078 = r.CheckBreak() } - if yyb4062 { + if yyb4078 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50797,13 +51000,13 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4062++ - if yyhl4062 { - yyb4062 = yyj4062 > l + yyj4078++ + if yyhl4078 { + yyb4078 = yyj4078 > l } else { - yyb4062 = r.CheckBreak() + yyb4078 = r.CheckBreak() } - if yyb4062 { + if yyb4078 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50811,16 +51014,16 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4065 := &x.ObjectMeta - yyv4065.CodecDecodeSelf(d) + yyv4081 := &x.ObjectMeta + yyv4081.CodecDecodeSelf(d) } - yyj4062++ - if yyhl4062 { - yyb4062 = yyj4062 > l + yyj4078++ + if yyhl4078 { + yyb4078 = yyj4078 > l } else { - yyb4062 = r.CheckBreak() + yyb4078 = r.CheckBreak() } - if yyb4062 { + if yyb4078 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -50828,21 +51031,21 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Spec = LimitRangeSpec{} } else { - yyv4066 := &x.Spec - yyv4066.CodecDecodeSelf(d) + yyv4082 := &x.Spec + yyv4082.CodecDecodeSelf(d) } for { - yyj4062++ - if yyhl4062 { - yyb4062 = yyj4062 > l + yyj4078++ + if yyhl4078 { + yyb4078 = yyj4078 > l } else { - yyb4062 = r.CheckBreak() + yyb4078 = r.CheckBreak() } - if yyb4062 { + if yyb4078 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4062-1, "") + z.DecStructFieldNotFound(yyj4078-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -50854,37 +51057,37 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4067 := z.EncBinary() - _ = yym4067 + yym4083 := z.EncBinary() + _ = yym4083 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4068 := !z.EncBinary() - yy2arr4068 := z.EncBasicHandle().StructToArray - var yyq4068 [4]bool - _, _, _ = yysep4068, yyq4068, yy2arr4068 - const yyr4068 bool = false - yyq4068[0] = x.Kind != "" - yyq4068[1] = x.APIVersion != "" - yyq4068[2] = true - var yynn4068 int - if yyr4068 || yy2arr4068 { + yysep4084 := !z.EncBinary() + yy2arr4084 := z.EncBasicHandle().StructToArray + var yyq4084 [4]bool + _, _, _ = yysep4084, yyq4084, yy2arr4084 + const yyr4084 bool = false + yyq4084[0] = x.Kind != "" + yyq4084[1] = x.APIVersion != "" + yyq4084[2] = true + var yynn4084 int + if yyr4084 || yy2arr4084 { r.EncodeArrayStart(4) } else { - yynn4068 = 1 - for _, b := range yyq4068 { + yynn4084 = 1 + for _, b := range yyq4084 { if b { - yynn4068++ + yynn4084++ } } - r.EncodeMapStart(yynn4068) - yynn4068 = 0 + r.EncodeMapStart(yynn4084) + yynn4084 = 0 } - if yyr4068 || yy2arr4068 { + if yyr4084 || yy2arr4084 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4068[0] { - yym4070 := z.EncBinary() - _ = yym4070 + if yyq4084[0] { + yym4086 := z.EncBinary() + _ = yym4086 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -50893,23 +51096,23 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4068[0] { + if yyq4084[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4071 := z.EncBinary() - _ = yym4071 + yym4087 := z.EncBinary() + _ = yym4087 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4068 || yy2arr4068 { + if yyr4084 || yy2arr4084 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4068[1] { - yym4073 := z.EncBinary() - _ = yym4073 + if yyq4084[1] { + yym4089 := z.EncBinary() + _ = yym4089 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -50918,54 +51121,54 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4068[1] { + if yyq4084[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4074 := z.EncBinary() - _ = yym4074 + yym4090 := z.EncBinary() + _ = yym4090 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4068 || yy2arr4068 { + if yyr4084 || yy2arr4084 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4068[2] { - yy4076 := &x.ListMeta - yym4077 := z.EncBinary() - _ = yym4077 + if yyq4084[2] { + yy4092 := &x.ListMeta + yym4093 := z.EncBinary() + _ = yym4093 if false { - } else if z.HasExtensions() && z.EncExt(yy4076) { + } else if z.HasExtensions() && z.EncExt(yy4092) { } else { - z.EncFallback(yy4076) + z.EncFallback(yy4092) } } else { r.EncodeNil() } } else { - if yyq4068[2] { + if yyq4084[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4078 := &x.ListMeta - yym4079 := z.EncBinary() - _ = yym4079 + yy4094 := &x.ListMeta + yym4095 := z.EncBinary() + _ = yym4095 if false { - } else if z.HasExtensions() && z.EncExt(yy4078) { + } else if z.HasExtensions() && z.EncExt(yy4094) { } else { - z.EncFallback(yy4078) + z.EncFallback(yy4094) } } } - if yyr4068 || yy2arr4068 { + if yyr4084 || yy2arr4084 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym4081 := z.EncBinary() - _ = yym4081 + yym4097 := z.EncBinary() + _ = yym4097 if false { } else { h.encSliceLimitRange(([]LimitRange)(x.Items), e) @@ -50978,15 +51181,15 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym4082 := z.EncBinary() - _ = yym4082 + yym4098 := z.EncBinary() + _ = yym4098 if false { } else { h.encSliceLimitRange(([]LimitRange)(x.Items), e) } } } - if yyr4068 || yy2arr4068 { + if yyr4084 || yy2arr4084 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -50999,25 +51202,25 @@ func (x *LimitRangeList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4083 := z.DecBinary() - _ = yym4083 + yym4099 := z.DecBinary() + _ = yym4099 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4084 := r.ContainerType() - if yyct4084 == codecSelferValueTypeMap1234 { - yyl4084 := r.ReadMapStart() - if yyl4084 == 0 { + yyct4100 := r.ContainerType() + if yyct4100 == codecSelferValueTypeMap1234 { + yyl4100 := r.ReadMapStart() + if yyl4100 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4084, d) + x.codecDecodeSelfFromMap(yyl4100, d) } - } else if yyct4084 == codecSelferValueTypeArray1234 { - yyl4084 := r.ReadArrayStart() - if yyl4084 == 0 { + } else if yyct4100 == codecSelferValueTypeArray1234 { + yyl4100 := r.ReadArrayStart() + if yyl4100 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4084, d) + x.codecDecodeSelfFromArray(yyl4100, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -51029,12 +51232,12 @@ func (x *LimitRangeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4085Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4085Slc - var yyhl4085 bool = l >= 0 - for yyj4085 := 0; ; yyj4085++ { - if yyhl4085 { - if yyj4085 >= l { + var yys4101Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4101Slc + var yyhl4101 bool = l >= 0 + for yyj4101 := 0; ; yyj4101++ { + if yyhl4101 { + if yyj4101 >= l { break } } else { @@ -51043,10 +51246,10 @@ func (x *LimitRangeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4085Slc = r.DecodeBytes(yys4085Slc, true, true) - yys4085 := string(yys4085Slc) + yys4101Slc = r.DecodeBytes(yys4101Slc, true, true) + yys4101 := string(yys4101Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4085 { + switch yys4101 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -51063,31 +51266,31 @@ func (x *LimitRangeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4088 := &x.ListMeta - yym4089 := z.DecBinary() - _ = yym4089 + yyv4104 := &x.ListMeta + yym4105 := z.DecBinary() + _ = yym4105 if false { - } else if z.HasExtensions() && z.DecExt(yyv4088) { + } else if z.HasExtensions() && z.DecExt(yyv4104) { } else { - z.DecFallback(yyv4088, false) + z.DecFallback(yyv4104, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4090 := &x.Items - yym4091 := z.DecBinary() - _ = yym4091 + yyv4106 := &x.Items + yym4107 := z.DecBinary() + _ = yym4107 if false { } else { - h.decSliceLimitRange((*[]LimitRange)(yyv4090), d) + h.decSliceLimitRange((*[]LimitRange)(yyv4106), d) } } default: - z.DecStructFieldNotFound(-1, yys4085) - } // end switch yys4085 - } // end for yyj4085 + z.DecStructFieldNotFound(-1, yys4101) + } // end switch yys4101 + } // end for yyj4101 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -51095,16 +51298,16 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4092 int - var yyb4092 bool - var yyhl4092 bool = l >= 0 - yyj4092++ - if yyhl4092 { - yyb4092 = yyj4092 > l + var yyj4108 int + var yyb4108 bool + var yyhl4108 bool = l >= 0 + yyj4108++ + if yyhl4108 { + yyb4108 = yyj4108 > l } else { - yyb4092 = r.CheckBreak() + yyb4108 = r.CheckBreak() } - if yyb4092 { + if yyb4108 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51114,13 +51317,13 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4092++ - if yyhl4092 { - yyb4092 = yyj4092 > l + yyj4108++ + if yyhl4108 { + yyb4108 = yyj4108 > l } else { - yyb4092 = r.CheckBreak() + yyb4108 = r.CheckBreak() } - if yyb4092 { + if yyb4108 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51130,13 +51333,13 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4092++ - if yyhl4092 { - yyb4092 = yyj4092 > l + yyj4108++ + if yyhl4108 { + yyb4108 = yyj4108 > l } else { - yyb4092 = r.CheckBreak() + yyb4108 = r.CheckBreak() } - if yyb4092 { + if yyb4108 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51144,22 +51347,22 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4095 := &x.ListMeta - yym4096 := z.DecBinary() - _ = yym4096 + yyv4111 := &x.ListMeta + yym4112 := z.DecBinary() + _ = yym4112 if false { - } else if z.HasExtensions() && z.DecExt(yyv4095) { + } else if z.HasExtensions() && z.DecExt(yyv4111) { } else { - z.DecFallback(yyv4095, false) + z.DecFallback(yyv4111, false) } } - yyj4092++ - if yyhl4092 { - yyb4092 = yyj4092 > l + yyj4108++ + if yyhl4108 { + yyb4108 = yyj4108 > l } else { - yyb4092 = r.CheckBreak() + yyb4108 = r.CheckBreak() } - if yyb4092 { + if yyb4108 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51167,26 +51370,26 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4097 := &x.Items - yym4098 := z.DecBinary() - _ = yym4098 + yyv4113 := &x.Items + yym4114 := z.DecBinary() + _ = yym4114 if false { } else { - h.decSliceLimitRange((*[]LimitRange)(yyv4097), d) + h.decSliceLimitRange((*[]LimitRange)(yyv4113), d) } } for { - yyj4092++ - if yyhl4092 { - yyb4092 = yyj4092 > l + yyj4108++ + if yyhl4108 { + yyb4108 = yyj4108 > l } else { - yyb4092 = r.CheckBreak() + yyb4108 = r.CheckBreak() } - if yyb4092 { + if yyb4108 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4092-1, "") + z.DecStructFieldNotFound(yyj4108-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -51195,8 +51398,8 @@ func (x ResourceQuotaScope) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym4099 := z.EncBinary() - _ = yym4099 + yym4115 := z.EncBinary() + _ = yym4115 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -51208,8 +51411,8 @@ func (x *ResourceQuotaScope) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4100 := z.DecBinary() - _ = yym4100 + yym4116 := z.DecBinary() + _ = yym4116 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -51218,243 +51421,6 @@ func (x *ResourceQuotaScope) CodecDecodeSelf(d *codec1978.Decoder) { } func (x *ResourceQuotaSpec) CodecEncodeSelf(e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - if x == nil { - r.EncodeNil() - } else { - yym4101 := z.EncBinary() - _ = yym4101 - if false { - } else if z.HasExtensions() && z.EncExt(x) { - } else { - yysep4102 := !z.EncBinary() - yy2arr4102 := z.EncBasicHandle().StructToArray - var yyq4102 [2]bool - _, _, _ = yysep4102, yyq4102, yy2arr4102 - const yyr4102 bool = false - yyq4102[0] = len(x.Hard) != 0 - yyq4102[1] = len(x.Scopes) != 0 - var yynn4102 int - if yyr4102 || yy2arr4102 { - r.EncodeArrayStart(2) - } else { - yynn4102 = 0 - for _, b := range yyq4102 { - if b { - yynn4102++ - } - } - r.EncodeMapStart(yynn4102) - yynn4102 = 0 - } - if yyr4102 || yy2arr4102 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4102[0] { - if x.Hard == nil { - r.EncodeNil() - } else { - x.Hard.CodecEncodeSelf(e) - } - } else { - r.EncodeNil() - } - } else { - if yyq4102[0] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("hard")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Hard == nil { - r.EncodeNil() - } else { - x.Hard.CodecEncodeSelf(e) - } - } - } - if yyr4102 || yy2arr4102 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4102[1] { - if x.Scopes == nil { - r.EncodeNil() - } else { - yym4105 := z.EncBinary() - _ = yym4105 - if false { - } else { - h.encSliceResourceQuotaScope(([]ResourceQuotaScope)(x.Scopes), e) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq4102[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("scopes")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Scopes == nil { - r.EncodeNil() - } else { - yym4106 := z.EncBinary() - _ = yym4106 - if false { - } else { - h.encSliceResourceQuotaScope(([]ResourceQuotaScope)(x.Scopes), e) - } - } - } - } - if yyr4102 || yy2arr4102 { - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - z.EncSendContainerState(codecSelfer_containerMapEnd1234) - } - } - } -} - -func (x *ResourceQuotaSpec) CodecDecodeSelf(d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - yym4107 := z.DecBinary() - _ = yym4107 - if false { - } else if z.HasExtensions() && z.DecExt(x) { - } else { - yyct4108 := r.ContainerType() - if yyct4108 == codecSelferValueTypeMap1234 { - yyl4108 := r.ReadMapStart() - if yyl4108 == 0 { - z.DecSendContainerState(codecSelfer_containerMapEnd1234) - } else { - x.codecDecodeSelfFromMap(yyl4108, d) - } - } else if yyct4108 == codecSelferValueTypeArray1234 { - yyl4108 := r.ReadArrayStart() - if yyl4108 == 0 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - } else { - x.codecDecodeSelfFromArray(yyl4108, d) - } - } else { - panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) - } - } -} - -func (x *ResourceQuotaSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yys4109Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4109Slc - var yyhl4109 bool = l >= 0 - for yyj4109 := 0; ; yyj4109++ { - if yyhl4109 { - if yyj4109 >= l { - break - } - } else { - if r.CheckBreak() { - break - } - } - z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4109Slc = r.DecodeBytes(yys4109Slc, true, true) - yys4109 := string(yys4109Slc) - z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4109 { - case "hard": - if r.TryDecodeAsNil() { - x.Hard = nil - } else { - yyv4110 := &x.Hard - yyv4110.CodecDecodeSelf(d) - } - case "scopes": - if r.TryDecodeAsNil() { - x.Scopes = nil - } else { - yyv4111 := &x.Scopes - yym4112 := z.DecBinary() - _ = yym4112 - if false { - } else { - h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4111), d) - } - } - default: - z.DecStructFieldNotFound(-1, yys4109) - } // end switch yys4109 - } // end for yyj4109 - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x *ResourceQuotaSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - var yyj4113 int - var yyb4113 bool - var yyhl4113 bool = l >= 0 - yyj4113++ - if yyhl4113 { - yyb4113 = yyj4113 > l - } else { - yyb4113 = r.CheckBreak() - } - if yyb4113 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Hard = nil - } else { - yyv4114 := &x.Hard - yyv4114.CodecDecodeSelf(d) - } - yyj4113++ - if yyhl4113 { - yyb4113 = yyj4113 > l - } else { - yyb4113 = r.CheckBreak() - } - if yyb4113 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.Scopes = nil - } else { - yyv4115 := &x.Scopes - yym4116 := z.DecBinary() - _ = yym4116 - if false { - } else { - h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4115), d) - } - } - for { - yyj4113++ - if yyhl4113 { - yyb4113 = yyj4113 > l - } else { - yyb4113 = r.CheckBreak() - } - if yyb4113 { - break - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4113-1, "") - } - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -51472,7 +51438,7 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) { _, _, _ = yysep4118, yyq4118, yy2arr4118 const yyr4118 bool = false yyq4118[0] = len(x.Hard) != 0 - yyq4118[1] = len(x.Used) != 0 + yyq4118[1] = len(x.Scopes) != 0 var yynn4118 int if yyr4118 || yy2arr4118 { r.EncodeArrayStart(2) @@ -51512,10 +51478,15 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) { if yyr4118 || yy2arr4118 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if yyq4118[1] { - if x.Used == nil { + if x.Scopes == nil { r.EncodeNil() } else { - x.Used.CodecEncodeSelf(e) + yym4121 := z.EncBinary() + _ = yym4121 + if false { + } else { + h.encSliceResourceQuotaScope(([]ResourceQuotaScope)(x.Scopes), e) + } } } else { r.EncodeNil() @@ -51523,12 +51494,17 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) { } else { if yyq4118[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("used")) + r.EncodeString(codecSelferC_UTF81234, string("scopes")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Used == nil { + if x.Scopes == nil { r.EncodeNil() } else { - x.Used.CodecEncodeSelf(e) + yym4122 := z.EncBinary() + _ = yym4122 + if false { + } else { + h.encSliceResourceQuotaScope(([]ResourceQuotaScope)(x.Scopes), e) + } } } } @@ -51541,29 +51517,256 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } +func (x *ResourceQuotaSpec) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym4123 := z.DecBinary() + _ = yym4123 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct4124 := r.ContainerType() + if yyct4124 == codecSelferValueTypeMap1234 { + yyl4124 := r.ReadMapStart() + if yyl4124 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd1234) + } else { + x.codecDecodeSelfFromMap(yyl4124, d) + } + } else if yyct4124 == codecSelferValueTypeArray1234 { + yyl4124 := r.ReadArrayStart() + if yyl4124 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + x.codecDecodeSelfFromArray(yyl4124, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) + } + } +} + +func (x *ResourceQuotaSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys4125Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4125Slc + var yyhl4125 bool = l >= 0 + for yyj4125 := 0; ; yyj4125++ { + if yyhl4125 { + if yyj4125 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey1234) + yys4125Slc = r.DecodeBytes(yys4125Slc, true, true) + yys4125 := string(yys4125Slc) + z.DecSendContainerState(codecSelfer_containerMapValue1234) + switch yys4125 { + case "hard": + if r.TryDecodeAsNil() { + x.Hard = nil + } else { + yyv4126 := &x.Hard + yyv4126.CodecDecodeSelf(d) + } + case "scopes": + if r.TryDecodeAsNil() { + x.Scopes = nil + } else { + yyv4127 := &x.Scopes + yym4128 := z.DecBinary() + _ = yym4128 + if false { + } else { + h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4127), d) + } + } + default: + z.DecStructFieldNotFound(-1, yys4125) + } // end switch yys4125 + } // end for yyj4125 + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x *ResourceQuotaSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj4129 int + var yyb4129 bool + var yyhl4129 bool = l >= 0 + yyj4129++ + if yyhl4129 { + yyb4129 = yyj4129 > l + } else { + yyb4129 = r.CheckBreak() + } + if yyb4129 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Hard = nil + } else { + yyv4130 := &x.Hard + yyv4130.CodecDecodeSelf(d) + } + yyj4129++ + if yyhl4129 { + yyb4129 = yyj4129 > l + } else { + yyb4129 = r.CheckBreak() + } + if yyb4129 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.Scopes = nil + } else { + yyv4131 := &x.Scopes + yym4132 := z.DecBinary() + _ = yym4132 + if false { + } else { + h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4131), d) + } + } + for { + yyj4129++ + if yyhl4129 { + yyb4129 = yyj4129 > l + } else { + yyb4129 = r.CheckBreak() + } + if yyb4129 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + z.DecStructFieldNotFound(yyj4129-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym4133 := z.EncBinary() + _ = yym4133 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep4134 := !z.EncBinary() + yy2arr4134 := z.EncBasicHandle().StructToArray + var yyq4134 [2]bool + _, _, _ = yysep4134, yyq4134, yy2arr4134 + const yyr4134 bool = false + yyq4134[0] = len(x.Hard) != 0 + yyq4134[1] = len(x.Used) != 0 + var yynn4134 int + if yyr4134 || yy2arr4134 { + r.EncodeArrayStart(2) + } else { + yynn4134 = 0 + for _, b := range yyq4134 { + if b { + yynn4134++ + } + } + r.EncodeMapStart(yynn4134) + yynn4134 = 0 + } + if yyr4134 || yy2arr4134 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq4134[0] { + if x.Hard == nil { + r.EncodeNil() + } else { + x.Hard.CodecEncodeSelf(e) + } + } else { + r.EncodeNil() + } + } else { + if yyq4134[0] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("hard")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Hard == nil { + r.EncodeNil() + } else { + x.Hard.CodecEncodeSelf(e) + } + } + } + if yyr4134 || yy2arr4134 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq4134[1] { + if x.Used == nil { + r.EncodeNil() + } else { + x.Used.CodecEncodeSelf(e) + } + } else { + r.EncodeNil() + } + } else { + if yyq4134[1] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("used")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.Used == nil { + r.EncodeNil() + } else { + x.Used.CodecEncodeSelf(e) + } + } + } + if yyr4134 || yy2arr4134 { + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd1234) + } + } + } +} + func (x *ResourceQuotaStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4121 := z.DecBinary() - _ = yym4121 + yym4137 := z.DecBinary() + _ = yym4137 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4122 := r.ContainerType() - if yyct4122 == codecSelferValueTypeMap1234 { - yyl4122 := r.ReadMapStart() - if yyl4122 == 0 { + yyct4138 := r.ContainerType() + if yyct4138 == codecSelferValueTypeMap1234 { + yyl4138 := r.ReadMapStart() + if yyl4138 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4122, d) + x.codecDecodeSelfFromMap(yyl4138, d) } - } else if yyct4122 == codecSelferValueTypeArray1234 { - yyl4122 := r.ReadArrayStart() - if yyl4122 == 0 { + } else if yyct4138 == codecSelferValueTypeArray1234 { + yyl4138 := r.ReadArrayStart() + if yyl4138 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4122, d) + x.codecDecodeSelfFromArray(yyl4138, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -51575,12 +51778,12 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4123Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4123Slc - var yyhl4123 bool = l >= 0 - for yyj4123 := 0; ; yyj4123++ { - if yyhl4123 { - if yyj4123 >= l { + var yys4139Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4139Slc + var yyhl4139 bool = l >= 0 + for yyj4139 := 0; ; yyj4139++ { + if yyhl4139 { + if yyj4139 >= l { break } } else { @@ -51589,28 +51792,28 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4123Slc = r.DecodeBytes(yys4123Slc, true, true) - yys4123 := string(yys4123Slc) + yys4139Slc = r.DecodeBytes(yys4139Slc, true, true) + yys4139 := string(yys4139Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4123 { + switch yys4139 { case "hard": if r.TryDecodeAsNil() { x.Hard = nil } else { - yyv4124 := &x.Hard - yyv4124.CodecDecodeSelf(d) + yyv4140 := &x.Hard + yyv4140.CodecDecodeSelf(d) } case "used": if r.TryDecodeAsNil() { x.Used = nil } else { - yyv4125 := &x.Used - yyv4125.CodecDecodeSelf(d) + yyv4141 := &x.Used + yyv4141.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys4123) - } // end switch yys4123 - } // end for yyj4123 + z.DecStructFieldNotFound(-1, yys4139) + } // end switch yys4139 + } // end for yyj4139 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -51618,16 +51821,16 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4126 int - var yyb4126 bool - var yyhl4126 bool = l >= 0 - yyj4126++ - if yyhl4126 { - yyb4126 = yyj4126 > l + var yyj4142 int + var yyb4142 bool + var yyhl4142 bool = l >= 0 + yyj4142++ + if yyhl4142 { + yyb4142 = yyj4142 > l } else { - yyb4126 = r.CheckBreak() + yyb4142 = r.CheckBreak() } - if yyb4126 { + if yyb4142 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51635,16 +51838,16 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.Hard = nil } else { - yyv4127 := &x.Hard - yyv4127.CodecDecodeSelf(d) + yyv4143 := &x.Hard + yyv4143.CodecDecodeSelf(d) } - yyj4126++ - if yyhl4126 { - yyb4126 = yyj4126 > l + yyj4142++ + if yyhl4142 { + yyb4142 = yyj4142 > l } else { - yyb4126 = r.CheckBreak() + yyb4142 = r.CheckBreak() } - if yyb4126 { + if yyb4142 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51652,21 +51855,21 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.Used = nil } else { - yyv4128 := &x.Used - yyv4128.CodecDecodeSelf(d) + yyv4144 := &x.Used + yyv4144.CodecDecodeSelf(d) } for { - yyj4126++ - if yyhl4126 { - yyb4126 = yyj4126 > l + yyj4142++ + if yyhl4142 { + yyb4142 = yyj4142 > l } else { - yyb4126 = r.CheckBreak() + yyb4142 = r.CheckBreak() } - if yyb4126 { + if yyb4142 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4126-1, "") + z.DecStructFieldNotFound(yyj4142-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -51678,39 +51881,39 @@ func (x *ResourceQuota) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4129 := z.EncBinary() - _ = yym4129 + yym4145 := z.EncBinary() + _ = yym4145 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4130 := !z.EncBinary() - yy2arr4130 := z.EncBasicHandle().StructToArray - var yyq4130 [5]bool - _, _, _ = yysep4130, yyq4130, yy2arr4130 - const yyr4130 bool = false - yyq4130[0] = x.Kind != "" - yyq4130[1] = x.APIVersion != "" - yyq4130[2] = true - yyq4130[3] = true - yyq4130[4] = true - var yynn4130 int - if yyr4130 || yy2arr4130 { + yysep4146 := !z.EncBinary() + yy2arr4146 := z.EncBasicHandle().StructToArray + var yyq4146 [5]bool + _, _, _ = yysep4146, yyq4146, yy2arr4146 + const yyr4146 bool = false + yyq4146[0] = x.Kind != "" + yyq4146[1] = x.APIVersion != "" + yyq4146[2] = true + yyq4146[3] = true + yyq4146[4] = true + var yynn4146 int + if yyr4146 || yy2arr4146 { r.EncodeArrayStart(5) } else { - yynn4130 = 0 - for _, b := range yyq4130 { + yynn4146 = 0 + for _, b := range yyq4146 { if b { - yynn4130++ + yynn4146++ } } - r.EncodeMapStart(yynn4130) - yynn4130 = 0 + r.EncodeMapStart(yynn4146) + yynn4146 = 0 } - if yyr4130 || yy2arr4130 { + if yyr4146 || yy2arr4146 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4130[0] { - yym4132 := z.EncBinary() - _ = yym4132 + if yyq4146[0] { + yym4148 := z.EncBinary() + _ = yym4148 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -51719,23 +51922,23 @@ func (x *ResourceQuota) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4130[0] { + if yyq4146[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4133 := z.EncBinary() - _ = yym4133 + yym4149 := z.EncBinary() + _ = yym4149 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4130 || yy2arr4130 { + if yyr4146 || yy2arr4146 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4130[1] { - yym4135 := z.EncBinary() - _ = yym4135 + if yyq4146[1] { + yym4151 := z.EncBinary() + _ = yym4151 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -51744,70 +51947,70 @@ func (x *ResourceQuota) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4130[1] { + if yyq4146[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4136 := z.EncBinary() - _ = yym4136 + yym4152 := z.EncBinary() + _ = yym4152 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4130 || yy2arr4130 { + if yyr4146 || yy2arr4146 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4130[2] { - yy4138 := &x.ObjectMeta - yy4138.CodecEncodeSelf(e) + if yyq4146[2] { + yy4154 := &x.ObjectMeta + yy4154.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4130[2] { + if yyq4146[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4139 := &x.ObjectMeta - yy4139.CodecEncodeSelf(e) + yy4155 := &x.ObjectMeta + yy4155.CodecEncodeSelf(e) } } - if yyr4130 || yy2arr4130 { + if yyr4146 || yy2arr4146 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4130[3] { - yy4141 := &x.Spec - yy4141.CodecEncodeSelf(e) + if yyq4146[3] { + yy4157 := &x.Spec + yy4157.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4130[3] { + if yyq4146[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("spec")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4142 := &x.Spec - yy4142.CodecEncodeSelf(e) + yy4158 := &x.Spec + yy4158.CodecEncodeSelf(e) } } - if yyr4130 || yy2arr4130 { + if yyr4146 || yy2arr4146 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4130[4] { - yy4144 := &x.Status - yy4144.CodecEncodeSelf(e) + if yyq4146[4] { + yy4160 := &x.Status + yy4160.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4130[4] { + if yyq4146[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("status")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4145 := &x.Status - yy4145.CodecEncodeSelf(e) + yy4161 := &x.Status + yy4161.CodecEncodeSelf(e) } } - if yyr4130 || yy2arr4130 { + if yyr4146 || yy2arr4146 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -51820,25 +52023,25 @@ func (x *ResourceQuota) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4146 := z.DecBinary() - _ = yym4146 + yym4162 := z.DecBinary() + _ = yym4162 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4147 := r.ContainerType() - if yyct4147 == codecSelferValueTypeMap1234 { - yyl4147 := r.ReadMapStart() - if yyl4147 == 0 { + yyct4163 := r.ContainerType() + if yyct4163 == codecSelferValueTypeMap1234 { + yyl4163 := r.ReadMapStart() + if yyl4163 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4147, d) + x.codecDecodeSelfFromMap(yyl4163, d) } - } else if yyct4147 == codecSelferValueTypeArray1234 { - yyl4147 := r.ReadArrayStart() - if yyl4147 == 0 { + } else if yyct4163 == codecSelferValueTypeArray1234 { + yyl4163 := r.ReadArrayStart() + if yyl4163 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4147, d) + x.codecDecodeSelfFromArray(yyl4163, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -51850,12 +52053,12 @@ func (x *ResourceQuota) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4148Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4148Slc - var yyhl4148 bool = l >= 0 - for yyj4148 := 0; ; yyj4148++ { - if yyhl4148 { - if yyj4148 >= l { + var yys4164Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4164Slc + var yyhl4164 bool = l >= 0 + for yyj4164 := 0; ; yyj4164++ { + if yyhl4164 { + if yyj4164 >= l { break } } else { @@ -51864,10 +52067,10 @@ func (x *ResourceQuota) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4148Slc = r.DecodeBytes(yys4148Slc, true, true) - yys4148 := string(yys4148Slc) + yys4164Slc = r.DecodeBytes(yys4164Slc, true, true) + yys4164 := string(yys4164Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4148 { + switch yys4164 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -51884,27 +52087,27 @@ func (x *ResourceQuota) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4151 := &x.ObjectMeta - yyv4151.CodecDecodeSelf(d) + yyv4167 := &x.ObjectMeta + yyv4167.CodecDecodeSelf(d) } case "spec": if r.TryDecodeAsNil() { x.Spec = ResourceQuotaSpec{} } else { - yyv4152 := &x.Spec - yyv4152.CodecDecodeSelf(d) + yyv4168 := &x.Spec + yyv4168.CodecDecodeSelf(d) } case "status": if r.TryDecodeAsNil() { x.Status = ResourceQuotaStatus{} } else { - yyv4153 := &x.Status - yyv4153.CodecDecodeSelf(d) + yyv4169 := &x.Status + yyv4169.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys4148) - } // end switch yys4148 - } // end for yyj4148 + z.DecStructFieldNotFound(-1, yys4164) + } // end switch yys4164 + } // end for yyj4164 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -51912,16 +52115,16 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4154 int - var yyb4154 bool - var yyhl4154 bool = l >= 0 - yyj4154++ - if yyhl4154 { - yyb4154 = yyj4154 > l + var yyj4170 int + var yyb4170 bool + var yyhl4170 bool = l >= 0 + yyj4170++ + if yyhl4170 { + yyb4170 = yyj4170 > l } else { - yyb4154 = r.CheckBreak() + yyb4170 = r.CheckBreak() } - if yyb4154 { + if yyb4170 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51931,13 +52134,13 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4154++ - if yyhl4154 { - yyb4154 = yyj4154 > l + yyj4170++ + if yyhl4170 { + yyb4170 = yyj4170 > l } else { - yyb4154 = r.CheckBreak() + yyb4170 = r.CheckBreak() } - if yyb4154 { + if yyb4170 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51947,13 +52150,13 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4154++ - if yyhl4154 { - yyb4154 = yyj4154 > l + yyj4170++ + if yyhl4170 { + yyb4170 = yyj4170 > l } else { - yyb4154 = r.CheckBreak() + yyb4170 = r.CheckBreak() } - if yyb4154 { + if yyb4170 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51961,16 +52164,16 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4157 := &x.ObjectMeta - yyv4157.CodecDecodeSelf(d) + yyv4173 := &x.ObjectMeta + yyv4173.CodecDecodeSelf(d) } - yyj4154++ - if yyhl4154 { - yyb4154 = yyj4154 > l + yyj4170++ + if yyhl4170 { + yyb4170 = yyj4170 > l } else { - yyb4154 = r.CheckBreak() + yyb4170 = r.CheckBreak() } - if yyb4154 { + if yyb4170 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51978,16 +52181,16 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Spec = ResourceQuotaSpec{} } else { - yyv4158 := &x.Spec - yyv4158.CodecDecodeSelf(d) + yyv4174 := &x.Spec + yyv4174.CodecDecodeSelf(d) } - yyj4154++ - if yyhl4154 { - yyb4154 = yyj4154 > l + yyj4170++ + if yyhl4170 { + yyb4170 = yyj4170 > l } else { - yyb4154 = r.CheckBreak() + yyb4170 = r.CheckBreak() } - if yyb4154 { + if yyb4170 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -51995,21 +52198,21 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Status = ResourceQuotaStatus{} } else { - yyv4159 := &x.Status - yyv4159.CodecDecodeSelf(d) + yyv4175 := &x.Status + yyv4175.CodecDecodeSelf(d) } for { - yyj4154++ - if yyhl4154 { - yyb4154 = yyj4154 > l + yyj4170++ + if yyhl4170 { + yyb4170 = yyj4170 > l } else { - yyb4154 = r.CheckBreak() + yyb4170 = r.CheckBreak() } - if yyb4154 { + if yyb4170 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4154-1, "") + z.DecStructFieldNotFound(yyj4170-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -52021,37 +52224,37 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4160 := z.EncBinary() - _ = yym4160 + yym4176 := z.EncBinary() + _ = yym4176 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4161 := !z.EncBinary() - yy2arr4161 := z.EncBasicHandle().StructToArray - var yyq4161 [4]bool - _, _, _ = yysep4161, yyq4161, yy2arr4161 - const yyr4161 bool = false - yyq4161[0] = x.Kind != "" - yyq4161[1] = x.APIVersion != "" - yyq4161[2] = true - var yynn4161 int - if yyr4161 || yy2arr4161 { + yysep4177 := !z.EncBinary() + yy2arr4177 := z.EncBasicHandle().StructToArray + var yyq4177 [4]bool + _, _, _ = yysep4177, yyq4177, yy2arr4177 + const yyr4177 bool = false + yyq4177[0] = x.Kind != "" + yyq4177[1] = x.APIVersion != "" + yyq4177[2] = true + var yynn4177 int + if yyr4177 || yy2arr4177 { r.EncodeArrayStart(4) } else { - yynn4161 = 1 - for _, b := range yyq4161 { + yynn4177 = 1 + for _, b := range yyq4177 { if b { - yynn4161++ + yynn4177++ } } - r.EncodeMapStart(yynn4161) - yynn4161 = 0 + r.EncodeMapStart(yynn4177) + yynn4177 = 0 } - if yyr4161 || yy2arr4161 { + if yyr4177 || yy2arr4177 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4161[0] { - yym4163 := z.EncBinary() - _ = yym4163 + if yyq4177[0] { + yym4179 := z.EncBinary() + _ = yym4179 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -52060,23 +52263,23 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4161[0] { + if yyq4177[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4164 := z.EncBinary() - _ = yym4164 + yym4180 := z.EncBinary() + _ = yym4180 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4161 || yy2arr4161 { + if yyr4177 || yy2arr4177 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4161[1] { - yym4166 := z.EncBinary() - _ = yym4166 + if yyq4177[1] { + yym4182 := z.EncBinary() + _ = yym4182 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -52085,54 +52288,54 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4161[1] { + if yyq4177[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4167 := z.EncBinary() - _ = yym4167 + yym4183 := z.EncBinary() + _ = yym4183 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4161 || yy2arr4161 { + if yyr4177 || yy2arr4177 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4161[2] { - yy4169 := &x.ListMeta - yym4170 := z.EncBinary() - _ = yym4170 + if yyq4177[2] { + yy4185 := &x.ListMeta + yym4186 := z.EncBinary() + _ = yym4186 if false { - } else if z.HasExtensions() && z.EncExt(yy4169) { + } else if z.HasExtensions() && z.EncExt(yy4185) { } else { - z.EncFallback(yy4169) + z.EncFallback(yy4185) } } else { r.EncodeNil() } } else { - if yyq4161[2] { + if yyq4177[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4171 := &x.ListMeta - yym4172 := z.EncBinary() - _ = yym4172 + yy4187 := &x.ListMeta + yym4188 := z.EncBinary() + _ = yym4188 if false { - } else if z.HasExtensions() && z.EncExt(yy4171) { + } else if z.HasExtensions() && z.EncExt(yy4187) { } else { - z.EncFallback(yy4171) + z.EncFallback(yy4187) } } } - if yyr4161 || yy2arr4161 { + if yyr4177 || yy2arr4177 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym4174 := z.EncBinary() - _ = yym4174 + yym4190 := z.EncBinary() + _ = yym4190 if false { } else { h.encSliceResourceQuota(([]ResourceQuota)(x.Items), e) @@ -52145,15 +52348,15 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym4175 := z.EncBinary() - _ = yym4175 + yym4191 := z.EncBinary() + _ = yym4191 if false { } else { h.encSliceResourceQuota(([]ResourceQuota)(x.Items), e) } } } - if yyr4161 || yy2arr4161 { + if yyr4177 || yy2arr4177 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -52166,25 +52369,25 @@ func (x *ResourceQuotaList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4176 := z.DecBinary() - _ = yym4176 + yym4192 := z.DecBinary() + _ = yym4192 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4177 := r.ContainerType() - if yyct4177 == codecSelferValueTypeMap1234 { - yyl4177 := r.ReadMapStart() - if yyl4177 == 0 { + yyct4193 := r.ContainerType() + if yyct4193 == codecSelferValueTypeMap1234 { + yyl4193 := r.ReadMapStart() + if yyl4193 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4177, d) + x.codecDecodeSelfFromMap(yyl4193, d) } - } else if yyct4177 == codecSelferValueTypeArray1234 { - yyl4177 := r.ReadArrayStart() - if yyl4177 == 0 { + } else if yyct4193 == codecSelferValueTypeArray1234 { + yyl4193 := r.ReadArrayStart() + if yyl4193 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4177, d) + x.codecDecodeSelfFromArray(yyl4193, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -52196,12 +52399,12 @@ func (x *ResourceQuotaList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4178Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4178Slc - var yyhl4178 bool = l >= 0 - for yyj4178 := 0; ; yyj4178++ { - if yyhl4178 { - if yyj4178 >= l { + var yys4194Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4194Slc + var yyhl4194 bool = l >= 0 + for yyj4194 := 0; ; yyj4194++ { + if yyhl4194 { + if yyj4194 >= l { break } } else { @@ -52210,10 +52413,10 @@ func (x *ResourceQuotaList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4178Slc = r.DecodeBytes(yys4178Slc, true, true) - yys4178 := string(yys4178Slc) + yys4194Slc = r.DecodeBytes(yys4194Slc, true, true) + yys4194 := string(yys4194Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4178 { + switch yys4194 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -52230,31 +52433,31 @@ func (x *ResourceQuotaList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4181 := &x.ListMeta - yym4182 := z.DecBinary() - _ = yym4182 + yyv4197 := &x.ListMeta + yym4198 := z.DecBinary() + _ = yym4198 if false { - } else if z.HasExtensions() && z.DecExt(yyv4181) { + } else if z.HasExtensions() && z.DecExt(yyv4197) { } else { - z.DecFallback(yyv4181, false) + z.DecFallback(yyv4197, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4183 := &x.Items - yym4184 := z.DecBinary() - _ = yym4184 + yyv4199 := &x.Items + yym4200 := z.DecBinary() + _ = yym4200 if false { } else { - h.decSliceResourceQuota((*[]ResourceQuota)(yyv4183), d) + h.decSliceResourceQuota((*[]ResourceQuota)(yyv4199), d) } } default: - z.DecStructFieldNotFound(-1, yys4178) - } // end switch yys4178 - } // end for yyj4178 + z.DecStructFieldNotFound(-1, yys4194) + } // end switch yys4194 + } // end for yyj4194 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -52262,16 +52465,16 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4185 int - var yyb4185 bool - var yyhl4185 bool = l >= 0 - yyj4185++ - if yyhl4185 { - yyb4185 = yyj4185 > l + var yyj4201 int + var yyb4201 bool + var yyhl4201 bool = l >= 0 + yyj4201++ + if yyhl4201 { + yyb4201 = yyj4201 > l } else { - yyb4185 = r.CheckBreak() + yyb4201 = r.CheckBreak() } - if yyb4185 { + if yyb4201 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52281,13 +52484,13 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder } else { x.Kind = string(r.DecodeString()) } - yyj4185++ - if yyhl4185 { - yyb4185 = yyj4185 > l + yyj4201++ + if yyhl4201 { + yyb4201 = yyj4201 > l } else { - yyb4185 = r.CheckBreak() + yyb4201 = r.CheckBreak() } - if yyb4185 { + if yyb4201 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52297,13 +52500,13 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder } else { x.APIVersion = string(r.DecodeString()) } - yyj4185++ - if yyhl4185 { - yyb4185 = yyj4185 > l + yyj4201++ + if yyhl4201 { + yyb4201 = yyj4201 > l } else { - yyb4185 = r.CheckBreak() + yyb4201 = r.CheckBreak() } - if yyb4185 { + if yyb4201 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52311,22 +52514,22 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4188 := &x.ListMeta - yym4189 := z.DecBinary() - _ = yym4189 + yyv4204 := &x.ListMeta + yym4205 := z.DecBinary() + _ = yym4205 if false { - } else if z.HasExtensions() && z.DecExt(yyv4188) { + } else if z.HasExtensions() && z.DecExt(yyv4204) { } else { - z.DecFallback(yyv4188, false) + z.DecFallback(yyv4204, false) } } - yyj4185++ - if yyhl4185 { - yyb4185 = yyj4185 > l + yyj4201++ + if yyhl4201 { + yyb4201 = yyj4201 > l } else { - yyb4185 = r.CheckBreak() + yyb4201 = r.CheckBreak() } - if yyb4185 { + if yyb4201 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52334,26 +52537,26 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4190 := &x.Items - yym4191 := z.DecBinary() - _ = yym4191 + yyv4206 := &x.Items + yym4207 := z.DecBinary() + _ = yym4207 if false { } else { - h.decSliceResourceQuota((*[]ResourceQuota)(yyv4190), d) + h.decSliceResourceQuota((*[]ResourceQuota)(yyv4206), d) } } for { - yyj4185++ - if yyhl4185 { - yyb4185 = yyj4185 > l + yyj4201++ + if yyhl4201 { + yyb4201 = yyj4201 > l } else { - yyb4185 = r.CheckBreak() + yyb4201 = r.CheckBreak() } - if yyb4185 { + if yyb4201 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4185-1, "") + z.DecStructFieldNotFound(yyj4201-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -52365,39 +52568,39 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4192 := z.EncBinary() - _ = yym4192 + yym4208 := z.EncBinary() + _ = yym4208 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4193 := !z.EncBinary() - yy2arr4193 := z.EncBasicHandle().StructToArray - var yyq4193 [5]bool - _, _, _ = yysep4193, yyq4193, yy2arr4193 - const yyr4193 bool = false - yyq4193[0] = x.Kind != "" - yyq4193[1] = x.APIVersion != "" - yyq4193[2] = true - yyq4193[3] = len(x.Data) != 0 - yyq4193[4] = x.Type != "" - var yynn4193 int - if yyr4193 || yy2arr4193 { + yysep4209 := !z.EncBinary() + yy2arr4209 := z.EncBasicHandle().StructToArray + var yyq4209 [5]bool + _, _, _ = yysep4209, yyq4209, yy2arr4209 + const yyr4209 bool = false + yyq4209[0] = x.Kind != "" + yyq4209[1] = x.APIVersion != "" + yyq4209[2] = true + yyq4209[3] = len(x.Data) != 0 + yyq4209[4] = x.Type != "" + var yynn4209 int + if yyr4209 || yy2arr4209 { r.EncodeArrayStart(5) } else { - yynn4193 = 0 - for _, b := range yyq4193 { + yynn4209 = 0 + for _, b := range yyq4209 { if b { - yynn4193++ + yynn4209++ } } - r.EncodeMapStart(yynn4193) - yynn4193 = 0 + r.EncodeMapStart(yynn4209) + yynn4209 = 0 } - if yyr4193 || yy2arr4193 { + if yyr4209 || yy2arr4209 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4193[0] { - yym4195 := z.EncBinary() - _ = yym4195 + if yyq4209[0] { + yym4211 := z.EncBinary() + _ = yym4211 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -52406,23 +52609,23 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4193[0] { + if yyq4209[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4196 := z.EncBinary() - _ = yym4196 + yym4212 := z.EncBinary() + _ = yym4212 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4193 || yy2arr4193 { + if yyr4209 || yy2arr4209 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4193[1] { - yym4198 := z.EncBinary() - _ = yym4198 + if yyq4209[1] { + yym4214 := z.EncBinary() + _ = yym4214 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -52431,43 +52634,43 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4193[1] { + if yyq4209[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4199 := z.EncBinary() - _ = yym4199 + yym4215 := z.EncBinary() + _ = yym4215 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4193 || yy2arr4193 { + if yyr4209 || yy2arr4209 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4193[2] { - yy4201 := &x.ObjectMeta - yy4201.CodecEncodeSelf(e) + if yyq4209[2] { + yy4217 := &x.ObjectMeta + yy4217.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4193[2] { + if yyq4209[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4202 := &x.ObjectMeta - yy4202.CodecEncodeSelf(e) + yy4218 := &x.ObjectMeta + yy4218.CodecEncodeSelf(e) } } - if yyr4193 || yy2arr4193 { + if yyr4209 || yy2arr4209 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4193[3] { + if yyq4209[3] { if x.Data == nil { r.EncodeNil() } else { - yym4204 := z.EncBinary() - _ = yym4204 + yym4220 := z.EncBinary() + _ = yym4220 if false { } else { h.encMapstringSliceuint8((map[string][]uint8)(x.Data), e) @@ -52477,15 +52680,15 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4193[3] { + if yyq4209[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("data")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.Data == nil { r.EncodeNil() } else { - yym4205 := z.EncBinary() - _ = yym4205 + yym4221 := z.EncBinary() + _ = yym4221 if false { } else { h.encMapstringSliceuint8((map[string][]uint8)(x.Data), e) @@ -52493,22 +52696,22 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4193 || yy2arr4193 { + if yyr4209 || yy2arr4209 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4193[4] { + if yyq4209[4] { x.Type.CodecEncodeSelf(e) } else { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4193[4] { + if yyq4209[4] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("type")) z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Type.CodecEncodeSelf(e) } } - if yyr4193 || yy2arr4193 { + if yyr4209 || yy2arr4209 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -52521,25 +52724,25 @@ func (x *Secret) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4207 := z.DecBinary() - _ = yym4207 + yym4223 := z.DecBinary() + _ = yym4223 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4208 := r.ContainerType() - if yyct4208 == codecSelferValueTypeMap1234 { - yyl4208 := r.ReadMapStart() - if yyl4208 == 0 { + yyct4224 := r.ContainerType() + if yyct4224 == codecSelferValueTypeMap1234 { + yyl4224 := r.ReadMapStart() + if yyl4224 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4208, d) + x.codecDecodeSelfFromMap(yyl4224, d) } - } else if yyct4208 == codecSelferValueTypeArray1234 { - yyl4208 := r.ReadArrayStart() - if yyl4208 == 0 { + } else if yyct4224 == codecSelferValueTypeArray1234 { + yyl4224 := r.ReadArrayStart() + if yyl4224 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4208, d) + x.codecDecodeSelfFromArray(yyl4224, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -52551,12 +52754,12 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4209Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4209Slc - var yyhl4209 bool = l >= 0 - for yyj4209 := 0; ; yyj4209++ { - if yyhl4209 { - if yyj4209 >= l { + var yys4225Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4225Slc + var yyhl4225 bool = l >= 0 + for yyj4225 := 0; ; yyj4225++ { + if yyhl4225 { + if yyj4225 >= l { break } } else { @@ -52565,10 +52768,10 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4209Slc = r.DecodeBytes(yys4209Slc, true, true) - yys4209 := string(yys4209Slc) + yys4225Slc = r.DecodeBytes(yys4225Slc, true, true) + yys4225 := string(yys4225Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4209 { + switch yys4225 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -52585,19 +52788,19 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4212 := &x.ObjectMeta - yyv4212.CodecDecodeSelf(d) + yyv4228 := &x.ObjectMeta + yyv4228.CodecDecodeSelf(d) } case "data": if r.TryDecodeAsNil() { x.Data = nil } else { - yyv4213 := &x.Data - yym4214 := z.DecBinary() - _ = yym4214 + yyv4229 := &x.Data + yym4230 := z.DecBinary() + _ = yym4230 if false { } else { - h.decMapstringSliceuint8((*map[string][]uint8)(yyv4213), d) + h.decMapstringSliceuint8((*map[string][]uint8)(yyv4229), d) } } case "type": @@ -52607,9 +52810,9 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Type = SecretType(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys4209) - } // end switch yys4209 - } // end for yyj4209 + z.DecStructFieldNotFound(-1, yys4225) + } // end switch yys4225 + } // end for yyj4225 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -52617,16 +52820,16 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4216 int - var yyb4216 bool - var yyhl4216 bool = l >= 0 - yyj4216++ - if yyhl4216 { - yyb4216 = yyj4216 > l + var yyj4232 int + var yyb4232 bool + var yyhl4232 bool = l >= 0 + yyj4232++ + if yyhl4232 { + yyb4232 = yyj4232 > l } else { - yyb4216 = r.CheckBreak() + yyb4232 = r.CheckBreak() } - if yyb4216 { + if yyb4232 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52636,13 +52839,13 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4216++ - if yyhl4216 { - yyb4216 = yyj4216 > l + yyj4232++ + if yyhl4232 { + yyb4232 = yyj4232 > l } else { - yyb4216 = r.CheckBreak() + yyb4232 = r.CheckBreak() } - if yyb4216 { + if yyb4232 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52652,13 +52855,13 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4216++ - if yyhl4216 { - yyb4216 = yyj4216 > l + yyj4232++ + if yyhl4232 { + yyb4232 = yyj4232 > l } else { - yyb4216 = r.CheckBreak() + yyb4232 = r.CheckBreak() } - if yyb4216 { + if yyb4232 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52666,16 +52869,16 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4219 := &x.ObjectMeta - yyv4219.CodecDecodeSelf(d) + yyv4235 := &x.ObjectMeta + yyv4235.CodecDecodeSelf(d) } - yyj4216++ - if yyhl4216 { - yyb4216 = yyj4216 > l + yyj4232++ + if yyhl4232 { + yyb4232 = yyj4232 > l } else { - yyb4216 = r.CheckBreak() + yyb4232 = r.CheckBreak() } - if yyb4216 { + if yyb4232 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52683,21 +52886,21 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Data = nil } else { - yyv4220 := &x.Data - yym4221 := z.DecBinary() - _ = yym4221 + yyv4236 := &x.Data + yym4237 := z.DecBinary() + _ = yym4237 if false { } else { - h.decMapstringSliceuint8((*map[string][]uint8)(yyv4220), d) + h.decMapstringSliceuint8((*map[string][]uint8)(yyv4236), d) } } - yyj4216++ - if yyhl4216 { - yyb4216 = yyj4216 > l + yyj4232++ + if yyhl4232 { + yyb4232 = yyj4232 > l } else { - yyb4216 = r.CheckBreak() + yyb4232 = r.CheckBreak() } - if yyb4216 { + if yyb4232 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -52708,17 +52911,17 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Type = SecretType(r.DecodeString()) } for { - yyj4216++ - if yyhl4216 { - yyb4216 = yyj4216 > l + yyj4232++ + if yyhl4232 { + yyb4232 = yyj4232 > l } else { - yyb4216 = r.CheckBreak() + yyb4232 = r.CheckBreak() } - if yyb4216 { + if yyb4232 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4216-1, "") + z.DecStructFieldNotFound(yyj4232-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -52727,8 +52930,8 @@ func (x SecretType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym4223 := z.EncBinary() - _ = yym4223 + yym4239 := z.EncBinary() + _ = yym4239 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -52740,8 +52943,8 @@ func (x *SecretType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4224 := z.DecBinary() - _ = yym4224 + yym4240 := z.DecBinary() + _ = yym4240 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -52756,37 +52959,37 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4225 := z.EncBinary() - _ = yym4225 + yym4241 := z.EncBinary() + _ = yym4241 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4226 := !z.EncBinary() - yy2arr4226 := z.EncBasicHandle().StructToArray - var yyq4226 [4]bool - _, _, _ = yysep4226, yyq4226, yy2arr4226 - const yyr4226 bool = false - yyq4226[0] = x.Kind != "" - yyq4226[1] = x.APIVersion != "" - yyq4226[2] = true - var yynn4226 int - if yyr4226 || yy2arr4226 { + yysep4242 := !z.EncBinary() + yy2arr4242 := z.EncBasicHandle().StructToArray + var yyq4242 [4]bool + _, _, _ = yysep4242, yyq4242, yy2arr4242 + const yyr4242 bool = false + yyq4242[0] = x.Kind != "" + yyq4242[1] = x.APIVersion != "" + yyq4242[2] = true + var yynn4242 int + if yyr4242 || yy2arr4242 { r.EncodeArrayStart(4) } else { - yynn4226 = 1 - for _, b := range yyq4226 { + yynn4242 = 1 + for _, b := range yyq4242 { if b { - yynn4226++ + yynn4242++ } } - r.EncodeMapStart(yynn4226) - yynn4226 = 0 + r.EncodeMapStart(yynn4242) + yynn4242 = 0 } - if yyr4226 || yy2arr4226 { + if yyr4242 || yy2arr4242 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4226[0] { - yym4228 := z.EncBinary() - _ = yym4228 + if yyq4242[0] { + yym4244 := z.EncBinary() + _ = yym4244 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -52795,23 +52998,23 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4226[0] { + if yyq4242[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4229 := z.EncBinary() - _ = yym4229 + yym4245 := z.EncBinary() + _ = yym4245 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4226 || yy2arr4226 { + if yyr4242 || yy2arr4242 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4226[1] { - yym4231 := z.EncBinary() - _ = yym4231 + if yyq4242[1] { + yym4247 := z.EncBinary() + _ = yym4247 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -52820,54 +53023,54 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4226[1] { + if yyq4242[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4232 := z.EncBinary() - _ = yym4232 + yym4248 := z.EncBinary() + _ = yym4248 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4226 || yy2arr4226 { + if yyr4242 || yy2arr4242 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4226[2] { - yy4234 := &x.ListMeta - yym4235 := z.EncBinary() - _ = yym4235 + if yyq4242[2] { + yy4250 := &x.ListMeta + yym4251 := z.EncBinary() + _ = yym4251 if false { - } else if z.HasExtensions() && z.EncExt(yy4234) { + } else if z.HasExtensions() && z.EncExt(yy4250) { } else { - z.EncFallback(yy4234) + z.EncFallback(yy4250) } } else { r.EncodeNil() } } else { - if yyq4226[2] { + if yyq4242[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4236 := &x.ListMeta - yym4237 := z.EncBinary() - _ = yym4237 + yy4252 := &x.ListMeta + yym4253 := z.EncBinary() + _ = yym4253 if false { - } else if z.HasExtensions() && z.EncExt(yy4236) { + } else if z.HasExtensions() && z.EncExt(yy4252) { } else { - z.EncFallback(yy4236) + z.EncFallback(yy4252) } } } - if yyr4226 || yy2arr4226 { + if yyr4242 || yy2arr4242 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym4239 := z.EncBinary() - _ = yym4239 + yym4255 := z.EncBinary() + _ = yym4255 if false { } else { h.encSliceSecret(([]Secret)(x.Items), e) @@ -52880,15 +53083,15 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym4240 := z.EncBinary() - _ = yym4240 + yym4256 := z.EncBinary() + _ = yym4256 if false { } else { h.encSliceSecret(([]Secret)(x.Items), e) } } } - if yyr4226 || yy2arr4226 { + if yyr4242 || yy2arr4242 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -52901,25 +53104,25 @@ func (x *SecretList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4241 := z.DecBinary() - _ = yym4241 + yym4257 := z.DecBinary() + _ = yym4257 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4242 := r.ContainerType() - if yyct4242 == codecSelferValueTypeMap1234 { - yyl4242 := r.ReadMapStart() - if yyl4242 == 0 { + yyct4258 := r.ContainerType() + if yyct4258 == codecSelferValueTypeMap1234 { + yyl4258 := r.ReadMapStart() + if yyl4258 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4242, d) + x.codecDecodeSelfFromMap(yyl4258, d) } - } else if yyct4242 == codecSelferValueTypeArray1234 { - yyl4242 := r.ReadArrayStart() - if yyl4242 == 0 { + } else if yyct4258 == codecSelferValueTypeArray1234 { + yyl4258 := r.ReadArrayStart() + if yyl4258 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4242, d) + x.codecDecodeSelfFromArray(yyl4258, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -52931,12 +53134,12 @@ func (x *SecretList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4243Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4243Slc - var yyhl4243 bool = l >= 0 - for yyj4243 := 0; ; yyj4243++ { - if yyhl4243 { - if yyj4243 >= l { + var yys4259Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4259Slc + var yyhl4259 bool = l >= 0 + for yyj4259 := 0; ; yyj4259++ { + if yyhl4259 { + if yyj4259 >= l { break } } else { @@ -52945,10 +53148,10 @@ func (x *SecretList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4243Slc = r.DecodeBytes(yys4243Slc, true, true) - yys4243 := string(yys4243Slc) + yys4259Slc = r.DecodeBytes(yys4259Slc, true, true) + yys4259 := string(yys4259Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4243 { + switch yys4259 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -52965,31 +53168,31 @@ func (x *SecretList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4246 := &x.ListMeta - yym4247 := z.DecBinary() - _ = yym4247 + yyv4262 := &x.ListMeta + yym4263 := z.DecBinary() + _ = yym4263 if false { - } else if z.HasExtensions() && z.DecExt(yyv4246) { + } else if z.HasExtensions() && z.DecExt(yyv4262) { } else { - z.DecFallback(yyv4246, false) + z.DecFallback(yyv4262, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4248 := &x.Items - yym4249 := z.DecBinary() - _ = yym4249 + yyv4264 := &x.Items + yym4265 := z.DecBinary() + _ = yym4265 if false { } else { - h.decSliceSecret((*[]Secret)(yyv4248), d) + h.decSliceSecret((*[]Secret)(yyv4264), d) } } default: - z.DecStructFieldNotFound(-1, yys4243) - } // end switch yys4243 - } // end for yyj4243 + z.DecStructFieldNotFound(-1, yys4259) + } // end switch yys4259 + } // end for yyj4259 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -52997,16 +53200,16 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4250 int - var yyb4250 bool - var yyhl4250 bool = l >= 0 - yyj4250++ - if yyhl4250 { - yyb4250 = yyj4250 > l + var yyj4266 int + var yyb4266 bool + var yyhl4266 bool = l >= 0 + yyj4266++ + if yyhl4266 { + yyb4266 = yyj4266 > l } else { - yyb4250 = r.CheckBreak() + yyb4266 = r.CheckBreak() } - if yyb4250 { + if yyb4266 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53016,13 +53219,13 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4250++ - if yyhl4250 { - yyb4250 = yyj4250 > l + yyj4266++ + if yyhl4266 { + yyb4266 = yyj4266 > l } else { - yyb4250 = r.CheckBreak() + yyb4266 = r.CheckBreak() } - if yyb4250 { + if yyb4266 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53032,13 +53235,13 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4250++ - if yyhl4250 { - yyb4250 = yyj4250 > l + yyj4266++ + if yyhl4266 { + yyb4266 = yyj4266 > l } else { - yyb4250 = r.CheckBreak() + yyb4266 = r.CheckBreak() } - if yyb4250 { + if yyb4266 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53046,22 +53249,22 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4253 := &x.ListMeta - yym4254 := z.DecBinary() - _ = yym4254 + yyv4269 := &x.ListMeta + yym4270 := z.DecBinary() + _ = yym4270 if false { - } else if z.HasExtensions() && z.DecExt(yyv4253) { + } else if z.HasExtensions() && z.DecExt(yyv4269) { } else { - z.DecFallback(yyv4253, false) + z.DecFallback(yyv4269, false) } } - yyj4250++ - if yyhl4250 { - yyb4250 = yyj4250 > l + yyj4266++ + if yyhl4266 { + yyb4266 = yyj4266 > l } else { - yyb4250 = r.CheckBreak() + yyb4266 = r.CheckBreak() } - if yyb4250 { + if yyb4266 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53069,26 +53272,26 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4255 := &x.Items - yym4256 := z.DecBinary() - _ = yym4256 + yyv4271 := &x.Items + yym4272 := z.DecBinary() + _ = yym4272 if false { } else { - h.decSliceSecret((*[]Secret)(yyv4255), d) + h.decSliceSecret((*[]Secret)(yyv4271), d) } } for { - yyj4250++ - if yyhl4250 { - yyb4250 = yyj4250 > l + yyj4266++ + if yyhl4266 { + yyb4266 = yyj4266 > l } else { - yyb4250 = r.CheckBreak() + yyb4266 = r.CheckBreak() } - if yyb4250 { + if yyb4266 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4250-1, "") + z.DecStructFieldNotFound(yyj4266-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -53100,38 +53303,38 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4257 := z.EncBinary() - _ = yym4257 + yym4273 := z.EncBinary() + _ = yym4273 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4258 := !z.EncBinary() - yy2arr4258 := z.EncBasicHandle().StructToArray - var yyq4258 [4]bool - _, _, _ = yysep4258, yyq4258, yy2arr4258 - const yyr4258 bool = false - yyq4258[0] = x.Kind != "" - yyq4258[1] = x.APIVersion != "" - yyq4258[2] = true - yyq4258[3] = len(x.Data) != 0 - var yynn4258 int - if yyr4258 || yy2arr4258 { + yysep4274 := !z.EncBinary() + yy2arr4274 := z.EncBasicHandle().StructToArray + var yyq4274 [4]bool + _, _, _ = yysep4274, yyq4274, yy2arr4274 + const yyr4274 bool = false + yyq4274[0] = x.Kind != "" + yyq4274[1] = x.APIVersion != "" + yyq4274[2] = true + yyq4274[3] = len(x.Data) != 0 + var yynn4274 int + if yyr4274 || yy2arr4274 { r.EncodeArrayStart(4) } else { - yynn4258 = 0 - for _, b := range yyq4258 { + yynn4274 = 0 + for _, b := range yyq4274 { if b { - yynn4258++ + yynn4274++ } } - r.EncodeMapStart(yynn4258) - yynn4258 = 0 + r.EncodeMapStart(yynn4274) + yynn4274 = 0 } - if yyr4258 || yy2arr4258 { + if yyr4274 || yy2arr4274 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4258[0] { - yym4260 := z.EncBinary() - _ = yym4260 + if yyq4274[0] { + yym4276 := z.EncBinary() + _ = yym4276 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -53140,23 +53343,23 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4258[0] { + if yyq4274[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4261 := z.EncBinary() - _ = yym4261 + yym4277 := z.EncBinary() + _ = yym4277 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4258 || yy2arr4258 { + if yyr4274 || yy2arr4274 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4258[1] { - yym4263 := z.EncBinary() - _ = yym4263 + if yyq4274[1] { + yym4279 := z.EncBinary() + _ = yym4279 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -53165,43 +53368,43 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4258[1] { + if yyq4274[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4264 := z.EncBinary() - _ = yym4264 + yym4280 := z.EncBinary() + _ = yym4280 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4258 || yy2arr4258 { + if yyr4274 || yy2arr4274 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4258[2] { - yy4266 := &x.ObjectMeta - yy4266.CodecEncodeSelf(e) + if yyq4274[2] { + yy4282 := &x.ObjectMeta + yy4282.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4258[2] { + if yyq4274[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4267 := &x.ObjectMeta - yy4267.CodecEncodeSelf(e) + yy4283 := &x.ObjectMeta + yy4283.CodecEncodeSelf(e) } } - if yyr4258 || yy2arr4258 { + if yyr4274 || yy2arr4274 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4258[3] { + if yyq4274[3] { if x.Data == nil { r.EncodeNil() } else { - yym4269 := z.EncBinary() - _ = yym4269 + yym4285 := z.EncBinary() + _ = yym4285 if false { } else { z.F.EncMapStringStringV(x.Data, false, e) @@ -53211,15 +53414,15 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4258[3] { + if yyq4274[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("data")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.Data == nil { r.EncodeNil() } else { - yym4270 := z.EncBinary() - _ = yym4270 + yym4286 := z.EncBinary() + _ = yym4286 if false { } else { z.F.EncMapStringStringV(x.Data, false, e) @@ -53227,7 +53430,7 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4258 || yy2arr4258 { + if yyr4274 || yy2arr4274 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -53240,25 +53443,25 @@ func (x *ConfigMap) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4271 := z.DecBinary() - _ = yym4271 + yym4287 := z.DecBinary() + _ = yym4287 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4272 := r.ContainerType() - if yyct4272 == codecSelferValueTypeMap1234 { - yyl4272 := r.ReadMapStart() - if yyl4272 == 0 { + yyct4288 := r.ContainerType() + if yyct4288 == codecSelferValueTypeMap1234 { + yyl4288 := r.ReadMapStart() + if yyl4288 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4272, d) + x.codecDecodeSelfFromMap(yyl4288, d) } - } else if yyct4272 == codecSelferValueTypeArray1234 { - yyl4272 := r.ReadArrayStart() - if yyl4272 == 0 { + } else if yyct4288 == codecSelferValueTypeArray1234 { + yyl4288 := r.ReadArrayStart() + if yyl4288 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4272, d) + x.codecDecodeSelfFromArray(yyl4288, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -53270,12 +53473,12 @@ func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4273Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4273Slc - var yyhl4273 bool = l >= 0 - for yyj4273 := 0; ; yyj4273++ { - if yyhl4273 { - if yyj4273 >= l { + var yys4289Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4289Slc + var yyhl4289 bool = l >= 0 + for yyj4289 := 0; ; yyj4289++ { + if yyhl4289 { + if yyj4289 >= l { break } } else { @@ -53284,10 +53487,10 @@ func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4273Slc = r.DecodeBytes(yys4273Slc, true, true) - yys4273 := string(yys4273Slc) + yys4289Slc = r.DecodeBytes(yys4289Slc, true, true) + yys4289 := string(yys4289Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4273 { + switch yys4289 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -53304,25 +53507,25 @@ func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4276 := &x.ObjectMeta - yyv4276.CodecDecodeSelf(d) + yyv4292 := &x.ObjectMeta + yyv4292.CodecDecodeSelf(d) } case "data": if r.TryDecodeAsNil() { x.Data = nil } else { - yyv4277 := &x.Data - yym4278 := z.DecBinary() - _ = yym4278 + yyv4293 := &x.Data + yym4294 := z.DecBinary() + _ = yym4294 if false { } else { - z.F.DecMapStringStringX(yyv4277, false, d) + z.F.DecMapStringStringX(yyv4293, false, d) } } default: - z.DecStructFieldNotFound(-1, yys4273) - } // end switch yys4273 - } // end for yyj4273 + z.DecStructFieldNotFound(-1, yys4289) + } // end switch yys4289 + } // end for yyj4289 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -53330,16 +53533,16 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4279 int - var yyb4279 bool - var yyhl4279 bool = l >= 0 - yyj4279++ - if yyhl4279 { - yyb4279 = yyj4279 > l + var yyj4295 int + var yyb4295 bool + var yyhl4295 bool = l >= 0 + yyj4295++ + if yyhl4295 { + yyb4295 = yyj4295 > l } else { - yyb4279 = r.CheckBreak() + yyb4295 = r.CheckBreak() } - if yyb4279 { + if yyb4295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53349,13 +53552,13 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4279++ - if yyhl4279 { - yyb4279 = yyj4279 > l + yyj4295++ + if yyhl4295 { + yyb4295 = yyj4295 > l } else { - yyb4279 = r.CheckBreak() + yyb4295 = r.CheckBreak() } - if yyb4279 { + if yyb4295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53365,13 +53568,13 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4279++ - if yyhl4279 { - yyb4279 = yyj4279 > l + yyj4295++ + if yyhl4295 { + yyb4295 = yyj4295 > l } else { - yyb4279 = r.CheckBreak() + yyb4295 = r.CheckBreak() } - if yyb4279 { + if yyb4295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53379,16 +53582,16 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4282 := &x.ObjectMeta - yyv4282.CodecDecodeSelf(d) + yyv4298 := &x.ObjectMeta + yyv4298.CodecDecodeSelf(d) } - yyj4279++ - if yyhl4279 { - yyb4279 = yyj4279 > l + yyj4295++ + if yyhl4295 { + yyb4295 = yyj4295 > l } else { - yyb4279 = r.CheckBreak() + yyb4295 = r.CheckBreak() } - if yyb4279 { + if yyb4295 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53396,26 +53599,26 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Data = nil } else { - yyv4283 := &x.Data - yym4284 := z.DecBinary() - _ = yym4284 + yyv4299 := &x.Data + yym4300 := z.DecBinary() + _ = yym4300 if false { } else { - z.F.DecMapStringStringX(yyv4283, false, d) + z.F.DecMapStringStringX(yyv4299, false, d) } } for { - yyj4279++ - if yyhl4279 { - yyb4279 = yyj4279 > l + yyj4295++ + if yyhl4295 { + yyb4295 = yyj4295 > l } else { - yyb4279 = r.CheckBreak() + yyb4295 = r.CheckBreak() } - if yyb4279 { + if yyb4295 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4279-1, "") + z.DecStructFieldNotFound(yyj4295-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -53427,37 +53630,37 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4285 := z.EncBinary() - _ = yym4285 + yym4301 := z.EncBinary() + _ = yym4301 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4286 := !z.EncBinary() - yy2arr4286 := z.EncBasicHandle().StructToArray - var yyq4286 [4]bool - _, _, _ = yysep4286, yyq4286, yy2arr4286 - const yyr4286 bool = false - yyq4286[0] = x.Kind != "" - yyq4286[1] = x.APIVersion != "" - yyq4286[2] = true - var yynn4286 int - if yyr4286 || yy2arr4286 { + yysep4302 := !z.EncBinary() + yy2arr4302 := z.EncBasicHandle().StructToArray + var yyq4302 [4]bool + _, _, _ = yysep4302, yyq4302, yy2arr4302 + const yyr4302 bool = false + yyq4302[0] = x.Kind != "" + yyq4302[1] = x.APIVersion != "" + yyq4302[2] = true + var yynn4302 int + if yyr4302 || yy2arr4302 { r.EncodeArrayStart(4) } else { - yynn4286 = 1 - for _, b := range yyq4286 { + yynn4302 = 1 + for _, b := range yyq4302 { if b { - yynn4286++ + yynn4302++ } } - r.EncodeMapStart(yynn4286) - yynn4286 = 0 + r.EncodeMapStart(yynn4302) + yynn4302 = 0 } - if yyr4286 || yy2arr4286 { + if yyr4302 || yy2arr4302 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4286[0] { - yym4288 := z.EncBinary() - _ = yym4288 + if yyq4302[0] { + yym4304 := z.EncBinary() + _ = yym4304 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -53466,23 +53669,23 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4286[0] { + if yyq4302[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4289 := z.EncBinary() - _ = yym4289 + yym4305 := z.EncBinary() + _ = yym4305 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4286 || yy2arr4286 { + if yyr4302 || yy2arr4302 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4286[1] { - yym4291 := z.EncBinary() - _ = yym4291 + if yyq4302[1] { + yym4307 := z.EncBinary() + _ = yym4307 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -53491,54 +53694,54 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4286[1] { + if yyq4302[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4292 := z.EncBinary() - _ = yym4292 + yym4308 := z.EncBinary() + _ = yym4308 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4286 || yy2arr4286 { + if yyr4302 || yy2arr4302 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4286[2] { - yy4294 := &x.ListMeta - yym4295 := z.EncBinary() - _ = yym4295 + if yyq4302[2] { + yy4310 := &x.ListMeta + yym4311 := z.EncBinary() + _ = yym4311 if false { - } else if z.HasExtensions() && z.EncExt(yy4294) { + } else if z.HasExtensions() && z.EncExt(yy4310) { } else { - z.EncFallback(yy4294) + z.EncFallback(yy4310) } } else { r.EncodeNil() } } else { - if yyq4286[2] { + if yyq4302[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4296 := &x.ListMeta - yym4297 := z.EncBinary() - _ = yym4297 + yy4312 := &x.ListMeta + yym4313 := z.EncBinary() + _ = yym4313 if false { - } else if z.HasExtensions() && z.EncExt(yy4296) { + } else if z.HasExtensions() && z.EncExt(yy4312) { } else { - z.EncFallback(yy4296) + z.EncFallback(yy4312) } } } - if yyr4286 || yy2arr4286 { + if yyr4302 || yy2arr4302 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym4299 := z.EncBinary() - _ = yym4299 + yym4315 := z.EncBinary() + _ = yym4315 if false { } else { h.encSliceConfigMap(([]ConfigMap)(x.Items), e) @@ -53551,15 +53754,15 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym4300 := z.EncBinary() - _ = yym4300 + yym4316 := z.EncBinary() + _ = yym4316 if false { } else { h.encSliceConfigMap(([]ConfigMap)(x.Items), e) } } } - if yyr4286 || yy2arr4286 { + if yyr4302 || yy2arr4302 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -53572,25 +53775,25 @@ func (x *ConfigMapList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4301 := z.DecBinary() - _ = yym4301 + yym4317 := z.DecBinary() + _ = yym4317 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4302 := r.ContainerType() - if yyct4302 == codecSelferValueTypeMap1234 { - yyl4302 := r.ReadMapStart() - if yyl4302 == 0 { + yyct4318 := r.ContainerType() + if yyct4318 == codecSelferValueTypeMap1234 { + yyl4318 := r.ReadMapStart() + if yyl4318 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4302, d) + x.codecDecodeSelfFromMap(yyl4318, d) } - } else if yyct4302 == codecSelferValueTypeArray1234 { - yyl4302 := r.ReadArrayStart() - if yyl4302 == 0 { + } else if yyct4318 == codecSelferValueTypeArray1234 { + yyl4318 := r.ReadArrayStart() + if yyl4318 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4302, d) + x.codecDecodeSelfFromArray(yyl4318, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -53602,12 +53805,12 @@ func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4303Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4303Slc - var yyhl4303 bool = l >= 0 - for yyj4303 := 0; ; yyj4303++ { - if yyhl4303 { - if yyj4303 >= l { + var yys4319Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4319Slc + var yyhl4319 bool = l >= 0 + for yyj4319 := 0; ; yyj4319++ { + if yyhl4319 { + if yyj4319 >= l { break } } else { @@ -53616,10 +53819,10 @@ func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4303Slc = r.DecodeBytes(yys4303Slc, true, true) - yys4303 := string(yys4303Slc) + yys4319Slc = r.DecodeBytes(yys4319Slc, true, true) + yys4319 := string(yys4319Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4303 { + switch yys4319 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -53636,31 +53839,31 @@ func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4306 := &x.ListMeta - yym4307 := z.DecBinary() - _ = yym4307 + yyv4322 := &x.ListMeta + yym4323 := z.DecBinary() + _ = yym4323 if false { - } else if z.HasExtensions() && z.DecExt(yyv4306) { + } else if z.HasExtensions() && z.DecExt(yyv4322) { } else { - z.DecFallback(yyv4306, false) + z.DecFallback(yyv4322, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4308 := &x.Items - yym4309 := z.DecBinary() - _ = yym4309 + yyv4324 := &x.Items + yym4325 := z.DecBinary() + _ = yym4325 if false { } else { - h.decSliceConfigMap((*[]ConfigMap)(yyv4308), d) + h.decSliceConfigMap((*[]ConfigMap)(yyv4324), d) } } default: - z.DecStructFieldNotFound(-1, yys4303) - } // end switch yys4303 - } // end for yyj4303 + z.DecStructFieldNotFound(-1, yys4319) + } // end switch yys4319 + } // end for yyj4319 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -53668,16 +53871,16 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4310 int - var yyb4310 bool - var yyhl4310 bool = l >= 0 - yyj4310++ - if yyhl4310 { - yyb4310 = yyj4310 > l + var yyj4326 int + var yyb4326 bool + var yyhl4326 bool = l >= 0 + yyj4326++ + if yyhl4326 { + yyb4326 = yyj4326 > l } else { - yyb4310 = r.CheckBreak() + yyb4326 = r.CheckBreak() } - if yyb4310 { + if yyb4326 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53687,13 +53890,13 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Kind = string(r.DecodeString()) } - yyj4310++ - if yyhl4310 { - yyb4310 = yyj4310 > l + yyj4326++ + if yyhl4326 { + yyb4326 = yyj4326 > l } else { - yyb4310 = r.CheckBreak() + yyb4326 = r.CheckBreak() } - if yyb4310 { + if yyb4326 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53703,13 +53906,13 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.APIVersion = string(r.DecodeString()) } - yyj4310++ - if yyhl4310 { - yyb4310 = yyj4310 > l + yyj4326++ + if yyhl4326 { + yyb4326 = yyj4326 > l } else { - yyb4310 = r.CheckBreak() + yyb4326 = r.CheckBreak() } - if yyb4310 { + if yyb4326 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53717,22 +53920,22 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4313 := &x.ListMeta - yym4314 := z.DecBinary() - _ = yym4314 + yyv4329 := &x.ListMeta + yym4330 := z.DecBinary() + _ = yym4330 if false { - } else if z.HasExtensions() && z.DecExt(yyv4313) { + } else if z.HasExtensions() && z.DecExt(yyv4329) { } else { - z.DecFallback(yyv4313, false) + z.DecFallback(yyv4329, false) } } - yyj4310++ - if yyhl4310 { - yyb4310 = yyj4310 > l + yyj4326++ + if yyhl4326 { + yyb4326 = yyj4326 > l } else { - yyb4310 = r.CheckBreak() + yyb4326 = r.CheckBreak() } - if yyb4310 { + if yyb4326 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -53740,26 +53943,26 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4315 := &x.Items - yym4316 := z.DecBinary() - _ = yym4316 + yyv4331 := &x.Items + yym4332 := z.DecBinary() + _ = yym4332 if false { } else { - h.decSliceConfigMap((*[]ConfigMap)(yyv4315), d) + h.decSliceConfigMap((*[]ConfigMap)(yyv4331), d) } } for { - yyj4310++ - if yyhl4310 { - yyb4310 = yyj4310 > l + yyj4326++ + if yyhl4326 { + yyb4326 = yyj4326 > l } else { - yyb4310 = r.CheckBreak() + yyb4326 = r.CheckBreak() } - if yyb4310 { + if yyb4326 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4310-1, "") + z.DecStructFieldNotFound(yyj4326-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -53768,8 +53971,8 @@ func (x PatchType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym4317 := z.EncBinary() - _ = yym4317 + yym4333 := z.EncBinary() + _ = yym4333 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -53781,8 +53984,8 @@ func (x *PatchType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4318 := z.DecBinary() - _ = yym4318 + yym4334 := z.DecBinary() + _ = yym4334 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -53794,8 +53997,8 @@ func (x ComponentConditionType) CodecEncodeSelf(e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r - yym4319 := z.EncBinary() - _ = yym4319 + yym4335 := z.EncBinary() + _ = yym4335 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { @@ -53807,8 +54010,8 @@ func (x *ComponentConditionType) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4320 := z.DecBinary() - _ = yym4320 + yym4336 := z.DecBinary() + _ = yym4336 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { @@ -53823,32 +54026,32 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4321 := z.EncBinary() - _ = yym4321 + yym4337 := z.EncBinary() + _ = yym4337 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4322 := !z.EncBinary() - yy2arr4322 := z.EncBasicHandle().StructToArray - var yyq4322 [4]bool - _, _, _ = yysep4322, yyq4322, yy2arr4322 - const yyr4322 bool = false - yyq4322[2] = x.Message != "" - yyq4322[3] = x.Error != "" - var yynn4322 int - if yyr4322 || yy2arr4322 { + yysep4338 := !z.EncBinary() + yy2arr4338 := z.EncBasicHandle().StructToArray + var yyq4338 [4]bool + _, _, _ = yysep4338, yyq4338, yy2arr4338 + const yyr4338 bool = false + yyq4338[2] = x.Message != "" + yyq4338[3] = x.Error != "" + var yynn4338 int + if yyr4338 || yy2arr4338 { r.EncodeArrayStart(4) } else { - yynn4322 = 2 - for _, b := range yyq4322 { + yynn4338 = 2 + for _, b := range yyq4338 { if b { - yynn4322++ + yynn4338++ } } - r.EncodeMapStart(yynn4322) - yynn4322 = 0 + r.EncodeMapStart(yynn4338) + yynn4338 = 0 } - if yyr4322 || yy2arr4322 { + if yyr4338 || yy2arr4338 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Type.CodecEncodeSelf(e) } else { @@ -53857,7 +54060,7 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Type.CodecEncodeSelf(e) } - if yyr4322 || yy2arr4322 { + if yyr4338 || yy2arr4338 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) x.Status.CodecEncodeSelf(e) } else { @@ -53866,11 +54069,11 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapValue1234) x.Status.CodecEncodeSelf(e) } - if yyr4322 || yy2arr4322 { + if yyr4338 || yy2arr4338 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4322[2] { - yym4326 := z.EncBinary() - _ = yym4326 + if yyq4338[2] { + yym4342 := z.EncBinary() + _ = yym4342 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) @@ -53879,23 +54082,23 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4322[2] { + if yyq4338[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("message")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4327 := z.EncBinary() - _ = yym4327 + yym4343 := z.EncBinary() + _ = yym4343 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Message)) } } } - if yyr4322 || yy2arr4322 { + if yyr4338 || yy2arr4338 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4322[3] { - yym4329 := z.EncBinary() - _ = yym4329 + if yyq4338[3] { + yym4345 := z.EncBinary() + _ = yym4345 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Error)) @@ -53904,19 +54107,19 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4322[3] { + if yyq4338[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("error")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4330 := z.EncBinary() - _ = yym4330 + yym4346 := z.EncBinary() + _ = yym4346 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Error)) } } } - if yyr4322 || yy2arr4322 { + if yyr4338 || yy2arr4338 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -53929,25 +54132,25 @@ func (x *ComponentCondition) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4331 := z.DecBinary() - _ = yym4331 + yym4347 := z.DecBinary() + _ = yym4347 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4332 := r.ContainerType() - if yyct4332 == codecSelferValueTypeMap1234 { - yyl4332 := r.ReadMapStart() - if yyl4332 == 0 { + yyct4348 := r.ContainerType() + if yyct4348 == codecSelferValueTypeMap1234 { + yyl4348 := r.ReadMapStart() + if yyl4348 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4332, d) + x.codecDecodeSelfFromMap(yyl4348, d) } - } else if yyct4332 == codecSelferValueTypeArray1234 { - yyl4332 := r.ReadArrayStart() - if yyl4332 == 0 { + } else if yyct4348 == codecSelferValueTypeArray1234 { + yyl4348 := r.ReadArrayStart() + if yyl4348 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4332, d) + x.codecDecodeSelfFromArray(yyl4348, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -53959,12 +54162,12 @@ func (x *ComponentCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4333Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4333Slc - var yyhl4333 bool = l >= 0 - for yyj4333 := 0; ; yyj4333++ { - if yyhl4333 { - if yyj4333 >= l { + var yys4349Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4349Slc + var yyhl4349 bool = l >= 0 + for yyj4349 := 0; ; yyj4349++ { + if yyhl4349 { + if yyj4349 >= l { break } } else { @@ -53973,10 +54176,10 @@ func (x *ComponentCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4333Slc = r.DecodeBytes(yys4333Slc, true, true) - yys4333 := string(yys4333Slc) + yys4349Slc = r.DecodeBytes(yys4349Slc, true, true) + yys4349 := string(yys4349Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4333 { + switch yys4349 { case "type": if r.TryDecodeAsNil() { x.Type = "" @@ -54002,9 +54205,9 @@ func (x *ComponentCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) x.Error = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys4333) - } // end switch yys4333 - } // end for yyj4333 + z.DecStructFieldNotFound(-1, yys4349) + } // end switch yys4349 + } // end for yyj4349 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -54012,16 +54215,16 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4338 int - var yyb4338 bool - var yyhl4338 bool = l >= 0 - yyj4338++ - if yyhl4338 { - yyb4338 = yyj4338 > l + var yyj4354 int + var yyb4354 bool + var yyhl4354 bool = l >= 0 + yyj4354++ + if yyhl4354 { + yyb4354 = yyj4354 > l } else { - yyb4338 = r.CheckBreak() + yyb4354 = r.CheckBreak() } - if yyb4338 { + if yyb4354 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54031,13 +54234,13 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.Type = ComponentConditionType(r.DecodeString()) } - yyj4338++ - if yyhl4338 { - yyb4338 = yyj4338 > l + yyj4354++ + if yyhl4354 { + yyb4354 = yyj4354 > l } else { - yyb4338 = r.CheckBreak() + yyb4354 = r.CheckBreak() } - if yyb4338 { + if yyb4354 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54047,13 +54250,13 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.Status = ConditionStatus(r.DecodeString()) } - yyj4338++ - if yyhl4338 { - yyb4338 = yyj4338 > l + yyj4354++ + if yyhl4354 { + yyb4354 = yyj4354 > l } else { - yyb4338 = r.CheckBreak() + yyb4354 = r.CheckBreak() } - if yyb4338 { + if yyb4354 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54063,13 +54266,13 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode } else { x.Message = string(r.DecodeString()) } - yyj4338++ - if yyhl4338 { - yyb4338 = yyj4338 > l + yyj4354++ + if yyhl4354 { + yyb4354 = yyj4354 > l } else { - yyb4338 = r.CheckBreak() + yyb4354 = r.CheckBreak() } - if yyb4338 { + if yyb4354 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54080,17 +54283,17 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode x.Error = string(r.DecodeString()) } for { - yyj4338++ - if yyhl4338 { - yyb4338 = yyj4338 > l + yyj4354++ + if yyhl4354 { + yyb4354 = yyj4354 > l } else { - yyb4338 = r.CheckBreak() + yyb4354 = r.CheckBreak() } - if yyb4338 { + if yyb4354 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4338-1, "") + z.DecStructFieldNotFound(yyj4354-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -54102,38 +54305,38 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4343 := z.EncBinary() - _ = yym4343 + yym4359 := z.EncBinary() + _ = yym4359 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4344 := !z.EncBinary() - yy2arr4344 := z.EncBasicHandle().StructToArray - var yyq4344 [4]bool - _, _, _ = yysep4344, yyq4344, yy2arr4344 - const yyr4344 bool = false - yyq4344[0] = x.Kind != "" - yyq4344[1] = x.APIVersion != "" - yyq4344[2] = true - yyq4344[3] = len(x.Conditions) != 0 - var yynn4344 int - if yyr4344 || yy2arr4344 { + yysep4360 := !z.EncBinary() + yy2arr4360 := z.EncBasicHandle().StructToArray + var yyq4360 [4]bool + _, _, _ = yysep4360, yyq4360, yy2arr4360 + const yyr4360 bool = false + yyq4360[0] = x.Kind != "" + yyq4360[1] = x.APIVersion != "" + yyq4360[2] = true + yyq4360[3] = len(x.Conditions) != 0 + var yynn4360 int + if yyr4360 || yy2arr4360 { r.EncodeArrayStart(4) } else { - yynn4344 = 0 - for _, b := range yyq4344 { + yynn4360 = 0 + for _, b := range yyq4360 { if b { - yynn4344++ + yynn4360++ } } - r.EncodeMapStart(yynn4344) - yynn4344 = 0 + r.EncodeMapStart(yynn4360) + yynn4360 = 0 } - if yyr4344 || yy2arr4344 { + if yyr4360 || yy2arr4360 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4344[0] { - yym4346 := z.EncBinary() - _ = yym4346 + if yyq4360[0] { + yym4362 := z.EncBinary() + _ = yym4362 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -54142,23 +54345,23 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4344[0] { + if yyq4360[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4347 := z.EncBinary() - _ = yym4347 + yym4363 := z.EncBinary() + _ = yym4363 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4344 || yy2arr4344 { + if yyr4360 || yy2arr4360 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4344[1] { - yym4349 := z.EncBinary() - _ = yym4349 + if yyq4360[1] { + yym4365 := z.EncBinary() + _ = yym4365 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -54167,43 +54370,43 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4344[1] { + if yyq4360[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4350 := z.EncBinary() - _ = yym4350 + yym4366 := z.EncBinary() + _ = yym4366 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4344 || yy2arr4344 { + if yyr4360 || yy2arr4360 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4344[2] { - yy4352 := &x.ObjectMeta - yy4352.CodecEncodeSelf(e) + if yyq4360[2] { + yy4368 := &x.ObjectMeta + yy4368.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4344[2] { + if yyq4360[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4353 := &x.ObjectMeta - yy4353.CodecEncodeSelf(e) + yy4369 := &x.ObjectMeta + yy4369.CodecEncodeSelf(e) } } - if yyr4344 || yy2arr4344 { + if yyr4360 || yy2arr4360 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4344[3] { + if yyq4360[3] { if x.Conditions == nil { r.EncodeNil() } else { - yym4355 := z.EncBinary() - _ = yym4355 + yym4371 := z.EncBinary() + _ = yym4371 if false { } else { h.encSliceComponentCondition(([]ComponentCondition)(x.Conditions), e) @@ -54213,15 +54416,15 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4344[3] { + if yyq4360[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("conditions")) z.EncSendContainerState(codecSelfer_containerMapValue1234) if x.Conditions == nil { r.EncodeNil() } else { - yym4356 := z.EncBinary() - _ = yym4356 + yym4372 := z.EncBinary() + _ = yym4372 if false { } else { h.encSliceComponentCondition(([]ComponentCondition)(x.Conditions), e) @@ -54229,7 +54432,7 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4344 || yy2arr4344 { + if yyr4360 || yy2arr4360 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -54242,25 +54445,25 @@ func (x *ComponentStatus) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4357 := z.DecBinary() - _ = yym4357 + yym4373 := z.DecBinary() + _ = yym4373 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4358 := r.ContainerType() - if yyct4358 == codecSelferValueTypeMap1234 { - yyl4358 := r.ReadMapStart() - if yyl4358 == 0 { + yyct4374 := r.ContainerType() + if yyct4374 == codecSelferValueTypeMap1234 { + yyl4374 := r.ReadMapStart() + if yyl4374 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4358, d) + x.codecDecodeSelfFromMap(yyl4374, d) } - } else if yyct4358 == codecSelferValueTypeArray1234 { - yyl4358 := r.ReadArrayStart() - if yyl4358 == 0 { + } else if yyct4374 == codecSelferValueTypeArray1234 { + yyl4374 := r.ReadArrayStart() + if yyl4374 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4358, d) + x.codecDecodeSelfFromArray(yyl4374, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -54272,12 +54475,12 @@ func (x *ComponentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4359Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4359Slc - var yyhl4359 bool = l >= 0 - for yyj4359 := 0; ; yyj4359++ { - if yyhl4359 { - if yyj4359 >= l { + var yys4375Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4375Slc + var yyhl4375 bool = l >= 0 + for yyj4375 := 0; ; yyj4375++ { + if yyhl4375 { + if yyj4375 >= l { break } } else { @@ -54286,10 +54489,10 @@ func (x *ComponentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4359Slc = r.DecodeBytes(yys4359Slc, true, true) - yys4359 := string(yys4359Slc) + yys4375Slc = r.DecodeBytes(yys4375Slc, true, true) + yys4375 := string(yys4375Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4359 { + switch yys4375 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -54306,25 +54509,25 @@ func (x *ComponentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4362 := &x.ObjectMeta - yyv4362.CodecDecodeSelf(d) + yyv4378 := &x.ObjectMeta + yyv4378.CodecDecodeSelf(d) } case "conditions": if r.TryDecodeAsNil() { x.Conditions = nil } else { - yyv4363 := &x.Conditions - yym4364 := z.DecBinary() - _ = yym4364 + yyv4379 := &x.Conditions + yym4380 := z.DecBinary() + _ = yym4380 if false { } else { - h.decSliceComponentCondition((*[]ComponentCondition)(yyv4363), d) + h.decSliceComponentCondition((*[]ComponentCondition)(yyv4379), d) } } default: - z.DecStructFieldNotFound(-1, yys4359) - } // end switch yys4359 - } // end for yyj4359 + z.DecStructFieldNotFound(-1, yys4375) + } // end switch yys4375 + } // end for yyj4375 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -54332,16 +54535,16 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4365 int - var yyb4365 bool - var yyhl4365 bool = l >= 0 - yyj4365++ - if yyhl4365 { - yyb4365 = yyj4365 > l + var yyj4381 int + var yyb4381 bool + var yyhl4381 bool = l >= 0 + yyj4381++ + if yyhl4381 { + yyb4381 = yyj4381 > l } else { - yyb4365 = r.CheckBreak() + yyb4381 = r.CheckBreak() } - if yyb4365 { + if yyb4381 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54351,13 +54554,13 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj4365++ - if yyhl4365 { - yyb4365 = yyj4365 > l + yyj4381++ + if yyhl4381 { + yyb4381 = yyj4381 > l } else { - yyb4365 = r.CheckBreak() + yyb4381 = r.CheckBreak() } - if yyb4365 { + if yyb4381 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54367,13 +54570,13 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj4365++ - if yyhl4365 { - yyb4365 = yyj4365 > l + yyj4381++ + if yyhl4381 { + yyb4381 = yyj4381 > l } else { - yyb4365 = r.CheckBreak() + yyb4381 = r.CheckBreak() } - if yyb4365 { + if yyb4381 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54381,16 +54584,16 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4368 := &x.ObjectMeta - yyv4368.CodecDecodeSelf(d) + yyv4384 := &x.ObjectMeta + yyv4384.CodecDecodeSelf(d) } - yyj4365++ - if yyhl4365 { - yyb4365 = yyj4365 > l + yyj4381++ + if yyhl4381 { + yyb4381 = yyj4381 > l } else { - yyb4365 = r.CheckBreak() + yyb4381 = r.CheckBreak() } - if yyb4365 { + if yyb4381 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54398,26 +54601,26 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.Conditions = nil } else { - yyv4369 := &x.Conditions - yym4370 := z.DecBinary() - _ = yym4370 + yyv4385 := &x.Conditions + yym4386 := z.DecBinary() + _ = yym4386 if false { } else { - h.decSliceComponentCondition((*[]ComponentCondition)(yyv4369), d) + h.decSliceComponentCondition((*[]ComponentCondition)(yyv4385), d) } } for { - yyj4365++ - if yyhl4365 { - yyb4365 = yyj4365 > l + yyj4381++ + if yyhl4381 { + yyb4381 = yyj4381 > l } else { - yyb4365 = r.CheckBreak() + yyb4381 = r.CheckBreak() } - if yyb4365 { + if yyb4381 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4365-1, "") + z.DecStructFieldNotFound(yyj4381-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -54429,37 +54632,37 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4371 := z.EncBinary() - _ = yym4371 + yym4387 := z.EncBinary() + _ = yym4387 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4372 := !z.EncBinary() - yy2arr4372 := z.EncBasicHandle().StructToArray - var yyq4372 [4]bool - _, _, _ = yysep4372, yyq4372, yy2arr4372 - const yyr4372 bool = false - yyq4372[0] = x.Kind != "" - yyq4372[1] = x.APIVersion != "" - yyq4372[2] = true - var yynn4372 int - if yyr4372 || yy2arr4372 { + yysep4388 := !z.EncBinary() + yy2arr4388 := z.EncBasicHandle().StructToArray + var yyq4388 [4]bool + _, _, _ = yysep4388, yyq4388, yy2arr4388 + const yyr4388 bool = false + yyq4388[0] = x.Kind != "" + yyq4388[1] = x.APIVersion != "" + yyq4388[2] = true + var yynn4388 int + if yyr4388 || yy2arr4388 { r.EncodeArrayStart(4) } else { - yynn4372 = 1 - for _, b := range yyq4372 { + yynn4388 = 1 + for _, b := range yyq4388 { if b { - yynn4372++ + yynn4388++ } } - r.EncodeMapStart(yynn4372) - yynn4372 = 0 + r.EncodeMapStart(yynn4388) + yynn4388 = 0 } - if yyr4372 || yy2arr4372 { + if yyr4388 || yy2arr4388 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4372[0] { - yym4374 := z.EncBinary() - _ = yym4374 + if yyq4388[0] { + yym4390 := z.EncBinary() + _ = yym4390 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -54468,23 +54671,23 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4372[0] { + if yyq4388[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4375 := z.EncBinary() - _ = yym4375 + yym4391 := z.EncBinary() + _ = yym4391 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4372 || yy2arr4372 { + if yyr4388 || yy2arr4388 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4372[1] { - yym4377 := z.EncBinary() - _ = yym4377 + if yyq4388[1] { + yym4393 := z.EncBinary() + _ = yym4393 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -54493,54 +54696,54 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4372[1] { + if yyq4388[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4378 := z.EncBinary() - _ = yym4378 + yym4394 := z.EncBinary() + _ = yym4394 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4372 || yy2arr4372 { + if yyr4388 || yy2arr4388 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4372[2] { - yy4380 := &x.ListMeta - yym4381 := z.EncBinary() - _ = yym4381 + if yyq4388[2] { + yy4396 := &x.ListMeta + yym4397 := z.EncBinary() + _ = yym4397 if false { - } else if z.HasExtensions() && z.EncExt(yy4380) { + } else if z.HasExtensions() && z.EncExt(yy4396) { } else { - z.EncFallback(yy4380) + z.EncFallback(yy4396) } } else { r.EncodeNil() } } else { - if yyq4372[2] { + if yyq4388[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4382 := &x.ListMeta - yym4383 := z.EncBinary() - _ = yym4383 + yy4398 := &x.ListMeta + yym4399 := z.EncBinary() + _ = yym4399 if false { - } else if z.HasExtensions() && z.EncExt(yy4382) { + } else if z.HasExtensions() && z.EncExt(yy4398) { } else { - z.EncFallback(yy4382) + z.EncFallback(yy4398) } } } - if yyr4372 || yy2arr4372 { + if yyr4388 || yy2arr4388 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Items == nil { r.EncodeNil() } else { - yym4385 := z.EncBinary() - _ = yym4385 + yym4401 := z.EncBinary() + _ = yym4401 if false { } else { h.encSliceComponentStatus(([]ComponentStatus)(x.Items), e) @@ -54553,15 +54756,15 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) { if x.Items == nil { r.EncodeNil() } else { - yym4386 := z.EncBinary() - _ = yym4386 + yym4402 := z.EncBinary() + _ = yym4402 if false { } else { h.encSliceComponentStatus(([]ComponentStatus)(x.Items), e) } } } - if yyr4372 || yy2arr4372 { + if yyr4388 || yy2arr4388 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -54574,25 +54777,25 @@ func (x *ComponentStatusList) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4387 := z.DecBinary() - _ = yym4387 + yym4403 := z.DecBinary() + _ = yym4403 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4388 := r.ContainerType() - if yyct4388 == codecSelferValueTypeMap1234 { - yyl4388 := r.ReadMapStart() - if yyl4388 == 0 { + yyct4404 := r.ContainerType() + if yyct4404 == codecSelferValueTypeMap1234 { + yyl4404 := r.ReadMapStart() + if yyl4404 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4388, d) + x.codecDecodeSelfFromMap(yyl4404, d) } - } else if yyct4388 == codecSelferValueTypeArray1234 { - yyl4388 := r.ReadArrayStart() - if yyl4388 == 0 { + } else if yyct4404 == codecSelferValueTypeArray1234 { + yyl4404 := r.ReadArrayStart() + if yyl4404 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4388, d) + x.codecDecodeSelfFromArray(yyl4404, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -54604,12 +54807,12 @@ func (x *ComponentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4389Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4389Slc - var yyhl4389 bool = l >= 0 - for yyj4389 := 0; ; yyj4389++ { - if yyhl4389 { - if yyj4389 >= l { + var yys4405Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4405Slc + var yyhl4405 bool = l >= 0 + for yyj4405 := 0; ; yyj4405++ { + if yyhl4405 { + if yyj4405 >= l { break } } else { @@ -54618,10 +54821,10 @@ func (x *ComponentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4389Slc = r.DecodeBytes(yys4389Slc, true, true) - yys4389 := string(yys4389Slc) + yys4405Slc = r.DecodeBytes(yys4405Slc, true, true) + yys4405 := string(yys4405Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4389 { + switch yys4405 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -54638,31 +54841,31 @@ func (x *ComponentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4392 := &x.ListMeta - yym4393 := z.DecBinary() - _ = yym4393 + yyv4408 := &x.ListMeta + yym4409 := z.DecBinary() + _ = yym4409 if false { - } else if z.HasExtensions() && z.DecExt(yyv4392) { + } else if z.HasExtensions() && z.DecExt(yyv4408) { } else { - z.DecFallback(yyv4392, false) + z.DecFallback(yyv4408, false) } } case "items": if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4394 := &x.Items - yym4395 := z.DecBinary() - _ = yym4395 + yyv4410 := &x.Items + yym4411 := z.DecBinary() + _ = yym4411 if false { } else { - h.decSliceComponentStatus((*[]ComponentStatus)(yyv4394), d) + h.decSliceComponentStatus((*[]ComponentStatus)(yyv4410), d) } } default: - z.DecStructFieldNotFound(-1, yys4389) - } // end switch yys4389 - } // end for yyj4389 + z.DecStructFieldNotFound(-1, yys4405) + } // end switch yys4405 + } // end for yyj4405 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -54670,16 +54873,16 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4396 int - var yyb4396 bool - var yyhl4396 bool = l >= 0 - yyj4396++ - if yyhl4396 { - yyb4396 = yyj4396 > l + var yyj4412 int + var yyb4412 bool + var yyhl4412 bool = l >= 0 + yyj4412++ + if yyhl4412 { + yyb4412 = yyj4412 > l } else { - yyb4396 = r.CheckBreak() + yyb4412 = r.CheckBreak() } - if yyb4396 { + if yyb4412 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54689,13 +54892,13 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.Kind = string(r.DecodeString()) } - yyj4396++ - if yyhl4396 { - yyb4396 = yyj4396 > l + yyj4412++ + if yyhl4412 { + yyb4412 = yyj4412 > l } else { - yyb4396 = r.CheckBreak() + yyb4412 = r.CheckBreak() } - if yyb4396 { + if yyb4412 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54705,13 +54908,13 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.APIVersion = string(r.DecodeString()) } - yyj4396++ - if yyhl4396 { - yyb4396 = yyj4396 > l + yyj4412++ + if yyhl4412 { + yyb4412 = yyj4412 > l } else { - yyb4396 = r.CheckBreak() + yyb4412 = r.CheckBreak() } - if yyb4396 { + if yyb4412 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54719,22 +54922,22 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.ListMeta = pkg2_unversioned.ListMeta{} } else { - yyv4399 := &x.ListMeta - yym4400 := z.DecBinary() - _ = yym4400 + yyv4415 := &x.ListMeta + yym4416 := z.DecBinary() + _ = yym4416 if false { - } else if z.HasExtensions() && z.DecExt(yyv4399) { + } else if z.HasExtensions() && z.DecExt(yyv4415) { } else { - z.DecFallback(yyv4399, false) + z.DecFallback(yyv4415, false) } } - yyj4396++ - if yyhl4396 { - yyb4396 = yyj4396 > l + yyj4412++ + if yyhl4412 { + yyb4412 = yyj4412 > l } else { - yyb4396 = r.CheckBreak() + yyb4412 = r.CheckBreak() } - if yyb4396 { + if yyb4412 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -54742,26 +54945,26 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.Items = nil } else { - yyv4401 := &x.Items - yym4402 := z.DecBinary() - _ = yym4402 + yyv4417 := &x.Items + yym4418 := z.DecBinary() + _ = yym4418 if false { } else { - h.decSliceComponentStatus((*[]ComponentStatus)(yyv4401), d) + h.decSliceComponentStatus((*[]ComponentStatus)(yyv4417), d) } } for { - yyj4396++ - if yyhl4396 { - yyb4396 = yyj4396 > l + yyj4412++ + if yyhl4412 { + yyb4412 = yyj4412 > l } else { - yyb4396 = r.CheckBreak() + yyb4412 = r.CheckBreak() } - if yyb4396 { + if yyb4412 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4396-1, "") + z.DecStructFieldNotFound(yyj4412-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -54773,38 +54976,38 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4403 := z.EncBinary() - _ = yym4403 + yym4419 := z.EncBinary() + _ = yym4419 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4404 := !z.EncBinary() - yy2arr4404 := z.EncBasicHandle().StructToArray - var yyq4404 [6]bool - _, _, _ = yysep4404, yyq4404, yy2arr4404 - const yyr4404 bool = false - yyq4404[0] = x.Capabilities != nil - yyq4404[1] = x.Privileged != nil - yyq4404[2] = x.SELinuxOptions != nil - yyq4404[3] = x.RunAsUser != nil - yyq4404[4] = x.RunAsNonRoot != nil - yyq4404[5] = x.ReadOnlyRootFilesystem != nil - var yynn4404 int - if yyr4404 || yy2arr4404 { + yysep4420 := !z.EncBinary() + yy2arr4420 := z.EncBasicHandle().StructToArray + var yyq4420 [6]bool + _, _, _ = yysep4420, yyq4420, yy2arr4420 + const yyr4420 bool = false + yyq4420[0] = x.Capabilities != nil + yyq4420[1] = x.Privileged != nil + yyq4420[2] = x.SELinuxOptions != nil + yyq4420[3] = x.RunAsUser != nil + yyq4420[4] = x.RunAsNonRoot != nil + yyq4420[5] = x.ReadOnlyRootFilesystem != nil + var yynn4420 int + if yyr4420 || yy2arr4420 { r.EncodeArrayStart(6) } else { - yynn4404 = 0 - for _, b := range yyq4404 { + yynn4420 = 0 + for _, b := range yyq4420 { if b { - yynn4404++ + yynn4420++ } } - r.EncodeMapStart(yynn4404) - yynn4404 = 0 + r.EncodeMapStart(yynn4420) + yynn4420 = 0 } - if yyr4404 || yy2arr4404 { + if yyr4420 || yy2arr4420 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4404[0] { + if yyq4420[0] { if x.Capabilities == nil { r.EncodeNil() } else { @@ -54814,7 +55017,7 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4404[0] { + if yyq4420[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("capabilities")) z.EncSendContainerState(codecSelfer_containerMapValue1234) @@ -54825,141 +55028,13 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4404 || yy2arr4404 { + if yyr4420 || yy2arr4420 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4404[1] { + if yyq4420[1] { if x.Privileged == nil { r.EncodeNil() } else { - yy4407 := *x.Privileged - yym4408 := z.EncBinary() - _ = yym4408 - if false { - } else { - r.EncodeBool(bool(yy4407)) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq4404[1] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("privileged")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.Privileged == nil { - r.EncodeNil() - } else { - yy4409 := *x.Privileged - yym4410 := z.EncBinary() - _ = yym4410 - if false { - } else { - r.EncodeBool(bool(yy4409)) - } - } - } - } - if yyr4404 || yy2arr4404 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4404[2] { - if x.SELinuxOptions == nil { - r.EncodeNil() - } else { - x.SELinuxOptions.CodecEncodeSelf(e) - } - } else { - r.EncodeNil() - } - } else { - if yyq4404[2] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.SELinuxOptions == nil { - r.EncodeNil() - } else { - x.SELinuxOptions.CodecEncodeSelf(e) - } - } - } - if yyr4404 || yy2arr4404 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4404[3] { - if x.RunAsUser == nil { - r.EncodeNil() - } else { - yy4413 := *x.RunAsUser - yym4414 := z.EncBinary() - _ = yym4414 - if false { - } else { - r.EncodeInt(int64(yy4413)) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq4404[3] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("runAsUser")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.RunAsUser == nil { - r.EncodeNil() - } else { - yy4415 := *x.RunAsUser - yym4416 := z.EncBinary() - _ = yym4416 - if false { - } else { - r.EncodeInt(int64(yy4415)) - } - } - } - } - if yyr4404 || yy2arr4404 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4404[4] { - if x.RunAsNonRoot == nil { - r.EncodeNil() - } else { - yy4418 := *x.RunAsNonRoot - yym4419 := z.EncBinary() - _ = yym4419 - if false { - } else { - r.EncodeBool(bool(yy4418)) - } - } - } else { - r.EncodeNil() - } - } else { - if yyq4404[4] { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("runAsNonRoot")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.RunAsNonRoot == nil { - r.EncodeNil() - } else { - yy4420 := *x.RunAsNonRoot - yym4421 := z.EncBinary() - _ = yym4421 - if false { - } else { - r.EncodeBool(bool(yy4420)) - } - } - } - } - if yyr4404 || yy2arr4404 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4404[5] { - if x.ReadOnlyRootFilesystem == nil { - r.EncodeNil() - } else { - yy4423 := *x.ReadOnlyRootFilesystem + yy4423 := *x.Privileged yym4424 := z.EncBinary() _ = yym4424 if false { @@ -54971,14 +55046,14 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeNil() } } else { - if yyq4404[5] { + if yyq4420[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem")) + r.EncodeString(codecSelferC_UTF81234, string("privileged")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - if x.ReadOnlyRootFilesystem == nil { + if x.Privileged == nil { r.EncodeNil() } else { - yy4425 := *x.ReadOnlyRootFilesystem + yy4425 := *x.Privileged yym4426 := z.EncBinary() _ = yym4426 if false { @@ -54988,7 +55063,135 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) { } } } - if yyr4404 || yy2arr4404 { + if yyr4420 || yy2arr4420 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq4420[2] { + if x.SELinuxOptions == nil { + r.EncodeNil() + } else { + x.SELinuxOptions.CodecEncodeSelf(e) + } + } else { + r.EncodeNil() + } + } else { + if yyq4420[2] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.SELinuxOptions == nil { + r.EncodeNil() + } else { + x.SELinuxOptions.CodecEncodeSelf(e) + } + } + } + if yyr4420 || yy2arr4420 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq4420[3] { + if x.RunAsUser == nil { + r.EncodeNil() + } else { + yy4429 := *x.RunAsUser + yym4430 := z.EncBinary() + _ = yym4430 + if false { + } else { + r.EncodeInt(int64(yy4429)) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq4420[3] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("runAsUser")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.RunAsUser == nil { + r.EncodeNil() + } else { + yy4431 := *x.RunAsUser + yym4432 := z.EncBinary() + _ = yym4432 + if false { + } else { + r.EncodeInt(int64(yy4431)) + } + } + } + } + if yyr4420 || yy2arr4420 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq4420[4] { + if x.RunAsNonRoot == nil { + r.EncodeNil() + } else { + yy4434 := *x.RunAsNonRoot + yym4435 := z.EncBinary() + _ = yym4435 + if false { + } else { + r.EncodeBool(bool(yy4434)) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq4420[4] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("runAsNonRoot")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.RunAsNonRoot == nil { + r.EncodeNil() + } else { + yy4436 := *x.RunAsNonRoot + yym4437 := z.EncBinary() + _ = yym4437 + if false { + } else { + r.EncodeBool(bool(yy4436)) + } + } + } + } + if yyr4420 || yy2arr4420 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq4420[5] { + if x.ReadOnlyRootFilesystem == nil { + r.EncodeNil() + } else { + yy4439 := *x.ReadOnlyRootFilesystem + yym4440 := z.EncBinary() + _ = yym4440 + if false { + } else { + r.EncodeBool(bool(yy4439)) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq4420[5] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.ReadOnlyRootFilesystem == nil { + r.EncodeNil() + } else { + yy4441 := *x.ReadOnlyRootFilesystem + yym4442 := z.EncBinary() + _ = yym4442 + if false { + } else { + r.EncodeBool(bool(yy4441)) + } + } + } + } + if yyr4420 || yy2arr4420 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -55001,25 +55204,25 @@ func (x *SecurityContext) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4427 := z.DecBinary() - _ = yym4427 + yym4443 := z.DecBinary() + _ = yym4443 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4428 := r.ContainerType() - if yyct4428 == codecSelferValueTypeMap1234 { - yyl4428 := r.ReadMapStart() - if yyl4428 == 0 { + yyct4444 := r.ContainerType() + if yyct4444 == codecSelferValueTypeMap1234 { + yyl4444 := r.ReadMapStart() + if yyl4444 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4428, d) + x.codecDecodeSelfFromMap(yyl4444, d) } - } else if yyct4428 == codecSelferValueTypeArray1234 { - yyl4428 := r.ReadArrayStart() - if yyl4428 == 0 { + } else if yyct4444 == codecSelferValueTypeArray1234 { + yyl4444 := r.ReadArrayStart() + if yyl4444 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4428, d) + x.codecDecodeSelfFromArray(yyl4444, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -55031,12 +55234,12 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4429Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4429Slc - var yyhl4429 bool = l >= 0 - for yyj4429 := 0; ; yyj4429++ { - if yyhl4429 { - if yyj4429 >= l { + var yys4445Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4445Slc + var yyhl4445 bool = l >= 0 + for yyj4445 := 0; ; yyj4445++ { + if yyhl4445 { + if yyj4445 >= l { break } } else { @@ -55045,10 +55248,10 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4429Slc = r.DecodeBytes(yys4429Slc, true, true) - yys4429 := string(yys4429Slc) + yys4445Slc = r.DecodeBytes(yys4445Slc, true, true) + yys4445 := string(yys4445Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4429 { + switch yys4445 { case "capabilities": if r.TryDecodeAsNil() { if x.Capabilities != nil { @@ -55069,8 +55272,8 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.Privileged == nil { x.Privileged = new(bool) } - yym4432 := z.DecBinary() - _ = yym4432 + yym4448 := z.DecBinary() + _ = yym4448 if false { } else { *((*bool)(x.Privileged)) = r.DecodeBool() @@ -55096,8 +55299,8 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.RunAsUser == nil { x.RunAsUser = new(int64) } - yym4435 := z.DecBinary() - _ = yym4435 + yym4451 := z.DecBinary() + _ = yym4451 if false { } else { *((*int64)(x.RunAsUser)) = int64(r.DecodeInt(64)) @@ -55112,8 +55315,8 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.RunAsNonRoot == nil { x.RunAsNonRoot = new(bool) } - yym4437 := z.DecBinary() - _ = yym4437 + yym4453 := z.DecBinary() + _ = yym4453 if false { } else { *((*bool)(x.RunAsNonRoot)) = r.DecodeBool() @@ -55128,17 +55331,17 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if x.ReadOnlyRootFilesystem == nil { x.ReadOnlyRootFilesystem = new(bool) } - yym4439 := z.DecBinary() - _ = yym4439 + yym4455 := z.DecBinary() + _ = yym4455 if false { } else { *((*bool)(x.ReadOnlyRootFilesystem)) = r.DecodeBool() } } default: - z.DecStructFieldNotFound(-1, yys4429) - } // end switch yys4429 - } // end for yyj4429 + z.DecStructFieldNotFound(-1, yys4445) + } // end switch yys4445 + } // end for yyj4445 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -55146,16 +55349,16 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4440 int - var yyb4440 bool - var yyhl4440 bool = l >= 0 - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + var yyj4456 int + var yyb4456 bool + var yyhl4456 bool = l >= 0 + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55170,13 +55373,13 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } x.Capabilities.CodecDecodeSelf(d) } - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55189,20 +55392,20 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if x.Privileged == nil { x.Privileged = new(bool) } - yym4443 := z.DecBinary() - _ = yym4443 + yym4459 := z.DecBinary() + _ = yym4459 if false { } else { *((*bool)(x.Privileged)) = r.DecodeBool() } } - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55217,13 +55420,13 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } x.SELinuxOptions.CodecDecodeSelf(d) } - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55236,20 +55439,20 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if x.RunAsUser == nil { x.RunAsUser = new(int64) } - yym4446 := z.DecBinary() - _ = yym4446 + yym4462 := z.DecBinary() + _ = yym4462 if false { } else { *((*int64)(x.RunAsUser)) = int64(r.DecodeInt(64)) } } - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55262,20 +55465,20 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if x.RunAsNonRoot == nil { x.RunAsNonRoot = new(bool) } - yym4448 := z.DecBinary() - _ = yym4448 + yym4464 := z.DecBinary() + _ = yym4464 if false { } else { *((*bool)(x.RunAsNonRoot)) = r.DecodeBool() } } - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55288,25 +55491,25 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if x.ReadOnlyRootFilesystem == nil { x.ReadOnlyRootFilesystem = new(bool) } - yym4450 := z.DecBinary() - _ = yym4450 + yym4466 := z.DecBinary() + _ = yym4466 if false { } else { *((*bool)(x.ReadOnlyRootFilesystem)) = r.DecodeBool() } } for { - yyj4440++ - if yyhl4440 { - yyb4440 = yyj4440 > l + yyj4456++ + if yyhl4456 { + yyb4456 = yyj4456 > l } else { - yyb4440 = r.CheckBreak() + yyb4456 = r.CheckBreak() } - if yyb4440 { + if yyb4456 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4440-1, "") + z.DecStructFieldNotFound(yyj4456-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -55318,38 +55521,38 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4451 := z.EncBinary() - _ = yym4451 + yym4467 := z.EncBinary() + _ = yym4467 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4452 := !z.EncBinary() - yy2arr4452 := z.EncBasicHandle().StructToArray - var yyq4452 [4]bool - _, _, _ = yysep4452, yyq4452, yy2arr4452 - const yyr4452 bool = false - yyq4452[0] = x.User != "" - yyq4452[1] = x.Role != "" - yyq4452[2] = x.Type != "" - yyq4452[3] = x.Level != "" - var yynn4452 int - if yyr4452 || yy2arr4452 { + yysep4468 := !z.EncBinary() + yy2arr4468 := z.EncBasicHandle().StructToArray + var yyq4468 [4]bool + _, _, _ = yysep4468, yyq4468, yy2arr4468 + const yyr4468 bool = false + yyq4468[0] = x.User != "" + yyq4468[1] = x.Role != "" + yyq4468[2] = x.Type != "" + yyq4468[3] = x.Level != "" + var yynn4468 int + if yyr4468 || yy2arr4468 { r.EncodeArrayStart(4) } else { - yynn4452 = 0 - for _, b := range yyq4452 { + yynn4468 = 0 + for _, b := range yyq4468 { if b { - yynn4452++ + yynn4468++ } } - r.EncodeMapStart(yynn4452) - yynn4452 = 0 + r.EncodeMapStart(yynn4468) + yynn4468 = 0 } - if yyr4452 || yy2arr4452 { + if yyr4468 || yy2arr4468 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4452[0] { - yym4454 := z.EncBinary() - _ = yym4454 + if yyq4468[0] { + yym4470 := z.EncBinary() + _ = yym4470 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.User)) @@ -55358,23 +55561,23 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4452[0] { + if yyq4468[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("user")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4455 := z.EncBinary() - _ = yym4455 + yym4471 := z.EncBinary() + _ = yym4471 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.User)) } } } - if yyr4452 || yy2arr4452 { + if yyr4468 || yy2arr4468 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4452[1] { - yym4457 := z.EncBinary() - _ = yym4457 + if yyq4468[1] { + yym4473 := z.EncBinary() + _ = yym4473 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Role)) @@ -55383,23 +55586,23 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4452[1] { + if yyq4468[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("role")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4458 := z.EncBinary() - _ = yym4458 + yym4474 := z.EncBinary() + _ = yym4474 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Role)) } } } - if yyr4452 || yy2arr4452 { + if yyr4468 || yy2arr4468 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4452[2] { - yym4460 := z.EncBinary() - _ = yym4460 + if yyq4468[2] { + yym4476 := z.EncBinary() + _ = yym4476 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Type)) @@ -55408,23 +55611,23 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4452[2] { + if yyq4468[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("type")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4461 := z.EncBinary() - _ = yym4461 + yym4477 := z.EncBinary() + _ = yym4477 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Type)) } } } - if yyr4452 || yy2arr4452 { + if yyr4468 || yy2arr4468 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4452[3] { - yym4463 := z.EncBinary() - _ = yym4463 + if yyq4468[3] { + yym4479 := z.EncBinary() + _ = yym4479 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Level)) @@ -55433,19 +55636,19 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4452[3] { + if yyq4468[3] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("level")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4464 := z.EncBinary() - _ = yym4464 + yym4480 := z.EncBinary() + _ = yym4480 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Level)) } } } - if yyr4452 || yy2arr4452 { + if yyr4468 || yy2arr4468 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -55458,25 +55661,25 @@ func (x *SELinuxOptions) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4465 := z.DecBinary() - _ = yym4465 + yym4481 := z.DecBinary() + _ = yym4481 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4466 := r.ContainerType() - if yyct4466 == codecSelferValueTypeMap1234 { - yyl4466 := r.ReadMapStart() - if yyl4466 == 0 { + yyct4482 := r.ContainerType() + if yyct4482 == codecSelferValueTypeMap1234 { + yyl4482 := r.ReadMapStart() + if yyl4482 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4466, d) + x.codecDecodeSelfFromMap(yyl4482, d) } - } else if yyct4466 == codecSelferValueTypeArray1234 { - yyl4466 := r.ReadArrayStart() - if yyl4466 == 0 { + } else if yyct4482 == codecSelferValueTypeArray1234 { + yyl4482 := r.ReadArrayStart() + if yyl4482 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4466, d) + x.codecDecodeSelfFromArray(yyl4482, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -55488,12 +55691,12 @@ func (x *SELinuxOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4467Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4467Slc - var yyhl4467 bool = l >= 0 - for yyj4467 := 0; ; yyj4467++ { - if yyhl4467 { - if yyj4467 >= l { + var yys4483Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4483Slc + var yyhl4483 bool = l >= 0 + for yyj4483 := 0; ; yyj4483++ { + if yyhl4483 { + if yyj4483 >= l { break } } else { @@ -55502,10 +55705,10 @@ func (x *SELinuxOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4467Slc = r.DecodeBytes(yys4467Slc, true, true) - yys4467 := string(yys4467Slc) + yys4483Slc = r.DecodeBytes(yys4483Slc, true, true) + yys4483 := string(yys4483Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4467 { + switch yys4483 { case "user": if r.TryDecodeAsNil() { x.User = "" @@ -55531,9 +55734,9 @@ func (x *SELinuxOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { x.Level = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys4467) - } // end switch yys4467 - } // end for yyj4467 + z.DecStructFieldNotFound(-1, yys4483) + } // end switch yys4483 + } // end for yyj4483 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -55541,16 +55744,16 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4472 int - var yyb4472 bool - var yyhl4472 bool = l >= 0 - yyj4472++ - if yyhl4472 { - yyb4472 = yyj4472 > l + var yyj4488 int + var yyb4488 bool + var yyhl4488 bool = l >= 0 + yyj4488++ + if yyhl4488 { + yyb4488 = yyj4488 > l } else { - yyb4472 = r.CheckBreak() + yyb4488 = r.CheckBreak() } - if yyb4472 { + if yyb4488 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55560,13 +55763,13 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.User = string(r.DecodeString()) } - yyj4472++ - if yyhl4472 { - yyb4472 = yyj4472 > l + yyj4488++ + if yyhl4488 { + yyb4488 = yyj4488 > l } else { - yyb4472 = r.CheckBreak() + yyb4488 = r.CheckBreak() } - if yyb4472 { + if yyb4488 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55576,13 +55779,13 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Role = string(r.DecodeString()) } - yyj4472++ - if yyhl4472 { - yyb4472 = yyj4472 > l + yyj4488++ + if yyhl4488 { + yyb4488 = yyj4488 > l } else { - yyb4472 = r.CheckBreak() + yyb4488 = r.CheckBreak() } - if yyb4472 { + if yyb4488 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55592,13 +55795,13 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { } else { x.Type = string(r.DecodeString()) } - yyj4472++ - if yyhl4472 { - yyb4472 = yyj4472 > l + yyj4488++ + if yyhl4488 { + yyb4488 = yyj4488 > l } else { - yyb4472 = r.CheckBreak() + yyb4488 = r.CheckBreak() } - if yyb4472 { + if yyb4488 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55609,17 +55812,17 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { x.Level = string(r.DecodeString()) } for { - yyj4472++ - if yyhl4472 { - yyb4472 = yyj4472 > l + yyj4488++ + if yyhl4488 { + yyb4488 = yyj4488 > l } else { - yyb4472 = r.CheckBreak() + yyb4488 = r.CheckBreak() } - if yyb4472 { + if yyb4488 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4472-1, "") + z.DecStructFieldNotFound(yyj4488-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -55631,37 +55834,37 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym4477 := z.EncBinary() - _ = yym4477 + yym4493 := z.EncBinary() + _ = yym4493 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep4478 := !z.EncBinary() - yy2arr4478 := z.EncBasicHandle().StructToArray - var yyq4478 [5]bool - _, _, _ = yysep4478, yyq4478, yy2arr4478 - const yyr4478 bool = false - yyq4478[0] = x.Kind != "" - yyq4478[1] = x.APIVersion != "" - yyq4478[2] = true - var yynn4478 int - if yyr4478 || yy2arr4478 { + yysep4494 := !z.EncBinary() + yy2arr4494 := z.EncBasicHandle().StructToArray + var yyq4494 [5]bool + _, _, _ = yysep4494, yyq4494, yy2arr4494 + const yyr4494 bool = false + yyq4494[0] = x.Kind != "" + yyq4494[1] = x.APIVersion != "" + yyq4494[2] = true + var yynn4494 int + if yyr4494 || yy2arr4494 { r.EncodeArrayStart(5) } else { - yynn4478 = 2 - for _, b := range yyq4478 { + yynn4494 = 2 + for _, b := range yyq4494 { if b { - yynn4478++ + yynn4494++ } } - r.EncodeMapStart(yynn4478) - yynn4478 = 0 + r.EncodeMapStart(yynn4494) + yynn4494 = 0 } - if yyr4478 || yy2arr4478 { + if yyr4494 || yy2arr4494 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4478[0] { - yym4480 := z.EncBinary() - _ = yym4480 + if yyq4494[0] { + yym4496 := z.EncBinary() + _ = yym4496 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -55670,23 +55873,23 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4478[0] { + if yyq4494[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4481 := z.EncBinary() - _ = yym4481 + yym4497 := z.EncBinary() + _ = yym4497 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr4478 || yy2arr4478 { + if yyr4494 || yy2arr4494 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4478[1] { - yym4483 := z.EncBinary() - _ = yym4483 + if yyq4494[1] { + yym4499 := z.EncBinary() + _ = yym4499 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -55695,39 +55898,39 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq4478[1] { + if yyq4494[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4484 := z.EncBinary() - _ = yym4484 + yym4500 := z.EncBinary() + _ = yym4500 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr4478 || yy2arr4478 { + if yyr4494 || yy2arr4494 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq4478[2] { - yy4486 := &x.ObjectMeta - yy4486.CodecEncodeSelf(e) + if yyq4494[2] { + yy4502 := &x.ObjectMeta + yy4502.CodecEncodeSelf(e) } else { r.EncodeNil() } } else { - if yyq4478[2] { + if yyq4494[2] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("metadata")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4487 := &x.ObjectMeta - yy4487.CodecEncodeSelf(e) + yy4503 := &x.ObjectMeta + yy4503.CodecEncodeSelf(e) } } - if yyr4478 || yy2arr4478 { + if yyr4494 || yy2arr4494 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym4489 := z.EncBinary() - _ = yym4489 + yym4505 := z.EncBinary() + _ = yym4505 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Range)) @@ -55736,20 +55939,20 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("range")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym4490 := z.EncBinary() - _ = yym4490 + yym4506 := z.EncBinary() + _ = yym4506 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Range)) } } - if yyr4478 || yy2arr4478 { + if yyr4494 || yy2arr4494 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) if x.Data == nil { r.EncodeNil() } else { - yym4492 := z.EncBinary() - _ = yym4492 + yym4508 := z.EncBinary() + _ = yym4508 if false { } else { r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data)) @@ -55762,15 +55965,15 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) { if x.Data == nil { r.EncodeNil() } else { - yym4493 := z.EncBinary() - _ = yym4493 + yym4509 := z.EncBinary() + _ = yym4509 if false { } else { r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data)) } } } - if yyr4478 || yy2arr4478 { + if yyr4494 || yy2arr4494 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -55783,25 +55986,25 @@ func (x *RangeAllocation) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym4494 := z.DecBinary() - _ = yym4494 + yym4510 := z.DecBinary() + _ = yym4510 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct4495 := r.ContainerType() - if yyct4495 == codecSelferValueTypeMap1234 { - yyl4495 := r.ReadMapStart() - if yyl4495 == 0 { + yyct4511 := r.ContainerType() + if yyct4511 == codecSelferValueTypeMap1234 { + yyl4511 := r.ReadMapStart() + if yyl4511 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl4495, d) + x.codecDecodeSelfFromMap(yyl4511, d) } - } else if yyct4495 == codecSelferValueTypeArray1234 { - yyl4495 := r.ReadArrayStart() - if yyl4495 == 0 { + } else if yyct4511 == codecSelferValueTypeArray1234 { + yyl4511 := r.ReadArrayStart() + if yyl4511 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl4495, d) + x.codecDecodeSelfFromArray(yyl4511, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -55813,12 +56016,12 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys4496Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys4496Slc - var yyhl4496 bool = l >= 0 - for yyj4496 := 0; ; yyj4496++ { - if yyhl4496 { - if yyj4496 >= l { + var yys4512Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys4512Slc + var yyhl4512 bool = l >= 0 + for yyj4512 := 0; ; yyj4512++ { + if yyhl4512 { + if yyj4512 >= l { break } } else { @@ -55827,10 +56030,10 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys4496Slc = r.DecodeBytes(yys4496Slc, true, true) - yys4496 := string(yys4496Slc) + yys4512Slc = r.DecodeBytes(yys4512Slc, true, true) + yys4512 := string(yys4512Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys4496 { + switch yys4512 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -55847,8 +56050,8 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4499 := &x.ObjectMeta - yyv4499.CodecDecodeSelf(d) + yyv4515 := &x.ObjectMeta + yyv4515.CodecDecodeSelf(d) } case "range": if r.TryDecodeAsNil() { @@ -55860,18 +56063,18 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { if r.TryDecodeAsNil() { x.Data = nil } else { - yyv4501 := &x.Data - yym4502 := z.DecBinary() - _ = yym4502 + yyv4517 := &x.Data + yym4518 := z.DecBinary() + _ = yym4518 if false { } else { - *yyv4501 = r.DecodeBytes(*(*[]byte)(yyv4501), false, false) + *yyv4517 = r.DecodeBytes(*(*[]byte)(yyv4517), false, false) } } default: - z.DecStructFieldNotFound(-1, yys4496) - } // end switch yys4496 - } // end for yyj4496 + z.DecStructFieldNotFound(-1, yys4512) + } // end switch yys4512 + } // end for yyj4512 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -55879,16 +56082,16 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj4503 int - var yyb4503 bool - var yyhl4503 bool = l >= 0 - yyj4503++ - if yyhl4503 { - yyb4503 = yyj4503 > l + var yyj4519 int + var yyb4519 bool + var yyhl4519 bool = l >= 0 + yyj4519++ + if yyhl4519 { + yyb4519 = yyj4519 > l } else { - yyb4503 = r.CheckBreak() + yyb4519 = r.CheckBreak() } - if yyb4503 { + if yyb4519 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55898,13 +56101,13 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Kind = string(r.DecodeString()) } - yyj4503++ - if yyhl4503 { - yyb4503 = yyj4503 > l + yyj4519++ + if yyhl4519 { + yyb4519 = yyj4519 > l } else { - yyb4503 = r.CheckBreak() + yyb4519 = r.CheckBreak() } - if yyb4503 { + if yyb4519 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55914,13 +56117,13 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.APIVersion = string(r.DecodeString()) } - yyj4503++ - if yyhl4503 { - yyb4503 = yyj4503 > l + yyj4519++ + if yyhl4519 { + yyb4519 = yyj4519 > l } else { - yyb4503 = r.CheckBreak() + yyb4519 = r.CheckBreak() } - if yyb4503 { + if yyb4519 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55928,16 +56131,16 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.ObjectMeta = ObjectMeta{} } else { - yyv4506 := &x.ObjectMeta - yyv4506.CodecDecodeSelf(d) + yyv4522 := &x.ObjectMeta + yyv4522.CodecDecodeSelf(d) } - yyj4503++ - if yyhl4503 { - yyb4503 = yyj4503 > l + yyj4519++ + if yyhl4519 { + yyb4519 = yyj4519 > l } else { - yyb4503 = r.CheckBreak() + yyb4519 = r.CheckBreak() } - if yyb4503 { + if yyb4519 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55947,13 +56150,13 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) } else { x.Range = string(r.DecodeString()) } - yyj4503++ - if yyhl4503 { - yyb4503 = yyj4503 > l + yyj4519++ + if yyhl4519 { + yyb4519 = yyj4519 > l } else { - yyb4503 = r.CheckBreak() + yyb4519 = r.CheckBreak() } - if yyb4503 { + if yyb4519 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -55961,26 +56164,26 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) if r.TryDecodeAsNil() { x.Data = nil } else { - yyv4508 := &x.Data - yym4509 := z.DecBinary() - _ = yym4509 + yyv4524 := &x.Data + yym4525 := z.DecBinary() + _ = yym4525 if false { } else { - *yyv4508 = r.DecodeBytes(*(*[]byte)(yyv4508), false, false) + *yyv4524 = r.DecodeBytes(*(*[]byte)(yyv4524), false, false) } } for { - yyj4503++ - if yyhl4503 { - yyb4503 = yyj4503 > l + yyj4519++ + if yyhl4519 { + yyb4519 = yyj4519 > l } else { - yyb4503 = r.CheckBreak() + yyb4519 = r.CheckBreak() } - if yyb4503 { + if yyb4519 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj4503-1, "") + z.DecStructFieldNotFound(yyj4519-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -55990,10 +56193,10 @@ func (x codecSelfer1234) encSliceOwnerReference(v []OwnerReference, e *codec1978 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4510 := range v { + for _, yyv4526 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4511 := &yyv4510 - yy4511.CodecEncodeSelf(e) + yy4527 := &yyv4526 + yy4527.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56003,83 +56206,83 @@ func (x codecSelfer1234) decSliceOwnerReference(v *[]OwnerReference, d *codec197 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4512 := *v - yyh4512, yyl4512 := z.DecSliceHelperStart() - var yyc4512 bool - if yyl4512 == 0 { - if yyv4512 == nil { - yyv4512 = []OwnerReference{} - yyc4512 = true - } else if len(yyv4512) != 0 { - yyv4512 = yyv4512[:0] - yyc4512 = true + yyv4528 := *v + yyh4528, yyl4528 := z.DecSliceHelperStart() + var yyc4528 bool + if yyl4528 == 0 { + if yyv4528 == nil { + yyv4528 = []OwnerReference{} + yyc4528 = true + } else if len(yyv4528) != 0 { + yyv4528 = yyv4528[:0] + yyc4528 = true } - } else if yyl4512 > 0 { - var yyrr4512, yyrl4512 int - var yyrt4512 bool - if yyl4512 > cap(yyv4512) { + } else if yyl4528 > 0 { + var yyrr4528, yyrl4528 int + var yyrt4528 bool + if yyl4528 > cap(yyv4528) { - yyrg4512 := len(yyv4512) > 0 - yyv24512 := yyv4512 - yyrl4512, yyrt4512 = z.DecInferLen(yyl4512, z.DecBasicHandle().MaxInitLen, 72) - if yyrt4512 { - if yyrl4512 <= cap(yyv4512) { - yyv4512 = yyv4512[:yyrl4512] + yyrg4528 := len(yyv4528) > 0 + yyv24528 := yyv4528 + yyrl4528, yyrt4528 = z.DecInferLen(yyl4528, z.DecBasicHandle().MaxInitLen, 72) + if yyrt4528 { + if yyrl4528 <= cap(yyv4528) { + yyv4528 = yyv4528[:yyrl4528] } else { - yyv4512 = make([]OwnerReference, yyrl4512) + yyv4528 = make([]OwnerReference, yyrl4528) } } else { - yyv4512 = make([]OwnerReference, yyrl4512) + yyv4528 = make([]OwnerReference, yyrl4528) } - yyc4512 = true - yyrr4512 = len(yyv4512) - if yyrg4512 { - copy(yyv4512, yyv24512) + yyc4528 = true + yyrr4528 = len(yyv4528) + if yyrg4528 { + copy(yyv4528, yyv24528) } - } else if yyl4512 != len(yyv4512) { - yyv4512 = yyv4512[:yyl4512] - yyc4512 = true + } else if yyl4528 != len(yyv4528) { + yyv4528 = yyv4528[:yyl4528] + yyc4528 = true } - yyj4512 := 0 - for ; yyj4512 < yyrr4512; yyj4512++ { - yyh4512.ElemContainerState(yyj4512) + yyj4528 := 0 + for ; yyj4528 < yyrr4528; yyj4528++ { + yyh4528.ElemContainerState(yyj4528) if r.TryDecodeAsNil() { - yyv4512[yyj4512] = OwnerReference{} + yyv4528[yyj4528] = OwnerReference{} } else { - yyv4513 := &yyv4512[yyj4512] - yyv4513.CodecDecodeSelf(d) + yyv4529 := &yyv4528[yyj4528] + yyv4529.CodecDecodeSelf(d) } } - if yyrt4512 { - for ; yyj4512 < yyl4512; yyj4512++ { - yyv4512 = append(yyv4512, OwnerReference{}) - yyh4512.ElemContainerState(yyj4512) + if yyrt4528 { + for ; yyj4528 < yyl4528; yyj4528++ { + yyv4528 = append(yyv4528, OwnerReference{}) + yyh4528.ElemContainerState(yyj4528) if r.TryDecodeAsNil() { - yyv4512[yyj4512] = OwnerReference{} + yyv4528[yyj4528] = OwnerReference{} } else { - yyv4514 := &yyv4512[yyj4512] - yyv4514.CodecDecodeSelf(d) + yyv4530 := &yyv4528[yyj4528] + yyv4530.CodecDecodeSelf(d) } } } } else { - yyj4512 := 0 - for ; !r.CheckBreak(); yyj4512++ { + yyj4528 := 0 + for ; !r.CheckBreak(); yyj4528++ { - if yyj4512 >= len(yyv4512) { - yyv4512 = append(yyv4512, OwnerReference{}) // var yyz4512 OwnerReference - yyc4512 = true + if yyj4528 >= len(yyv4528) { + yyv4528 = append(yyv4528, OwnerReference{}) // var yyz4528 OwnerReference + yyc4528 = true } - yyh4512.ElemContainerState(yyj4512) - if yyj4512 < len(yyv4512) { + yyh4528.ElemContainerState(yyj4528) + if yyj4528 < len(yyv4528) { if r.TryDecodeAsNil() { - yyv4512[yyj4512] = OwnerReference{} + yyv4528[yyj4528] = OwnerReference{} } else { - yyv4515 := &yyv4512[yyj4512] - yyv4515.CodecDecodeSelf(d) + yyv4531 := &yyv4528[yyj4528] + yyv4531.CodecDecodeSelf(d) } } else { @@ -56087,17 +56290,17 @@ func (x codecSelfer1234) decSliceOwnerReference(v *[]OwnerReference, d *codec197 } } - if yyj4512 < len(yyv4512) { - yyv4512 = yyv4512[:yyj4512] - yyc4512 = true - } else if yyj4512 == 0 && yyv4512 == nil { - yyv4512 = []OwnerReference{} - yyc4512 = true + if yyj4528 < len(yyv4528) { + yyv4528 = yyv4528[:yyj4528] + yyc4528 = true + } else if yyj4528 == 0 && yyv4528 == nil { + yyv4528 = []OwnerReference{} + yyc4528 = true } } - yyh4512.End() - if yyc4512 { - *v = yyv4512 + yyh4528.End() + if yyc4528 { + *v = yyv4528 } } @@ -56106,9 +56309,9 @@ func (x codecSelfer1234) encSlicePersistentVolumeAccessMode(v []PersistentVolume z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4516 := range v { + for _, yyv4532 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yyv4516.CodecEncodeSelf(e) + yyv4532.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56118,75 +56321,75 @@ func (x codecSelfer1234) decSlicePersistentVolumeAccessMode(v *[]PersistentVolum z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4517 := *v - yyh4517, yyl4517 := z.DecSliceHelperStart() - var yyc4517 bool - if yyl4517 == 0 { - if yyv4517 == nil { - yyv4517 = []PersistentVolumeAccessMode{} - yyc4517 = true - } else if len(yyv4517) != 0 { - yyv4517 = yyv4517[:0] - yyc4517 = true + yyv4533 := *v + yyh4533, yyl4533 := z.DecSliceHelperStart() + var yyc4533 bool + if yyl4533 == 0 { + if yyv4533 == nil { + yyv4533 = []PersistentVolumeAccessMode{} + yyc4533 = true + } else if len(yyv4533) != 0 { + yyv4533 = yyv4533[:0] + yyc4533 = true } - } else if yyl4517 > 0 { - var yyrr4517, yyrl4517 int - var yyrt4517 bool - if yyl4517 > cap(yyv4517) { + } else if yyl4533 > 0 { + var yyrr4533, yyrl4533 int + var yyrt4533 bool + if yyl4533 > cap(yyv4533) { - yyrl4517, yyrt4517 = z.DecInferLen(yyl4517, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4517 { - if yyrl4517 <= cap(yyv4517) { - yyv4517 = yyv4517[:yyrl4517] + yyrl4533, yyrt4533 = z.DecInferLen(yyl4533, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4533 { + if yyrl4533 <= cap(yyv4533) { + yyv4533 = yyv4533[:yyrl4533] } else { - yyv4517 = make([]PersistentVolumeAccessMode, yyrl4517) + yyv4533 = make([]PersistentVolumeAccessMode, yyrl4533) } } else { - yyv4517 = make([]PersistentVolumeAccessMode, yyrl4517) + yyv4533 = make([]PersistentVolumeAccessMode, yyrl4533) } - yyc4517 = true - yyrr4517 = len(yyv4517) - } else if yyl4517 != len(yyv4517) { - yyv4517 = yyv4517[:yyl4517] - yyc4517 = true + yyc4533 = true + yyrr4533 = len(yyv4533) + } else if yyl4533 != len(yyv4533) { + yyv4533 = yyv4533[:yyl4533] + yyc4533 = true } - yyj4517 := 0 - for ; yyj4517 < yyrr4517; yyj4517++ { - yyh4517.ElemContainerState(yyj4517) + yyj4533 := 0 + for ; yyj4533 < yyrr4533; yyj4533++ { + yyh4533.ElemContainerState(yyj4533) if r.TryDecodeAsNil() { - yyv4517[yyj4517] = "" + yyv4533[yyj4533] = "" } else { - yyv4517[yyj4517] = PersistentVolumeAccessMode(r.DecodeString()) + yyv4533[yyj4533] = PersistentVolumeAccessMode(r.DecodeString()) } } - if yyrt4517 { - for ; yyj4517 < yyl4517; yyj4517++ { - yyv4517 = append(yyv4517, "") - yyh4517.ElemContainerState(yyj4517) + if yyrt4533 { + for ; yyj4533 < yyl4533; yyj4533++ { + yyv4533 = append(yyv4533, "") + yyh4533.ElemContainerState(yyj4533) if r.TryDecodeAsNil() { - yyv4517[yyj4517] = "" + yyv4533[yyj4533] = "" } else { - yyv4517[yyj4517] = PersistentVolumeAccessMode(r.DecodeString()) + yyv4533[yyj4533] = PersistentVolumeAccessMode(r.DecodeString()) } } } } else { - yyj4517 := 0 - for ; !r.CheckBreak(); yyj4517++ { + yyj4533 := 0 + for ; !r.CheckBreak(); yyj4533++ { - if yyj4517 >= len(yyv4517) { - yyv4517 = append(yyv4517, "") // var yyz4517 PersistentVolumeAccessMode - yyc4517 = true + if yyj4533 >= len(yyv4533) { + yyv4533 = append(yyv4533, "") // var yyz4533 PersistentVolumeAccessMode + yyc4533 = true } - yyh4517.ElemContainerState(yyj4517) - if yyj4517 < len(yyv4517) { + yyh4533.ElemContainerState(yyj4533) + if yyj4533 < len(yyv4533) { if r.TryDecodeAsNil() { - yyv4517[yyj4517] = "" + yyv4533[yyj4533] = "" } else { - yyv4517[yyj4517] = PersistentVolumeAccessMode(r.DecodeString()) + yyv4533[yyj4533] = PersistentVolumeAccessMode(r.DecodeString()) } } else { @@ -56194,17 +56397,17 @@ func (x codecSelfer1234) decSlicePersistentVolumeAccessMode(v *[]PersistentVolum } } - if yyj4517 < len(yyv4517) { - yyv4517 = yyv4517[:yyj4517] - yyc4517 = true - } else if yyj4517 == 0 && yyv4517 == nil { - yyv4517 = []PersistentVolumeAccessMode{} - yyc4517 = true + if yyj4533 < len(yyv4533) { + yyv4533 = yyv4533[:yyj4533] + yyc4533 = true + } else if yyj4533 == 0 && yyv4533 == nil { + yyv4533 = []PersistentVolumeAccessMode{} + yyc4533 = true } } - yyh4517.End() - if yyc4517 { - *v = yyv4517 + yyh4533.End() + if yyc4533 { + *v = yyv4533 } } @@ -56213,10 +56416,10 @@ func (x codecSelfer1234) encSlicePersistentVolume(v []PersistentVolume, e *codec z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4521 := range v { + for _, yyv4537 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4522 := &yyv4521 - yy4522.CodecEncodeSelf(e) + yy4538 := &yyv4537 + yy4538.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56226,83 +56429,83 @@ func (x codecSelfer1234) decSlicePersistentVolume(v *[]PersistentVolume, d *code z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4523 := *v - yyh4523, yyl4523 := z.DecSliceHelperStart() - var yyc4523 bool - if yyl4523 == 0 { - if yyv4523 == nil { - yyv4523 = []PersistentVolume{} - yyc4523 = true - } else if len(yyv4523) != 0 { - yyv4523 = yyv4523[:0] - yyc4523 = true + yyv4539 := *v + yyh4539, yyl4539 := z.DecSliceHelperStart() + var yyc4539 bool + if yyl4539 == 0 { + if yyv4539 == nil { + yyv4539 = []PersistentVolume{} + yyc4539 = true + } else if len(yyv4539) != 0 { + yyv4539 = yyv4539[:0] + yyc4539 = true } - } else if yyl4523 > 0 { - var yyrr4523, yyrl4523 int - var yyrt4523 bool - if yyl4523 > cap(yyv4523) { + } else if yyl4539 > 0 { + var yyrr4539, yyrl4539 int + var yyrt4539 bool + if yyl4539 > cap(yyv4539) { - yyrg4523 := len(yyv4523) > 0 - yyv24523 := yyv4523 - yyrl4523, yyrt4523 = z.DecInferLen(yyl4523, z.DecBasicHandle().MaxInitLen, 488) - if yyrt4523 { - if yyrl4523 <= cap(yyv4523) { - yyv4523 = yyv4523[:yyrl4523] + yyrg4539 := len(yyv4539) > 0 + yyv24539 := yyv4539 + yyrl4539, yyrt4539 = z.DecInferLen(yyl4539, z.DecBasicHandle().MaxInitLen, 488) + if yyrt4539 { + if yyrl4539 <= cap(yyv4539) { + yyv4539 = yyv4539[:yyrl4539] } else { - yyv4523 = make([]PersistentVolume, yyrl4523) + yyv4539 = make([]PersistentVolume, yyrl4539) } } else { - yyv4523 = make([]PersistentVolume, yyrl4523) + yyv4539 = make([]PersistentVolume, yyrl4539) } - yyc4523 = true - yyrr4523 = len(yyv4523) - if yyrg4523 { - copy(yyv4523, yyv24523) + yyc4539 = true + yyrr4539 = len(yyv4539) + if yyrg4539 { + copy(yyv4539, yyv24539) } - } else if yyl4523 != len(yyv4523) { - yyv4523 = yyv4523[:yyl4523] - yyc4523 = true + } else if yyl4539 != len(yyv4539) { + yyv4539 = yyv4539[:yyl4539] + yyc4539 = true } - yyj4523 := 0 - for ; yyj4523 < yyrr4523; yyj4523++ { - yyh4523.ElemContainerState(yyj4523) + yyj4539 := 0 + for ; yyj4539 < yyrr4539; yyj4539++ { + yyh4539.ElemContainerState(yyj4539) if r.TryDecodeAsNil() { - yyv4523[yyj4523] = PersistentVolume{} + yyv4539[yyj4539] = PersistentVolume{} } else { - yyv4524 := &yyv4523[yyj4523] - yyv4524.CodecDecodeSelf(d) + yyv4540 := &yyv4539[yyj4539] + yyv4540.CodecDecodeSelf(d) } } - if yyrt4523 { - for ; yyj4523 < yyl4523; yyj4523++ { - yyv4523 = append(yyv4523, PersistentVolume{}) - yyh4523.ElemContainerState(yyj4523) + if yyrt4539 { + for ; yyj4539 < yyl4539; yyj4539++ { + yyv4539 = append(yyv4539, PersistentVolume{}) + yyh4539.ElemContainerState(yyj4539) if r.TryDecodeAsNil() { - yyv4523[yyj4523] = PersistentVolume{} + yyv4539[yyj4539] = PersistentVolume{} } else { - yyv4525 := &yyv4523[yyj4523] - yyv4525.CodecDecodeSelf(d) + yyv4541 := &yyv4539[yyj4539] + yyv4541.CodecDecodeSelf(d) } } } } else { - yyj4523 := 0 - for ; !r.CheckBreak(); yyj4523++ { + yyj4539 := 0 + for ; !r.CheckBreak(); yyj4539++ { - if yyj4523 >= len(yyv4523) { - yyv4523 = append(yyv4523, PersistentVolume{}) // var yyz4523 PersistentVolume - yyc4523 = true + if yyj4539 >= len(yyv4539) { + yyv4539 = append(yyv4539, PersistentVolume{}) // var yyz4539 PersistentVolume + yyc4539 = true } - yyh4523.ElemContainerState(yyj4523) - if yyj4523 < len(yyv4523) { + yyh4539.ElemContainerState(yyj4539) + if yyj4539 < len(yyv4539) { if r.TryDecodeAsNil() { - yyv4523[yyj4523] = PersistentVolume{} + yyv4539[yyj4539] = PersistentVolume{} } else { - yyv4526 := &yyv4523[yyj4523] - yyv4526.CodecDecodeSelf(d) + yyv4542 := &yyv4539[yyj4539] + yyv4542.CodecDecodeSelf(d) } } else { @@ -56310,17 +56513,17 @@ func (x codecSelfer1234) decSlicePersistentVolume(v *[]PersistentVolume, d *code } } - if yyj4523 < len(yyv4523) { - yyv4523 = yyv4523[:yyj4523] - yyc4523 = true - } else if yyj4523 == 0 && yyv4523 == nil { - yyv4523 = []PersistentVolume{} - yyc4523 = true + if yyj4539 < len(yyv4539) { + yyv4539 = yyv4539[:yyj4539] + yyc4539 = true + } else if yyj4539 == 0 && yyv4539 == nil { + yyv4539 = []PersistentVolume{} + yyc4539 = true } } - yyh4523.End() - if yyc4523 { - *v = yyv4523 + yyh4539.End() + if yyc4539 { + *v = yyv4539 } } @@ -56329,10 +56532,10 @@ func (x codecSelfer1234) encSlicePersistentVolumeClaim(v []PersistentVolumeClaim z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4527 := range v { + for _, yyv4543 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4528 := &yyv4527 - yy4528.CodecEncodeSelf(e) + yy4544 := &yyv4543 + yy4544.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56342,83 +56545,83 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4529 := *v - yyh4529, yyl4529 := z.DecSliceHelperStart() - var yyc4529 bool - if yyl4529 == 0 { - if yyv4529 == nil { - yyv4529 = []PersistentVolumeClaim{} - yyc4529 = true - } else if len(yyv4529) != 0 { - yyv4529 = yyv4529[:0] - yyc4529 = true + yyv4545 := *v + yyh4545, yyl4545 := z.DecSliceHelperStart() + var yyc4545 bool + if yyl4545 == 0 { + if yyv4545 == nil { + yyv4545 = []PersistentVolumeClaim{} + yyc4545 = true + } else if len(yyv4545) != 0 { + yyv4545 = yyv4545[:0] + yyc4545 = true } - } else if yyl4529 > 0 { - var yyrr4529, yyrl4529 int - var yyrt4529 bool - if yyl4529 > cap(yyv4529) { + } else if yyl4545 > 0 { + var yyrr4545, yyrl4545 int + var yyrt4545 bool + if yyl4545 > cap(yyv4545) { - yyrg4529 := len(yyv4529) > 0 - yyv24529 := yyv4529 - yyrl4529, yyrt4529 = z.DecInferLen(yyl4529, z.DecBasicHandle().MaxInitLen, 368) - if yyrt4529 { - if yyrl4529 <= cap(yyv4529) { - yyv4529 = yyv4529[:yyrl4529] + yyrg4545 := len(yyv4545) > 0 + yyv24545 := yyv4545 + yyrl4545, yyrt4545 = z.DecInferLen(yyl4545, z.DecBasicHandle().MaxInitLen, 368) + if yyrt4545 { + if yyrl4545 <= cap(yyv4545) { + yyv4545 = yyv4545[:yyrl4545] } else { - yyv4529 = make([]PersistentVolumeClaim, yyrl4529) + yyv4545 = make([]PersistentVolumeClaim, yyrl4545) } } else { - yyv4529 = make([]PersistentVolumeClaim, yyrl4529) + yyv4545 = make([]PersistentVolumeClaim, yyrl4545) } - yyc4529 = true - yyrr4529 = len(yyv4529) - if yyrg4529 { - copy(yyv4529, yyv24529) + yyc4545 = true + yyrr4545 = len(yyv4545) + if yyrg4545 { + copy(yyv4545, yyv24545) } - } else if yyl4529 != len(yyv4529) { - yyv4529 = yyv4529[:yyl4529] - yyc4529 = true + } else if yyl4545 != len(yyv4545) { + yyv4545 = yyv4545[:yyl4545] + yyc4545 = true } - yyj4529 := 0 - for ; yyj4529 < yyrr4529; yyj4529++ { - yyh4529.ElemContainerState(yyj4529) + yyj4545 := 0 + for ; yyj4545 < yyrr4545; yyj4545++ { + yyh4545.ElemContainerState(yyj4545) if r.TryDecodeAsNil() { - yyv4529[yyj4529] = PersistentVolumeClaim{} + yyv4545[yyj4545] = PersistentVolumeClaim{} } else { - yyv4530 := &yyv4529[yyj4529] - yyv4530.CodecDecodeSelf(d) + yyv4546 := &yyv4545[yyj4545] + yyv4546.CodecDecodeSelf(d) } } - if yyrt4529 { - for ; yyj4529 < yyl4529; yyj4529++ { - yyv4529 = append(yyv4529, PersistentVolumeClaim{}) - yyh4529.ElemContainerState(yyj4529) + if yyrt4545 { + for ; yyj4545 < yyl4545; yyj4545++ { + yyv4545 = append(yyv4545, PersistentVolumeClaim{}) + yyh4545.ElemContainerState(yyj4545) if r.TryDecodeAsNil() { - yyv4529[yyj4529] = PersistentVolumeClaim{} + yyv4545[yyj4545] = PersistentVolumeClaim{} } else { - yyv4531 := &yyv4529[yyj4529] - yyv4531.CodecDecodeSelf(d) + yyv4547 := &yyv4545[yyj4545] + yyv4547.CodecDecodeSelf(d) } } } } else { - yyj4529 := 0 - for ; !r.CheckBreak(); yyj4529++ { + yyj4545 := 0 + for ; !r.CheckBreak(); yyj4545++ { - if yyj4529 >= len(yyv4529) { - yyv4529 = append(yyv4529, PersistentVolumeClaim{}) // var yyz4529 PersistentVolumeClaim - yyc4529 = true + if yyj4545 >= len(yyv4545) { + yyv4545 = append(yyv4545, PersistentVolumeClaim{}) // var yyz4545 PersistentVolumeClaim + yyc4545 = true } - yyh4529.ElemContainerState(yyj4529) - if yyj4529 < len(yyv4529) { + yyh4545.ElemContainerState(yyj4545) + if yyj4545 < len(yyv4545) { if r.TryDecodeAsNil() { - yyv4529[yyj4529] = PersistentVolumeClaim{} + yyv4545[yyj4545] = PersistentVolumeClaim{} } else { - yyv4532 := &yyv4529[yyj4529] - yyv4532.CodecDecodeSelf(d) + yyv4548 := &yyv4545[yyj4545] + yyv4548.CodecDecodeSelf(d) } } else { @@ -56426,17 +56629,17 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai } } - if yyj4529 < len(yyv4529) { - yyv4529 = yyv4529[:yyj4529] - yyc4529 = true - } else if yyj4529 == 0 && yyv4529 == nil { - yyv4529 = []PersistentVolumeClaim{} - yyc4529 = true + if yyj4545 < len(yyv4545) { + yyv4545 = yyv4545[:yyj4545] + yyc4545 = true + } else if yyj4545 == 0 && yyv4545 == nil { + yyv4545 = []PersistentVolumeClaim{} + yyc4545 = true } } - yyh4529.End() - if yyc4529 { - *v = yyv4529 + yyh4545.End() + if yyc4545 { + *v = yyv4545 } } @@ -56445,10 +56648,10 @@ func (x codecSelfer1234) encSliceKeyToPath(v []KeyToPath, e *codec1978.Encoder) z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4533 := range v { + for _, yyv4549 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4534 := &yyv4533 - yy4534.CodecEncodeSelf(e) + yy4550 := &yyv4549 + yy4550.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56458,83 +56661,83 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder) z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4535 := *v - yyh4535, yyl4535 := z.DecSliceHelperStart() - var yyc4535 bool - if yyl4535 == 0 { - if yyv4535 == nil { - yyv4535 = []KeyToPath{} - yyc4535 = true - } else if len(yyv4535) != 0 { - yyv4535 = yyv4535[:0] - yyc4535 = true + yyv4551 := *v + yyh4551, yyl4551 := z.DecSliceHelperStart() + var yyc4551 bool + if yyl4551 == 0 { + if yyv4551 == nil { + yyv4551 = []KeyToPath{} + yyc4551 = true + } else if len(yyv4551) != 0 { + yyv4551 = yyv4551[:0] + yyc4551 = true } - } else if yyl4535 > 0 { - var yyrr4535, yyrl4535 int - var yyrt4535 bool - if yyl4535 > cap(yyv4535) { + } else if yyl4551 > 0 { + var yyrr4551, yyrl4551 int + var yyrt4551 bool + if yyl4551 > cap(yyv4551) { - yyrg4535 := len(yyv4535) > 0 - yyv24535 := yyv4535 - yyrl4535, yyrt4535 = z.DecInferLen(yyl4535, z.DecBasicHandle().MaxInitLen, 40) - if yyrt4535 { - if yyrl4535 <= cap(yyv4535) { - yyv4535 = yyv4535[:yyrl4535] + yyrg4551 := len(yyv4551) > 0 + yyv24551 := yyv4551 + yyrl4551, yyrt4551 = z.DecInferLen(yyl4551, z.DecBasicHandle().MaxInitLen, 40) + if yyrt4551 { + if yyrl4551 <= cap(yyv4551) { + yyv4551 = yyv4551[:yyrl4551] } else { - yyv4535 = make([]KeyToPath, yyrl4535) + yyv4551 = make([]KeyToPath, yyrl4551) } } else { - yyv4535 = make([]KeyToPath, yyrl4535) + yyv4551 = make([]KeyToPath, yyrl4551) } - yyc4535 = true - yyrr4535 = len(yyv4535) - if yyrg4535 { - copy(yyv4535, yyv24535) + yyc4551 = true + yyrr4551 = len(yyv4551) + if yyrg4551 { + copy(yyv4551, yyv24551) } - } else if yyl4535 != len(yyv4535) { - yyv4535 = yyv4535[:yyl4535] - yyc4535 = true + } else if yyl4551 != len(yyv4551) { + yyv4551 = yyv4551[:yyl4551] + yyc4551 = true } - yyj4535 := 0 - for ; yyj4535 < yyrr4535; yyj4535++ { - yyh4535.ElemContainerState(yyj4535) + yyj4551 := 0 + for ; yyj4551 < yyrr4551; yyj4551++ { + yyh4551.ElemContainerState(yyj4551) if r.TryDecodeAsNil() { - yyv4535[yyj4535] = KeyToPath{} + yyv4551[yyj4551] = KeyToPath{} } else { - yyv4536 := &yyv4535[yyj4535] - yyv4536.CodecDecodeSelf(d) + yyv4552 := &yyv4551[yyj4551] + yyv4552.CodecDecodeSelf(d) } } - if yyrt4535 { - for ; yyj4535 < yyl4535; yyj4535++ { - yyv4535 = append(yyv4535, KeyToPath{}) - yyh4535.ElemContainerState(yyj4535) + if yyrt4551 { + for ; yyj4551 < yyl4551; yyj4551++ { + yyv4551 = append(yyv4551, KeyToPath{}) + yyh4551.ElemContainerState(yyj4551) if r.TryDecodeAsNil() { - yyv4535[yyj4535] = KeyToPath{} + yyv4551[yyj4551] = KeyToPath{} } else { - yyv4537 := &yyv4535[yyj4535] - yyv4537.CodecDecodeSelf(d) + yyv4553 := &yyv4551[yyj4551] + yyv4553.CodecDecodeSelf(d) } } } } else { - yyj4535 := 0 - for ; !r.CheckBreak(); yyj4535++ { + yyj4551 := 0 + for ; !r.CheckBreak(); yyj4551++ { - if yyj4535 >= len(yyv4535) { - yyv4535 = append(yyv4535, KeyToPath{}) // var yyz4535 KeyToPath - yyc4535 = true + if yyj4551 >= len(yyv4551) { + yyv4551 = append(yyv4551, KeyToPath{}) // var yyz4551 KeyToPath + yyc4551 = true } - yyh4535.ElemContainerState(yyj4535) - if yyj4535 < len(yyv4535) { + yyh4551.ElemContainerState(yyj4551) + if yyj4551 < len(yyv4551) { if r.TryDecodeAsNil() { - yyv4535[yyj4535] = KeyToPath{} + yyv4551[yyj4551] = KeyToPath{} } else { - yyv4538 := &yyv4535[yyj4535] - yyv4538.CodecDecodeSelf(d) + yyv4554 := &yyv4551[yyj4551] + yyv4554.CodecDecodeSelf(d) } } else { @@ -56542,17 +56745,17 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder) } } - if yyj4535 < len(yyv4535) { - yyv4535 = yyv4535[:yyj4535] - yyc4535 = true - } else if yyj4535 == 0 && yyv4535 == nil { - yyv4535 = []KeyToPath{} - yyc4535 = true + if yyj4551 < len(yyv4551) { + yyv4551 = yyv4551[:yyj4551] + yyc4551 = true + } else if yyj4551 == 0 && yyv4551 == nil { + yyv4551 = []KeyToPath{} + yyc4551 = true } } - yyh4535.End() - if yyc4535 { - *v = yyv4535 + yyh4551.End() + if yyc4551 { + *v = yyv4551 } } @@ -56561,10 +56764,10 @@ func (x codecSelfer1234) encSliceDownwardAPIVolumeFile(v []DownwardAPIVolumeFile z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4539 := range v { + for _, yyv4555 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4540 := &yyv4539 - yy4540.CodecEncodeSelf(e) + yy4556 := &yyv4555 + yy4556.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56574,83 +56777,83 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4541 := *v - yyh4541, yyl4541 := z.DecSliceHelperStart() - var yyc4541 bool - if yyl4541 == 0 { - if yyv4541 == nil { - yyv4541 = []DownwardAPIVolumeFile{} - yyc4541 = true - } else if len(yyv4541) != 0 { - yyv4541 = yyv4541[:0] - yyc4541 = true + yyv4557 := *v + yyh4557, yyl4557 := z.DecSliceHelperStart() + var yyc4557 bool + if yyl4557 == 0 { + if yyv4557 == nil { + yyv4557 = []DownwardAPIVolumeFile{} + yyc4557 = true + } else if len(yyv4557) != 0 { + yyv4557 = yyv4557[:0] + yyc4557 = true } - } else if yyl4541 > 0 { - var yyrr4541, yyrl4541 int - var yyrt4541 bool - if yyl4541 > cap(yyv4541) { + } else if yyl4557 > 0 { + var yyrr4557, yyrl4557 int + var yyrt4557 bool + if yyl4557 > cap(yyv4557) { - yyrg4541 := len(yyv4541) > 0 - yyv24541 := yyv4541 - yyrl4541, yyrt4541 = z.DecInferLen(yyl4541, z.DecBasicHandle().MaxInitLen, 40) - if yyrt4541 { - if yyrl4541 <= cap(yyv4541) { - yyv4541 = yyv4541[:yyrl4541] + yyrg4557 := len(yyv4557) > 0 + yyv24557 := yyv4557 + yyrl4557, yyrt4557 = z.DecInferLen(yyl4557, z.DecBasicHandle().MaxInitLen, 40) + if yyrt4557 { + if yyrl4557 <= cap(yyv4557) { + yyv4557 = yyv4557[:yyrl4557] } else { - yyv4541 = make([]DownwardAPIVolumeFile, yyrl4541) + yyv4557 = make([]DownwardAPIVolumeFile, yyrl4557) } } else { - yyv4541 = make([]DownwardAPIVolumeFile, yyrl4541) + yyv4557 = make([]DownwardAPIVolumeFile, yyrl4557) } - yyc4541 = true - yyrr4541 = len(yyv4541) - if yyrg4541 { - copy(yyv4541, yyv24541) + yyc4557 = true + yyrr4557 = len(yyv4557) + if yyrg4557 { + copy(yyv4557, yyv24557) } - } else if yyl4541 != len(yyv4541) { - yyv4541 = yyv4541[:yyl4541] - yyc4541 = true + } else if yyl4557 != len(yyv4557) { + yyv4557 = yyv4557[:yyl4557] + yyc4557 = true } - yyj4541 := 0 - for ; yyj4541 < yyrr4541; yyj4541++ { - yyh4541.ElemContainerState(yyj4541) + yyj4557 := 0 + for ; yyj4557 < yyrr4557; yyj4557++ { + yyh4557.ElemContainerState(yyj4557) if r.TryDecodeAsNil() { - yyv4541[yyj4541] = DownwardAPIVolumeFile{} + yyv4557[yyj4557] = DownwardAPIVolumeFile{} } else { - yyv4542 := &yyv4541[yyj4541] - yyv4542.CodecDecodeSelf(d) + yyv4558 := &yyv4557[yyj4557] + yyv4558.CodecDecodeSelf(d) } } - if yyrt4541 { - for ; yyj4541 < yyl4541; yyj4541++ { - yyv4541 = append(yyv4541, DownwardAPIVolumeFile{}) - yyh4541.ElemContainerState(yyj4541) + if yyrt4557 { + for ; yyj4557 < yyl4557; yyj4557++ { + yyv4557 = append(yyv4557, DownwardAPIVolumeFile{}) + yyh4557.ElemContainerState(yyj4557) if r.TryDecodeAsNil() { - yyv4541[yyj4541] = DownwardAPIVolumeFile{} + yyv4557[yyj4557] = DownwardAPIVolumeFile{} } else { - yyv4543 := &yyv4541[yyj4541] - yyv4543.CodecDecodeSelf(d) + yyv4559 := &yyv4557[yyj4557] + yyv4559.CodecDecodeSelf(d) } } } } else { - yyj4541 := 0 - for ; !r.CheckBreak(); yyj4541++ { + yyj4557 := 0 + for ; !r.CheckBreak(); yyj4557++ { - if yyj4541 >= len(yyv4541) { - yyv4541 = append(yyv4541, DownwardAPIVolumeFile{}) // var yyz4541 DownwardAPIVolumeFile - yyc4541 = true + if yyj4557 >= len(yyv4557) { + yyv4557 = append(yyv4557, DownwardAPIVolumeFile{}) // var yyz4557 DownwardAPIVolumeFile + yyc4557 = true } - yyh4541.ElemContainerState(yyj4541) - if yyj4541 < len(yyv4541) { + yyh4557.ElemContainerState(yyj4557) + if yyj4557 < len(yyv4557) { if r.TryDecodeAsNil() { - yyv4541[yyj4541] = DownwardAPIVolumeFile{} + yyv4557[yyj4557] = DownwardAPIVolumeFile{} } else { - yyv4544 := &yyv4541[yyj4541] - yyv4544.CodecDecodeSelf(d) + yyv4560 := &yyv4557[yyj4557] + yyv4560.CodecDecodeSelf(d) } } else { @@ -56658,17 +56861,17 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil } } - if yyj4541 < len(yyv4541) { - yyv4541 = yyv4541[:yyj4541] - yyc4541 = true - } else if yyj4541 == 0 && yyv4541 == nil { - yyv4541 = []DownwardAPIVolumeFile{} - yyc4541 = true + if yyj4557 < len(yyv4557) { + yyv4557 = yyv4557[:yyj4557] + yyc4557 = true + } else if yyj4557 == 0 && yyv4557 == nil { + yyv4557 = []DownwardAPIVolumeFile{} + yyc4557 = true } } - yyh4541.End() - if yyc4541 { - *v = yyv4541 + yyh4557.End() + if yyc4557 { + *v = yyv4557 } } @@ -56677,10 +56880,10 @@ func (x codecSelfer1234) encSliceHTTPHeader(v []HTTPHeader, e *codec1978.Encoder z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4545 := range v { + for _, yyv4561 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4546 := &yyv4545 - yy4546.CodecEncodeSelf(e) + yy4562 := &yyv4561 + yy4562.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56690,83 +56893,83 @@ func (x codecSelfer1234) decSliceHTTPHeader(v *[]HTTPHeader, d *codec1978.Decode z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4547 := *v - yyh4547, yyl4547 := z.DecSliceHelperStart() - var yyc4547 bool - if yyl4547 == 0 { - if yyv4547 == nil { - yyv4547 = []HTTPHeader{} - yyc4547 = true - } else if len(yyv4547) != 0 { - yyv4547 = yyv4547[:0] - yyc4547 = true + yyv4563 := *v + yyh4563, yyl4563 := z.DecSliceHelperStart() + var yyc4563 bool + if yyl4563 == 0 { + if yyv4563 == nil { + yyv4563 = []HTTPHeader{} + yyc4563 = true + } else if len(yyv4563) != 0 { + yyv4563 = yyv4563[:0] + yyc4563 = true } - } else if yyl4547 > 0 { - var yyrr4547, yyrl4547 int - var yyrt4547 bool - if yyl4547 > cap(yyv4547) { + } else if yyl4563 > 0 { + var yyrr4563, yyrl4563 int + var yyrt4563 bool + if yyl4563 > cap(yyv4563) { - yyrg4547 := len(yyv4547) > 0 - yyv24547 := yyv4547 - yyrl4547, yyrt4547 = z.DecInferLen(yyl4547, z.DecBasicHandle().MaxInitLen, 32) - if yyrt4547 { - if yyrl4547 <= cap(yyv4547) { - yyv4547 = yyv4547[:yyrl4547] + yyrg4563 := len(yyv4563) > 0 + yyv24563 := yyv4563 + yyrl4563, yyrt4563 = z.DecInferLen(yyl4563, z.DecBasicHandle().MaxInitLen, 32) + if yyrt4563 { + if yyrl4563 <= cap(yyv4563) { + yyv4563 = yyv4563[:yyrl4563] } else { - yyv4547 = make([]HTTPHeader, yyrl4547) + yyv4563 = make([]HTTPHeader, yyrl4563) } } else { - yyv4547 = make([]HTTPHeader, yyrl4547) + yyv4563 = make([]HTTPHeader, yyrl4563) } - yyc4547 = true - yyrr4547 = len(yyv4547) - if yyrg4547 { - copy(yyv4547, yyv24547) + yyc4563 = true + yyrr4563 = len(yyv4563) + if yyrg4563 { + copy(yyv4563, yyv24563) } - } else if yyl4547 != len(yyv4547) { - yyv4547 = yyv4547[:yyl4547] - yyc4547 = true + } else if yyl4563 != len(yyv4563) { + yyv4563 = yyv4563[:yyl4563] + yyc4563 = true } - yyj4547 := 0 - for ; yyj4547 < yyrr4547; yyj4547++ { - yyh4547.ElemContainerState(yyj4547) + yyj4563 := 0 + for ; yyj4563 < yyrr4563; yyj4563++ { + yyh4563.ElemContainerState(yyj4563) if r.TryDecodeAsNil() { - yyv4547[yyj4547] = HTTPHeader{} + yyv4563[yyj4563] = HTTPHeader{} } else { - yyv4548 := &yyv4547[yyj4547] - yyv4548.CodecDecodeSelf(d) + yyv4564 := &yyv4563[yyj4563] + yyv4564.CodecDecodeSelf(d) } } - if yyrt4547 { - for ; yyj4547 < yyl4547; yyj4547++ { - yyv4547 = append(yyv4547, HTTPHeader{}) - yyh4547.ElemContainerState(yyj4547) + if yyrt4563 { + for ; yyj4563 < yyl4563; yyj4563++ { + yyv4563 = append(yyv4563, HTTPHeader{}) + yyh4563.ElemContainerState(yyj4563) if r.TryDecodeAsNil() { - yyv4547[yyj4547] = HTTPHeader{} + yyv4563[yyj4563] = HTTPHeader{} } else { - yyv4549 := &yyv4547[yyj4547] - yyv4549.CodecDecodeSelf(d) + yyv4565 := &yyv4563[yyj4563] + yyv4565.CodecDecodeSelf(d) } } } } else { - yyj4547 := 0 - for ; !r.CheckBreak(); yyj4547++ { + yyj4563 := 0 + for ; !r.CheckBreak(); yyj4563++ { - if yyj4547 >= len(yyv4547) { - yyv4547 = append(yyv4547, HTTPHeader{}) // var yyz4547 HTTPHeader - yyc4547 = true + if yyj4563 >= len(yyv4563) { + yyv4563 = append(yyv4563, HTTPHeader{}) // var yyz4563 HTTPHeader + yyc4563 = true } - yyh4547.ElemContainerState(yyj4547) - if yyj4547 < len(yyv4547) { + yyh4563.ElemContainerState(yyj4563) + if yyj4563 < len(yyv4563) { if r.TryDecodeAsNil() { - yyv4547[yyj4547] = HTTPHeader{} + yyv4563[yyj4563] = HTTPHeader{} } else { - yyv4550 := &yyv4547[yyj4547] - yyv4550.CodecDecodeSelf(d) + yyv4566 := &yyv4563[yyj4563] + yyv4566.CodecDecodeSelf(d) } } else { @@ -56774,17 +56977,17 @@ func (x codecSelfer1234) decSliceHTTPHeader(v *[]HTTPHeader, d *codec1978.Decode } } - if yyj4547 < len(yyv4547) { - yyv4547 = yyv4547[:yyj4547] - yyc4547 = true - } else if yyj4547 == 0 && yyv4547 == nil { - yyv4547 = []HTTPHeader{} - yyc4547 = true + if yyj4563 < len(yyv4563) { + yyv4563 = yyv4563[:yyj4563] + yyc4563 = true + } else if yyj4563 == 0 && yyv4563 == nil { + yyv4563 = []HTTPHeader{} + yyc4563 = true } } - yyh4547.End() - if yyc4547 { - *v = yyv4547 + yyh4563.End() + if yyc4563 { + *v = yyv4563 } } @@ -56793,9 +56996,9 @@ func (x codecSelfer1234) encSliceCapability(v []Capability, e *codec1978.Encoder z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4551 := range v { + for _, yyv4567 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yyv4551.CodecEncodeSelf(e) + yyv4567.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56805,75 +57008,75 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4552 := *v - yyh4552, yyl4552 := z.DecSliceHelperStart() - var yyc4552 bool - if yyl4552 == 0 { - if yyv4552 == nil { - yyv4552 = []Capability{} - yyc4552 = true - } else if len(yyv4552) != 0 { - yyv4552 = yyv4552[:0] - yyc4552 = true + yyv4568 := *v + yyh4568, yyl4568 := z.DecSliceHelperStart() + var yyc4568 bool + if yyl4568 == 0 { + if yyv4568 == nil { + yyv4568 = []Capability{} + yyc4568 = true + } else if len(yyv4568) != 0 { + yyv4568 = yyv4568[:0] + yyc4568 = true } - } else if yyl4552 > 0 { - var yyrr4552, yyrl4552 int - var yyrt4552 bool - if yyl4552 > cap(yyv4552) { + } else if yyl4568 > 0 { + var yyrr4568, yyrl4568 int + var yyrt4568 bool + if yyl4568 > cap(yyv4568) { - yyrl4552, yyrt4552 = z.DecInferLen(yyl4552, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4552 { - if yyrl4552 <= cap(yyv4552) { - yyv4552 = yyv4552[:yyrl4552] + yyrl4568, yyrt4568 = z.DecInferLen(yyl4568, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4568 { + if yyrl4568 <= cap(yyv4568) { + yyv4568 = yyv4568[:yyrl4568] } else { - yyv4552 = make([]Capability, yyrl4552) + yyv4568 = make([]Capability, yyrl4568) } } else { - yyv4552 = make([]Capability, yyrl4552) + yyv4568 = make([]Capability, yyrl4568) } - yyc4552 = true - yyrr4552 = len(yyv4552) - } else if yyl4552 != len(yyv4552) { - yyv4552 = yyv4552[:yyl4552] - yyc4552 = true + yyc4568 = true + yyrr4568 = len(yyv4568) + } else if yyl4568 != len(yyv4568) { + yyv4568 = yyv4568[:yyl4568] + yyc4568 = true } - yyj4552 := 0 - for ; yyj4552 < yyrr4552; yyj4552++ { - yyh4552.ElemContainerState(yyj4552) + yyj4568 := 0 + for ; yyj4568 < yyrr4568; yyj4568++ { + yyh4568.ElemContainerState(yyj4568) if r.TryDecodeAsNil() { - yyv4552[yyj4552] = "" + yyv4568[yyj4568] = "" } else { - yyv4552[yyj4552] = Capability(r.DecodeString()) + yyv4568[yyj4568] = Capability(r.DecodeString()) } } - if yyrt4552 { - for ; yyj4552 < yyl4552; yyj4552++ { - yyv4552 = append(yyv4552, "") - yyh4552.ElemContainerState(yyj4552) + if yyrt4568 { + for ; yyj4568 < yyl4568; yyj4568++ { + yyv4568 = append(yyv4568, "") + yyh4568.ElemContainerState(yyj4568) if r.TryDecodeAsNil() { - yyv4552[yyj4552] = "" + yyv4568[yyj4568] = "" } else { - yyv4552[yyj4552] = Capability(r.DecodeString()) + yyv4568[yyj4568] = Capability(r.DecodeString()) } } } } else { - yyj4552 := 0 - for ; !r.CheckBreak(); yyj4552++ { + yyj4568 := 0 + for ; !r.CheckBreak(); yyj4568++ { - if yyj4552 >= len(yyv4552) { - yyv4552 = append(yyv4552, "") // var yyz4552 Capability - yyc4552 = true + if yyj4568 >= len(yyv4568) { + yyv4568 = append(yyv4568, "") // var yyz4568 Capability + yyc4568 = true } - yyh4552.ElemContainerState(yyj4552) - if yyj4552 < len(yyv4552) { + yyh4568.ElemContainerState(yyj4568) + if yyj4568 < len(yyv4568) { if r.TryDecodeAsNil() { - yyv4552[yyj4552] = "" + yyv4568[yyj4568] = "" } else { - yyv4552[yyj4552] = Capability(r.DecodeString()) + yyv4568[yyj4568] = Capability(r.DecodeString()) } } else { @@ -56881,17 +57084,17 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode } } - if yyj4552 < len(yyv4552) { - yyv4552 = yyv4552[:yyj4552] - yyc4552 = true - } else if yyj4552 == 0 && yyv4552 == nil { - yyv4552 = []Capability{} - yyc4552 = true + if yyj4568 < len(yyv4568) { + yyv4568 = yyv4568[:yyj4568] + yyc4568 = true + } else if yyj4568 == 0 && yyv4568 == nil { + yyv4568 = []Capability{} + yyc4568 = true } } - yyh4552.End() - if yyc4552 { - *v = yyv4552 + yyh4568.End() + if yyc4568 { + *v = yyv4568 } } @@ -56900,10 +57103,10 @@ func (x codecSelfer1234) encSliceContainerPort(v []ContainerPort, e *codec1978.E z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4556 := range v { + for _, yyv4572 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4557 := &yyv4556 - yy4557.CodecEncodeSelf(e) + yy4573 := &yyv4572 + yy4573.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -56913,83 +57116,83 @@ func (x codecSelfer1234) decSliceContainerPort(v *[]ContainerPort, d *codec1978. z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4558 := *v - yyh4558, yyl4558 := z.DecSliceHelperStart() - var yyc4558 bool - if yyl4558 == 0 { - if yyv4558 == nil { - yyv4558 = []ContainerPort{} - yyc4558 = true - } else if len(yyv4558) != 0 { - yyv4558 = yyv4558[:0] - yyc4558 = true + yyv4574 := *v + yyh4574, yyl4574 := z.DecSliceHelperStart() + var yyc4574 bool + if yyl4574 == 0 { + if yyv4574 == nil { + yyv4574 = []ContainerPort{} + yyc4574 = true + } else if len(yyv4574) != 0 { + yyv4574 = yyv4574[:0] + yyc4574 = true } - } else if yyl4558 > 0 { - var yyrr4558, yyrl4558 int - var yyrt4558 bool - if yyl4558 > cap(yyv4558) { + } else if yyl4574 > 0 { + var yyrr4574, yyrl4574 int + var yyrt4574 bool + if yyl4574 > cap(yyv4574) { - yyrg4558 := len(yyv4558) > 0 - yyv24558 := yyv4558 - yyrl4558, yyrt4558 = z.DecInferLen(yyl4558, z.DecBasicHandle().MaxInitLen, 56) - if yyrt4558 { - if yyrl4558 <= cap(yyv4558) { - yyv4558 = yyv4558[:yyrl4558] + yyrg4574 := len(yyv4574) > 0 + yyv24574 := yyv4574 + yyrl4574, yyrt4574 = z.DecInferLen(yyl4574, z.DecBasicHandle().MaxInitLen, 56) + if yyrt4574 { + if yyrl4574 <= cap(yyv4574) { + yyv4574 = yyv4574[:yyrl4574] } else { - yyv4558 = make([]ContainerPort, yyrl4558) + yyv4574 = make([]ContainerPort, yyrl4574) } } else { - yyv4558 = make([]ContainerPort, yyrl4558) + yyv4574 = make([]ContainerPort, yyrl4574) } - yyc4558 = true - yyrr4558 = len(yyv4558) - if yyrg4558 { - copy(yyv4558, yyv24558) + yyc4574 = true + yyrr4574 = len(yyv4574) + if yyrg4574 { + copy(yyv4574, yyv24574) } - } else if yyl4558 != len(yyv4558) { - yyv4558 = yyv4558[:yyl4558] - yyc4558 = true + } else if yyl4574 != len(yyv4574) { + yyv4574 = yyv4574[:yyl4574] + yyc4574 = true } - yyj4558 := 0 - for ; yyj4558 < yyrr4558; yyj4558++ { - yyh4558.ElemContainerState(yyj4558) + yyj4574 := 0 + for ; yyj4574 < yyrr4574; yyj4574++ { + yyh4574.ElemContainerState(yyj4574) if r.TryDecodeAsNil() { - yyv4558[yyj4558] = ContainerPort{} + yyv4574[yyj4574] = ContainerPort{} } else { - yyv4559 := &yyv4558[yyj4558] - yyv4559.CodecDecodeSelf(d) + yyv4575 := &yyv4574[yyj4574] + yyv4575.CodecDecodeSelf(d) } } - if yyrt4558 { - for ; yyj4558 < yyl4558; yyj4558++ { - yyv4558 = append(yyv4558, ContainerPort{}) - yyh4558.ElemContainerState(yyj4558) + if yyrt4574 { + for ; yyj4574 < yyl4574; yyj4574++ { + yyv4574 = append(yyv4574, ContainerPort{}) + yyh4574.ElemContainerState(yyj4574) if r.TryDecodeAsNil() { - yyv4558[yyj4558] = ContainerPort{} + yyv4574[yyj4574] = ContainerPort{} } else { - yyv4560 := &yyv4558[yyj4558] - yyv4560.CodecDecodeSelf(d) + yyv4576 := &yyv4574[yyj4574] + yyv4576.CodecDecodeSelf(d) } } } } else { - yyj4558 := 0 - for ; !r.CheckBreak(); yyj4558++ { + yyj4574 := 0 + for ; !r.CheckBreak(); yyj4574++ { - if yyj4558 >= len(yyv4558) { - yyv4558 = append(yyv4558, ContainerPort{}) // var yyz4558 ContainerPort - yyc4558 = true + if yyj4574 >= len(yyv4574) { + yyv4574 = append(yyv4574, ContainerPort{}) // var yyz4574 ContainerPort + yyc4574 = true } - yyh4558.ElemContainerState(yyj4558) - if yyj4558 < len(yyv4558) { + yyh4574.ElemContainerState(yyj4574) + if yyj4574 < len(yyv4574) { if r.TryDecodeAsNil() { - yyv4558[yyj4558] = ContainerPort{} + yyv4574[yyj4574] = ContainerPort{} } else { - yyv4561 := &yyv4558[yyj4558] - yyv4561.CodecDecodeSelf(d) + yyv4577 := &yyv4574[yyj4574] + yyv4577.CodecDecodeSelf(d) } } else { @@ -56997,17 +57200,17 @@ func (x codecSelfer1234) decSliceContainerPort(v *[]ContainerPort, d *codec1978. } } - if yyj4558 < len(yyv4558) { - yyv4558 = yyv4558[:yyj4558] - yyc4558 = true - } else if yyj4558 == 0 && yyv4558 == nil { - yyv4558 = []ContainerPort{} - yyc4558 = true + if yyj4574 < len(yyv4574) { + yyv4574 = yyv4574[:yyj4574] + yyc4574 = true + } else if yyj4574 == 0 && yyv4574 == nil { + yyv4574 = []ContainerPort{} + yyc4574 = true } } - yyh4558.End() - if yyc4558 { - *v = yyv4558 + yyh4574.End() + if yyc4574 { + *v = yyv4574 } } @@ -57016,10 +57219,10 @@ func (x codecSelfer1234) encSliceEnvVar(v []EnvVar, e *codec1978.Encoder) { z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4562 := range v { + for _, yyv4578 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4563 := &yyv4562 - yy4563.CodecEncodeSelf(e) + yy4579 := &yyv4578 + yy4579.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57029,83 +57232,83 @@ func (x codecSelfer1234) decSliceEnvVar(v *[]EnvVar, d *codec1978.Decoder) { z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4564 := *v - yyh4564, yyl4564 := z.DecSliceHelperStart() - var yyc4564 bool - if yyl4564 == 0 { - if yyv4564 == nil { - yyv4564 = []EnvVar{} - yyc4564 = true - } else if len(yyv4564) != 0 { - yyv4564 = yyv4564[:0] - yyc4564 = true + yyv4580 := *v + yyh4580, yyl4580 := z.DecSliceHelperStart() + var yyc4580 bool + if yyl4580 == 0 { + if yyv4580 == nil { + yyv4580 = []EnvVar{} + yyc4580 = true + } else if len(yyv4580) != 0 { + yyv4580 = yyv4580[:0] + yyc4580 = true } - } else if yyl4564 > 0 { - var yyrr4564, yyrl4564 int - var yyrt4564 bool - if yyl4564 > cap(yyv4564) { + } else if yyl4580 > 0 { + var yyrr4580, yyrl4580 int + var yyrt4580 bool + if yyl4580 > cap(yyv4580) { - yyrg4564 := len(yyv4564) > 0 - yyv24564 := yyv4564 - yyrl4564, yyrt4564 = z.DecInferLen(yyl4564, z.DecBasicHandle().MaxInitLen, 40) - if yyrt4564 { - if yyrl4564 <= cap(yyv4564) { - yyv4564 = yyv4564[:yyrl4564] + yyrg4580 := len(yyv4580) > 0 + yyv24580 := yyv4580 + yyrl4580, yyrt4580 = z.DecInferLen(yyl4580, z.DecBasicHandle().MaxInitLen, 40) + if yyrt4580 { + if yyrl4580 <= cap(yyv4580) { + yyv4580 = yyv4580[:yyrl4580] } else { - yyv4564 = make([]EnvVar, yyrl4564) + yyv4580 = make([]EnvVar, yyrl4580) } } else { - yyv4564 = make([]EnvVar, yyrl4564) + yyv4580 = make([]EnvVar, yyrl4580) } - yyc4564 = true - yyrr4564 = len(yyv4564) - if yyrg4564 { - copy(yyv4564, yyv24564) + yyc4580 = true + yyrr4580 = len(yyv4580) + if yyrg4580 { + copy(yyv4580, yyv24580) } - } else if yyl4564 != len(yyv4564) { - yyv4564 = yyv4564[:yyl4564] - yyc4564 = true + } else if yyl4580 != len(yyv4580) { + yyv4580 = yyv4580[:yyl4580] + yyc4580 = true } - yyj4564 := 0 - for ; yyj4564 < yyrr4564; yyj4564++ { - yyh4564.ElemContainerState(yyj4564) + yyj4580 := 0 + for ; yyj4580 < yyrr4580; yyj4580++ { + yyh4580.ElemContainerState(yyj4580) if r.TryDecodeAsNil() { - yyv4564[yyj4564] = EnvVar{} + yyv4580[yyj4580] = EnvVar{} } else { - yyv4565 := &yyv4564[yyj4564] - yyv4565.CodecDecodeSelf(d) + yyv4581 := &yyv4580[yyj4580] + yyv4581.CodecDecodeSelf(d) } } - if yyrt4564 { - for ; yyj4564 < yyl4564; yyj4564++ { - yyv4564 = append(yyv4564, EnvVar{}) - yyh4564.ElemContainerState(yyj4564) + if yyrt4580 { + for ; yyj4580 < yyl4580; yyj4580++ { + yyv4580 = append(yyv4580, EnvVar{}) + yyh4580.ElemContainerState(yyj4580) if r.TryDecodeAsNil() { - yyv4564[yyj4564] = EnvVar{} + yyv4580[yyj4580] = EnvVar{} } else { - yyv4566 := &yyv4564[yyj4564] - yyv4566.CodecDecodeSelf(d) + yyv4582 := &yyv4580[yyj4580] + yyv4582.CodecDecodeSelf(d) } } } } else { - yyj4564 := 0 - for ; !r.CheckBreak(); yyj4564++ { + yyj4580 := 0 + for ; !r.CheckBreak(); yyj4580++ { - if yyj4564 >= len(yyv4564) { - yyv4564 = append(yyv4564, EnvVar{}) // var yyz4564 EnvVar - yyc4564 = true + if yyj4580 >= len(yyv4580) { + yyv4580 = append(yyv4580, EnvVar{}) // var yyz4580 EnvVar + yyc4580 = true } - yyh4564.ElemContainerState(yyj4564) - if yyj4564 < len(yyv4564) { + yyh4580.ElemContainerState(yyj4580) + if yyj4580 < len(yyv4580) { if r.TryDecodeAsNil() { - yyv4564[yyj4564] = EnvVar{} + yyv4580[yyj4580] = EnvVar{} } else { - yyv4567 := &yyv4564[yyj4564] - yyv4567.CodecDecodeSelf(d) + yyv4583 := &yyv4580[yyj4580] + yyv4583.CodecDecodeSelf(d) } } else { @@ -57113,17 +57316,17 @@ func (x codecSelfer1234) decSliceEnvVar(v *[]EnvVar, d *codec1978.Decoder) { } } - if yyj4564 < len(yyv4564) { - yyv4564 = yyv4564[:yyj4564] - yyc4564 = true - } else if yyj4564 == 0 && yyv4564 == nil { - yyv4564 = []EnvVar{} - yyc4564 = true + if yyj4580 < len(yyv4580) { + yyv4580 = yyv4580[:yyj4580] + yyc4580 = true + } else if yyj4580 == 0 && yyv4580 == nil { + yyv4580 = []EnvVar{} + yyc4580 = true } } - yyh4564.End() - if yyc4564 { - *v = yyv4564 + yyh4580.End() + if yyc4580 { + *v = yyv4580 } } @@ -57132,10 +57335,10 @@ func (x codecSelfer1234) encSliceVolumeMount(v []VolumeMount, e *codec1978.Encod z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4568 := range v { + for _, yyv4584 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4569 := &yyv4568 - yy4569.CodecEncodeSelf(e) + yy4585 := &yyv4584 + yy4585.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57145,83 +57348,83 @@ func (x codecSelfer1234) decSliceVolumeMount(v *[]VolumeMount, d *codec1978.Deco z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4570 := *v - yyh4570, yyl4570 := z.DecSliceHelperStart() - var yyc4570 bool - if yyl4570 == 0 { - if yyv4570 == nil { - yyv4570 = []VolumeMount{} - yyc4570 = true - } else if len(yyv4570) != 0 { - yyv4570 = yyv4570[:0] - yyc4570 = true + yyv4586 := *v + yyh4586, yyl4586 := z.DecSliceHelperStart() + var yyc4586 bool + if yyl4586 == 0 { + if yyv4586 == nil { + yyv4586 = []VolumeMount{} + yyc4586 = true + } else if len(yyv4586) != 0 { + yyv4586 = yyv4586[:0] + yyc4586 = true } - } else if yyl4570 > 0 { - var yyrr4570, yyrl4570 int - var yyrt4570 bool - if yyl4570 > cap(yyv4570) { + } else if yyl4586 > 0 { + var yyrr4586, yyrl4586 int + var yyrt4586 bool + if yyl4586 > cap(yyv4586) { - yyrg4570 := len(yyv4570) > 0 - yyv24570 := yyv4570 - yyrl4570, yyrt4570 = z.DecInferLen(yyl4570, z.DecBasicHandle().MaxInitLen, 56) - if yyrt4570 { - if yyrl4570 <= cap(yyv4570) { - yyv4570 = yyv4570[:yyrl4570] + yyrg4586 := len(yyv4586) > 0 + yyv24586 := yyv4586 + yyrl4586, yyrt4586 = z.DecInferLen(yyl4586, z.DecBasicHandle().MaxInitLen, 56) + if yyrt4586 { + if yyrl4586 <= cap(yyv4586) { + yyv4586 = yyv4586[:yyrl4586] } else { - yyv4570 = make([]VolumeMount, yyrl4570) + yyv4586 = make([]VolumeMount, yyrl4586) } } else { - yyv4570 = make([]VolumeMount, yyrl4570) + yyv4586 = make([]VolumeMount, yyrl4586) } - yyc4570 = true - yyrr4570 = len(yyv4570) - if yyrg4570 { - copy(yyv4570, yyv24570) + yyc4586 = true + yyrr4586 = len(yyv4586) + if yyrg4586 { + copy(yyv4586, yyv24586) } - } else if yyl4570 != len(yyv4570) { - yyv4570 = yyv4570[:yyl4570] - yyc4570 = true + } else if yyl4586 != len(yyv4586) { + yyv4586 = yyv4586[:yyl4586] + yyc4586 = true } - yyj4570 := 0 - for ; yyj4570 < yyrr4570; yyj4570++ { - yyh4570.ElemContainerState(yyj4570) + yyj4586 := 0 + for ; yyj4586 < yyrr4586; yyj4586++ { + yyh4586.ElemContainerState(yyj4586) if r.TryDecodeAsNil() { - yyv4570[yyj4570] = VolumeMount{} + yyv4586[yyj4586] = VolumeMount{} } else { - yyv4571 := &yyv4570[yyj4570] - yyv4571.CodecDecodeSelf(d) + yyv4587 := &yyv4586[yyj4586] + yyv4587.CodecDecodeSelf(d) } } - if yyrt4570 { - for ; yyj4570 < yyl4570; yyj4570++ { - yyv4570 = append(yyv4570, VolumeMount{}) - yyh4570.ElemContainerState(yyj4570) + if yyrt4586 { + for ; yyj4586 < yyl4586; yyj4586++ { + yyv4586 = append(yyv4586, VolumeMount{}) + yyh4586.ElemContainerState(yyj4586) if r.TryDecodeAsNil() { - yyv4570[yyj4570] = VolumeMount{} + yyv4586[yyj4586] = VolumeMount{} } else { - yyv4572 := &yyv4570[yyj4570] - yyv4572.CodecDecodeSelf(d) + yyv4588 := &yyv4586[yyj4586] + yyv4588.CodecDecodeSelf(d) } } } } else { - yyj4570 := 0 - for ; !r.CheckBreak(); yyj4570++ { + yyj4586 := 0 + for ; !r.CheckBreak(); yyj4586++ { - if yyj4570 >= len(yyv4570) { - yyv4570 = append(yyv4570, VolumeMount{}) // var yyz4570 VolumeMount - yyc4570 = true + if yyj4586 >= len(yyv4586) { + yyv4586 = append(yyv4586, VolumeMount{}) // var yyz4586 VolumeMount + yyc4586 = true } - yyh4570.ElemContainerState(yyj4570) - if yyj4570 < len(yyv4570) { + yyh4586.ElemContainerState(yyj4586) + if yyj4586 < len(yyv4586) { if r.TryDecodeAsNil() { - yyv4570[yyj4570] = VolumeMount{} + yyv4586[yyj4586] = VolumeMount{} } else { - yyv4573 := &yyv4570[yyj4570] - yyv4573.CodecDecodeSelf(d) + yyv4589 := &yyv4586[yyj4586] + yyv4589.CodecDecodeSelf(d) } } else { @@ -57229,17 +57432,17 @@ func (x codecSelfer1234) decSliceVolumeMount(v *[]VolumeMount, d *codec1978.Deco } } - if yyj4570 < len(yyv4570) { - yyv4570 = yyv4570[:yyj4570] - yyc4570 = true - } else if yyj4570 == 0 && yyv4570 == nil { - yyv4570 = []VolumeMount{} - yyc4570 = true + if yyj4586 < len(yyv4586) { + yyv4586 = yyv4586[:yyj4586] + yyc4586 = true + } else if yyj4586 == 0 && yyv4586 == nil { + yyv4586 = []VolumeMount{} + yyc4586 = true } } - yyh4570.End() - if yyc4570 { - *v = yyv4570 + yyh4586.End() + if yyc4586 { + *v = yyv4586 } } @@ -57248,10 +57451,10 @@ func (x codecSelfer1234) encSlicePod(v []Pod, e *codec1978.Encoder) { z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4574 := range v { + for _, yyv4590 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4575 := &yyv4574 - yy4575.CodecEncodeSelf(e) + yy4591 := &yyv4590 + yy4591.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57261,83 +57464,83 @@ func (x codecSelfer1234) decSlicePod(v *[]Pod, d *codec1978.Decoder) { z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4576 := *v - yyh4576, yyl4576 := z.DecSliceHelperStart() - var yyc4576 bool - if yyl4576 == 0 { - if yyv4576 == nil { - yyv4576 = []Pod{} - yyc4576 = true - } else if len(yyv4576) != 0 { - yyv4576 = yyv4576[:0] - yyc4576 = true + yyv4592 := *v + yyh4592, yyl4592 := z.DecSliceHelperStart() + var yyc4592 bool + if yyl4592 == 0 { + if yyv4592 == nil { + yyv4592 = []Pod{} + yyc4592 = true + } else if len(yyv4592) != 0 { + yyv4592 = yyv4592[:0] + yyc4592 = true } - } else if yyl4576 > 0 { - var yyrr4576, yyrl4576 int - var yyrt4576 bool - if yyl4576 > cap(yyv4576) { + } else if yyl4592 > 0 { + var yyrr4592, yyrl4592 int + var yyrt4592 bool + if yyl4592 > cap(yyv4592) { - yyrg4576 := len(yyv4576) > 0 - yyv24576 := yyv4576 - yyrl4576, yyrt4576 = z.DecInferLen(yyl4576, z.DecBasicHandle().MaxInitLen, 640) - if yyrt4576 { - if yyrl4576 <= cap(yyv4576) { - yyv4576 = yyv4576[:yyrl4576] + yyrg4592 := len(yyv4592) > 0 + yyv24592 := yyv4592 + yyrl4592, yyrt4592 = z.DecInferLen(yyl4592, z.DecBasicHandle().MaxInitLen, 640) + if yyrt4592 { + if yyrl4592 <= cap(yyv4592) { + yyv4592 = yyv4592[:yyrl4592] } else { - yyv4576 = make([]Pod, yyrl4576) + yyv4592 = make([]Pod, yyrl4592) } } else { - yyv4576 = make([]Pod, yyrl4576) + yyv4592 = make([]Pod, yyrl4592) } - yyc4576 = true - yyrr4576 = len(yyv4576) - if yyrg4576 { - copy(yyv4576, yyv24576) + yyc4592 = true + yyrr4592 = len(yyv4592) + if yyrg4592 { + copy(yyv4592, yyv24592) } - } else if yyl4576 != len(yyv4576) { - yyv4576 = yyv4576[:yyl4576] - yyc4576 = true + } else if yyl4592 != len(yyv4592) { + yyv4592 = yyv4592[:yyl4592] + yyc4592 = true } - yyj4576 := 0 - for ; yyj4576 < yyrr4576; yyj4576++ { - yyh4576.ElemContainerState(yyj4576) + yyj4592 := 0 + for ; yyj4592 < yyrr4592; yyj4592++ { + yyh4592.ElemContainerState(yyj4592) if r.TryDecodeAsNil() { - yyv4576[yyj4576] = Pod{} + yyv4592[yyj4592] = Pod{} } else { - yyv4577 := &yyv4576[yyj4576] - yyv4577.CodecDecodeSelf(d) + yyv4593 := &yyv4592[yyj4592] + yyv4593.CodecDecodeSelf(d) } } - if yyrt4576 { - for ; yyj4576 < yyl4576; yyj4576++ { - yyv4576 = append(yyv4576, Pod{}) - yyh4576.ElemContainerState(yyj4576) + if yyrt4592 { + for ; yyj4592 < yyl4592; yyj4592++ { + yyv4592 = append(yyv4592, Pod{}) + yyh4592.ElemContainerState(yyj4592) if r.TryDecodeAsNil() { - yyv4576[yyj4576] = Pod{} + yyv4592[yyj4592] = Pod{} } else { - yyv4578 := &yyv4576[yyj4576] - yyv4578.CodecDecodeSelf(d) + yyv4594 := &yyv4592[yyj4592] + yyv4594.CodecDecodeSelf(d) } } } } else { - yyj4576 := 0 - for ; !r.CheckBreak(); yyj4576++ { + yyj4592 := 0 + for ; !r.CheckBreak(); yyj4592++ { - if yyj4576 >= len(yyv4576) { - yyv4576 = append(yyv4576, Pod{}) // var yyz4576 Pod - yyc4576 = true + if yyj4592 >= len(yyv4592) { + yyv4592 = append(yyv4592, Pod{}) // var yyz4592 Pod + yyc4592 = true } - yyh4576.ElemContainerState(yyj4576) - if yyj4576 < len(yyv4576) { + yyh4592.ElemContainerState(yyj4592) + if yyj4592 < len(yyv4592) { if r.TryDecodeAsNil() { - yyv4576[yyj4576] = Pod{} + yyv4592[yyj4592] = Pod{} } else { - yyv4579 := &yyv4576[yyj4576] - yyv4579.CodecDecodeSelf(d) + yyv4595 := &yyv4592[yyj4592] + yyv4595.CodecDecodeSelf(d) } } else { @@ -57345,17 +57548,17 @@ func (x codecSelfer1234) decSlicePod(v *[]Pod, d *codec1978.Decoder) { } } - if yyj4576 < len(yyv4576) { - yyv4576 = yyv4576[:yyj4576] - yyc4576 = true - } else if yyj4576 == 0 && yyv4576 == nil { - yyv4576 = []Pod{} - yyc4576 = true + if yyj4592 < len(yyv4592) { + yyv4592 = yyv4592[:yyj4592] + yyc4592 = true + } else if yyj4592 == 0 && yyv4592 == nil { + yyv4592 = []Pod{} + yyc4592 = true } } - yyh4576.End() - if yyc4576 { - *v = yyv4576 + yyh4592.End() + if yyc4592 { + *v = yyv4592 } } @@ -57364,10 +57567,10 @@ func (x codecSelfer1234) encSliceNodeSelectorTerm(v []NodeSelectorTerm, e *codec z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4580 := range v { + for _, yyv4596 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4581 := &yyv4580 - yy4581.CodecEncodeSelf(e) + yy4597 := &yyv4596 + yy4597.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57377,83 +57580,83 @@ func (x codecSelfer1234) decSliceNodeSelectorTerm(v *[]NodeSelectorTerm, d *code z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4582 := *v - yyh4582, yyl4582 := z.DecSliceHelperStart() - var yyc4582 bool - if yyl4582 == 0 { - if yyv4582 == nil { - yyv4582 = []NodeSelectorTerm{} - yyc4582 = true - } else if len(yyv4582) != 0 { - yyv4582 = yyv4582[:0] - yyc4582 = true + yyv4598 := *v + yyh4598, yyl4598 := z.DecSliceHelperStart() + var yyc4598 bool + if yyl4598 == 0 { + if yyv4598 == nil { + yyv4598 = []NodeSelectorTerm{} + yyc4598 = true + } else if len(yyv4598) != 0 { + yyv4598 = yyv4598[:0] + yyc4598 = true } - } else if yyl4582 > 0 { - var yyrr4582, yyrl4582 int - var yyrt4582 bool - if yyl4582 > cap(yyv4582) { + } else if yyl4598 > 0 { + var yyrr4598, yyrl4598 int + var yyrt4598 bool + if yyl4598 > cap(yyv4598) { - yyrg4582 := len(yyv4582) > 0 - yyv24582 := yyv4582 - yyrl4582, yyrt4582 = z.DecInferLen(yyl4582, z.DecBasicHandle().MaxInitLen, 24) - if yyrt4582 { - if yyrl4582 <= cap(yyv4582) { - yyv4582 = yyv4582[:yyrl4582] + yyrg4598 := len(yyv4598) > 0 + yyv24598 := yyv4598 + yyrl4598, yyrt4598 = z.DecInferLen(yyl4598, z.DecBasicHandle().MaxInitLen, 24) + if yyrt4598 { + if yyrl4598 <= cap(yyv4598) { + yyv4598 = yyv4598[:yyrl4598] } else { - yyv4582 = make([]NodeSelectorTerm, yyrl4582) + yyv4598 = make([]NodeSelectorTerm, yyrl4598) } } else { - yyv4582 = make([]NodeSelectorTerm, yyrl4582) + yyv4598 = make([]NodeSelectorTerm, yyrl4598) } - yyc4582 = true - yyrr4582 = len(yyv4582) - if yyrg4582 { - copy(yyv4582, yyv24582) + yyc4598 = true + yyrr4598 = len(yyv4598) + if yyrg4598 { + copy(yyv4598, yyv24598) } - } else if yyl4582 != len(yyv4582) { - yyv4582 = yyv4582[:yyl4582] - yyc4582 = true + } else if yyl4598 != len(yyv4598) { + yyv4598 = yyv4598[:yyl4598] + yyc4598 = true } - yyj4582 := 0 - for ; yyj4582 < yyrr4582; yyj4582++ { - yyh4582.ElemContainerState(yyj4582) + yyj4598 := 0 + for ; yyj4598 < yyrr4598; yyj4598++ { + yyh4598.ElemContainerState(yyj4598) if r.TryDecodeAsNil() { - yyv4582[yyj4582] = NodeSelectorTerm{} + yyv4598[yyj4598] = NodeSelectorTerm{} } else { - yyv4583 := &yyv4582[yyj4582] - yyv4583.CodecDecodeSelf(d) + yyv4599 := &yyv4598[yyj4598] + yyv4599.CodecDecodeSelf(d) } } - if yyrt4582 { - for ; yyj4582 < yyl4582; yyj4582++ { - yyv4582 = append(yyv4582, NodeSelectorTerm{}) - yyh4582.ElemContainerState(yyj4582) + if yyrt4598 { + for ; yyj4598 < yyl4598; yyj4598++ { + yyv4598 = append(yyv4598, NodeSelectorTerm{}) + yyh4598.ElemContainerState(yyj4598) if r.TryDecodeAsNil() { - yyv4582[yyj4582] = NodeSelectorTerm{} + yyv4598[yyj4598] = NodeSelectorTerm{} } else { - yyv4584 := &yyv4582[yyj4582] - yyv4584.CodecDecodeSelf(d) + yyv4600 := &yyv4598[yyj4598] + yyv4600.CodecDecodeSelf(d) } } } } else { - yyj4582 := 0 - for ; !r.CheckBreak(); yyj4582++ { + yyj4598 := 0 + for ; !r.CheckBreak(); yyj4598++ { - if yyj4582 >= len(yyv4582) { - yyv4582 = append(yyv4582, NodeSelectorTerm{}) // var yyz4582 NodeSelectorTerm - yyc4582 = true + if yyj4598 >= len(yyv4598) { + yyv4598 = append(yyv4598, NodeSelectorTerm{}) // var yyz4598 NodeSelectorTerm + yyc4598 = true } - yyh4582.ElemContainerState(yyj4582) - if yyj4582 < len(yyv4582) { + yyh4598.ElemContainerState(yyj4598) + if yyj4598 < len(yyv4598) { if r.TryDecodeAsNil() { - yyv4582[yyj4582] = NodeSelectorTerm{} + yyv4598[yyj4598] = NodeSelectorTerm{} } else { - yyv4585 := &yyv4582[yyj4582] - yyv4585.CodecDecodeSelf(d) + yyv4601 := &yyv4598[yyj4598] + yyv4601.CodecDecodeSelf(d) } } else { @@ -57461,17 +57664,17 @@ func (x codecSelfer1234) decSliceNodeSelectorTerm(v *[]NodeSelectorTerm, d *code } } - if yyj4582 < len(yyv4582) { - yyv4582 = yyv4582[:yyj4582] - yyc4582 = true - } else if yyj4582 == 0 && yyv4582 == nil { - yyv4582 = []NodeSelectorTerm{} - yyc4582 = true + if yyj4598 < len(yyv4598) { + yyv4598 = yyv4598[:yyj4598] + yyc4598 = true + } else if yyj4598 == 0 && yyv4598 == nil { + yyv4598 = []NodeSelectorTerm{} + yyc4598 = true } } - yyh4582.End() - if yyc4582 { - *v = yyv4582 + yyh4598.End() + if yyc4598 { + *v = yyv4598 } } @@ -57480,10 +57683,10 @@ func (x codecSelfer1234) encSliceNodeSelectorRequirement(v []NodeSelectorRequire z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4586 := range v { + for _, yyv4602 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4587 := &yyv4586 - yy4587.CodecEncodeSelf(e) + yy4603 := &yyv4602 + yy4603.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57493,83 +57696,83 @@ func (x codecSelfer1234) decSliceNodeSelectorRequirement(v *[]NodeSelectorRequir z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4588 := *v - yyh4588, yyl4588 := z.DecSliceHelperStart() - var yyc4588 bool - if yyl4588 == 0 { - if yyv4588 == nil { - yyv4588 = []NodeSelectorRequirement{} - yyc4588 = true - } else if len(yyv4588) != 0 { - yyv4588 = yyv4588[:0] - yyc4588 = true + yyv4604 := *v + yyh4604, yyl4604 := z.DecSliceHelperStart() + var yyc4604 bool + if yyl4604 == 0 { + if yyv4604 == nil { + yyv4604 = []NodeSelectorRequirement{} + yyc4604 = true + } else if len(yyv4604) != 0 { + yyv4604 = yyv4604[:0] + yyc4604 = true } - } else if yyl4588 > 0 { - var yyrr4588, yyrl4588 int - var yyrt4588 bool - if yyl4588 > cap(yyv4588) { + } else if yyl4604 > 0 { + var yyrr4604, yyrl4604 int + var yyrt4604 bool + if yyl4604 > cap(yyv4604) { - yyrg4588 := len(yyv4588) > 0 - yyv24588 := yyv4588 - yyrl4588, yyrt4588 = z.DecInferLen(yyl4588, z.DecBasicHandle().MaxInitLen, 56) - if yyrt4588 { - if yyrl4588 <= cap(yyv4588) { - yyv4588 = yyv4588[:yyrl4588] + yyrg4604 := len(yyv4604) > 0 + yyv24604 := yyv4604 + yyrl4604, yyrt4604 = z.DecInferLen(yyl4604, z.DecBasicHandle().MaxInitLen, 56) + if yyrt4604 { + if yyrl4604 <= cap(yyv4604) { + yyv4604 = yyv4604[:yyrl4604] } else { - yyv4588 = make([]NodeSelectorRequirement, yyrl4588) + yyv4604 = make([]NodeSelectorRequirement, yyrl4604) } } else { - yyv4588 = make([]NodeSelectorRequirement, yyrl4588) + yyv4604 = make([]NodeSelectorRequirement, yyrl4604) } - yyc4588 = true - yyrr4588 = len(yyv4588) - if yyrg4588 { - copy(yyv4588, yyv24588) + yyc4604 = true + yyrr4604 = len(yyv4604) + if yyrg4604 { + copy(yyv4604, yyv24604) } - } else if yyl4588 != len(yyv4588) { - yyv4588 = yyv4588[:yyl4588] - yyc4588 = true + } else if yyl4604 != len(yyv4604) { + yyv4604 = yyv4604[:yyl4604] + yyc4604 = true } - yyj4588 := 0 - for ; yyj4588 < yyrr4588; yyj4588++ { - yyh4588.ElemContainerState(yyj4588) + yyj4604 := 0 + for ; yyj4604 < yyrr4604; yyj4604++ { + yyh4604.ElemContainerState(yyj4604) if r.TryDecodeAsNil() { - yyv4588[yyj4588] = NodeSelectorRequirement{} + yyv4604[yyj4604] = NodeSelectorRequirement{} } else { - yyv4589 := &yyv4588[yyj4588] - yyv4589.CodecDecodeSelf(d) + yyv4605 := &yyv4604[yyj4604] + yyv4605.CodecDecodeSelf(d) } } - if yyrt4588 { - for ; yyj4588 < yyl4588; yyj4588++ { - yyv4588 = append(yyv4588, NodeSelectorRequirement{}) - yyh4588.ElemContainerState(yyj4588) + if yyrt4604 { + for ; yyj4604 < yyl4604; yyj4604++ { + yyv4604 = append(yyv4604, NodeSelectorRequirement{}) + yyh4604.ElemContainerState(yyj4604) if r.TryDecodeAsNil() { - yyv4588[yyj4588] = NodeSelectorRequirement{} + yyv4604[yyj4604] = NodeSelectorRequirement{} } else { - yyv4590 := &yyv4588[yyj4588] - yyv4590.CodecDecodeSelf(d) + yyv4606 := &yyv4604[yyj4604] + yyv4606.CodecDecodeSelf(d) } } } } else { - yyj4588 := 0 - for ; !r.CheckBreak(); yyj4588++ { + yyj4604 := 0 + for ; !r.CheckBreak(); yyj4604++ { - if yyj4588 >= len(yyv4588) { - yyv4588 = append(yyv4588, NodeSelectorRequirement{}) // var yyz4588 NodeSelectorRequirement - yyc4588 = true + if yyj4604 >= len(yyv4604) { + yyv4604 = append(yyv4604, NodeSelectorRequirement{}) // var yyz4604 NodeSelectorRequirement + yyc4604 = true } - yyh4588.ElemContainerState(yyj4588) - if yyj4588 < len(yyv4588) { + yyh4604.ElemContainerState(yyj4604) + if yyj4604 < len(yyv4604) { if r.TryDecodeAsNil() { - yyv4588[yyj4588] = NodeSelectorRequirement{} + yyv4604[yyj4604] = NodeSelectorRequirement{} } else { - yyv4591 := &yyv4588[yyj4588] - yyv4591.CodecDecodeSelf(d) + yyv4607 := &yyv4604[yyj4604] + yyv4607.CodecDecodeSelf(d) } } else { @@ -57577,17 +57780,17 @@ func (x codecSelfer1234) decSliceNodeSelectorRequirement(v *[]NodeSelectorRequir } } - if yyj4588 < len(yyv4588) { - yyv4588 = yyv4588[:yyj4588] - yyc4588 = true - } else if yyj4588 == 0 && yyv4588 == nil { - yyv4588 = []NodeSelectorRequirement{} - yyc4588 = true + if yyj4604 < len(yyv4604) { + yyv4604 = yyv4604[:yyj4604] + yyc4604 = true + } else if yyj4604 == 0 && yyv4604 == nil { + yyv4604 = []NodeSelectorRequirement{} + yyc4604 = true } } - yyh4588.End() - if yyc4588 { - *v = yyv4588 + yyh4604.End() + if yyc4604 { + *v = yyv4604 } } @@ -57596,10 +57799,10 @@ func (x codecSelfer1234) encSlicePodAffinityTerm(v []PodAffinityTerm, e *codec19 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4592 := range v { + for _, yyv4608 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4593 := &yyv4592 - yy4593.CodecEncodeSelf(e) + yy4609 := &yyv4608 + yy4609.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57609,83 +57812,83 @@ func (x codecSelfer1234) decSlicePodAffinityTerm(v *[]PodAffinityTerm, d *codec1 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4594 := *v - yyh4594, yyl4594 := z.DecSliceHelperStart() - var yyc4594 bool - if yyl4594 == 0 { - if yyv4594 == nil { - yyv4594 = []PodAffinityTerm{} - yyc4594 = true - } else if len(yyv4594) != 0 { - yyv4594 = yyv4594[:0] - yyc4594 = true + yyv4610 := *v + yyh4610, yyl4610 := z.DecSliceHelperStart() + var yyc4610 bool + if yyl4610 == 0 { + if yyv4610 == nil { + yyv4610 = []PodAffinityTerm{} + yyc4610 = true + } else if len(yyv4610) != 0 { + yyv4610 = yyv4610[:0] + yyc4610 = true } - } else if yyl4594 > 0 { - var yyrr4594, yyrl4594 int - var yyrt4594 bool - if yyl4594 > cap(yyv4594) { + } else if yyl4610 > 0 { + var yyrr4610, yyrl4610 int + var yyrt4610 bool + if yyl4610 > cap(yyv4610) { - yyrg4594 := len(yyv4594) > 0 - yyv24594 := yyv4594 - yyrl4594, yyrt4594 = z.DecInferLen(yyl4594, z.DecBasicHandle().MaxInitLen, 48) - if yyrt4594 { - if yyrl4594 <= cap(yyv4594) { - yyv4594 = yyv4594[:yyrl4594] + yyrg4610 := len(yyv4610) > 0 + yyv24610 := yyv4610 + yyrl4610, yyrt4610 = z.DecInferLen(yyl4610, z.DecBasicHandle().MaxInitLen, 48) + if yyrt4610 { + if yyrl4610 <= cap(yyv4610) { + yyv4610 = yyv4610[:yyrl4610] } else { - yyv4594 = make([]PodAffinityTerm, yyrl4594) + yyv4610 = make([]PodAffinityTerm, yyrl4610) } } else { - yyv4594 = make([]PodAffinityTerm, yyrl4594) + yyv4610 = make([]PodAffinityTerm, yyrl4610) } - yyc4594 = true - yyrr4594 = len(yyv4594) - if yyrg4594 { - copy(yyv4594, yyv24594) + yyc4610 = true + yyrr4610 = len(yyv4610) + if yyrg4610 { + copy(yyv4610, yyv24610) } - } else if yyl4594 != len(yyv4594) { - yyv4594 = yyv4594[:yyl4594] - yyc4594 = true + } else if yyl4610 != len(yyv4610) { + yyv4610 = yyv4610[:yyl4610] + yyc4610 = true } - yyj4594 := 0 - for ; yyj4594 < yyrr4594; yyj4594++ { - yyh4594.ElemContainerState(yyj4594) + yyj4610 := 0 + for ; yyj4610 < yyrr4610; yyj4610++ { + yyh4610.ElemContainerState(yyj4610) if r.TryDecodeAsNil() { - yyv4594[yyj4594] = PodAffinityTerm{} + yyv4610[yyj4610] = PodAffinityTerm{} } else { - yyv4595 := &yyv4594[yyj4594] - yyv4595.CodecDecodeSelf(d) + yyv4611 := &yyv4610[yyj4610] + yyv4611.CodecDecodeSelf(d) } } - if yyrt4594 { - for ; yyj4594 < yyl4594; yyj4594++ { - yyv4594 = append(yyv4594, PodAffinityTerm{}) - yyh4594.ElemContainerState(yyj4594) + if yyrt4610 { + for ; yyj4610 < yyl4610; yyj4610++ { + yyv4610 = append(yyv4610, PodAffinityTerm{}) + yyh4610.ElemContainerState(yyj4610) if r.TryDecodeAsNil() { - yyv4594[yyj4594] = PodAffinityTerm{} + yyv4610[yyj4610] = PodAffinityTerm{} } else { - yyv4596 := &yyv4594[yyj4594] - yyv4596.CodecDecodeSelf(d) + yyv4612 := &yyv4610[yyj4610] + yyv4612.CodecDecodeSelf(d) } } } } else { - yyj4594 := 0 - for ; !r.CheckBreak(); yyj4594++ { + yyj4610 := 0 + for ; !r.CheckBreak(); yyj4610++ { - if yyj4594 >= len(yyv4594) { - yyv4594 = append(yyv4594, PodAffinityTerm{}) // var yyz4594 PodAffinityTerm - yyc4594 = true + if yyj4610 >= len(yyv4610) { + yyv4610 = append(yyv4610, PodAffinityTerm{}) // var yyz4610 PodAffinityTerm + yyc4610 = true } - yyh4594.ElemContainerState(yyj4594) - if yyj4594 < len(yyv4594) { + yyh4610.ElemContainerState(yyj4610) + if yyj4610 < len(yyv4610) { if r.TryDecodeAsNil() { - yyv4594[yyj4594] = PodAffinityTerm{} + yyv4610[yyj4610] = PodAffinityTerm{} } else { - yyv4597 := &yyv4594[yyj4594] - yyv4597.CodecDecodeSelf(d) + yyv4613 := &yyv4610[yyj4610] + yyv4613.CodecDecodeSelf(d) } } else { @@ -57693,17 +57896,17 @@ func (x codecSelfer1234) decSlicePodAffinityTerm(v *[]PodAffinityTerm, d *codec1 } } - if yyj4594 < len(yyv4594) { - yyv4594 = yyv4594[:yyj4594] - yyc4594 = true - } else if yyj4594 == 0 && yyv4594 == nil { - yyv4594 = []PodAffinityTerm{} - yyc4594 = true + if yyj4610 < len(yyv4610) { + yyv4610 = yyv4610[:yyj4610] + yyc4610 = true + } else if yyj4610 == 0 && yyv4610 == nil { + yyv4610 = []PodAffinityTerm{} + yyc4610 = true } } - yyh4594.End() - if yyc4594 { - *v = yyv4594 + yyh4610.End() + if yyc4610 { + *v = yyv4610 } } @@ -57712,10 +57915,10 @@ func (x codecSelfer1234) encSliceWeightedPodAffinityTerm(v []WeightedPodAffinity z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4598 := range v { + for _, yyv4614 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4599 := &yyv4598 - yy4599.CodecEncodeSelf(e) + yy4615 := &yyv4614 + yy4615.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57725,83 +57928,83 @@ func (x codecSelfer1234) decSliceWeightedPodAffinityTerm(v *[]WeightedPodAffinit z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4600 := *v - yyh4600, yyl4600 := z.DecSliceHelperStart() - var yyc4600 bool - if yyl4600 == 0 { - if yyv4600 == nil { - yyv4600 = []WeightedPodAffinityTerm{} - yyc4600 = true - } else if len(yyv4600) != 0 { - yyv4600 = yyv4600[:0] - yyc4600 = true + yyv4616 := *v + yyh4616, yyl4616 := z.DecSliceHelperStart() + var yyc4616 bool + if yyl4616 == 0 { + if yyv4616 == nil { + yyv4616 = []WeightedPodAffinityTerm{} + yyc4616 = true + } else if len(yyv4616) != 0 { + yyv4616 = yyv4616[:0] + yyc4616 = true } - } else if yyl4600 > 0 { - var yyrr4600, yyrl4600 int - var yyrt4600 bool - if yyl4600 > cap(yyv4600) { + } else if yyl4616 > 0 { + var yyrr4616, yyrl4616 int + var yyrt4616 bool + if yyl4616 > cap(yyv4616) { - yyrg4600 := len(yyv4600) > 0 - yyv24600 := yyv4600 - yyrl4600, yyrt4600 = z.DecInferLen(yyl4600, z.DecBasicHandle().MaxInitLen, 56) - if yyrt4600 { - if yyrl4600 <= cap(yyv4600) { - yyv4600 = yyv4600[:yyrl4600] + yyrg4616 := len(yyv4616) > 0 + yyv24616 := yyv4616 + yyrl4616, yyrt4616 = z.DecInferLen(yyl4616, z.DecBasicHandle().MaxInitLen, 56) + if yyrt4616 { + if yyrl4616 <= cap(yyv4616) { + yyv4616 = yyv4616[:yyrl4616] } else { - yyv4600 = make([]WeightedPodAffinityTerm, yyrl4600) + yyv4616 = make([]WeightedPodAffinityTerm, yyrl4616) } } else { - yyv4600 = make([]WeightedPodAffinityTerm, yyrl4600) + yyv4616 = make([]WeightedPodAffinityTerm, yyrl4616) } - yyc4600 = true - yyrr4600 = len(yyv4600) - if yyrg4600 { - copy(yyv4600, yyv24600) + yyc4616 = true + yyrr4616 = len(yyv4616) + if yyrg4616 { + copy(yyv4616, yyv24616) } - } else if yyl4600 != len(yyv4600) { - yyv4600 = yyv4600[:yyl4600] - yyc4600 = true + } else if yyl4616 != len(yyv4616) { + yyv4616 = yyv4616[:yyl4616] + yyc4616 = true } - yyj4600 := 0 - for ; yyj4600 < yyrr4600; yyj4600++ { - yyh4600.ElemContainerState(yyj4600) + yyj4616 := 0 + for ; yyj4616 < yyrr4616; yyj4616++ { + yyh4616.ElemContainerState(yyj4616) if r.TryDecodeAsNil() { - yyv4600[yyj4600] = WeightedPodAffinityTerm{} + yyv4616[yyj4616] = WeightedPodAffinityTerm{} } else { - yyv4601 := &yyv4600[yyj4600] - yyv4601.CodecDecodeSelf(d) + yyv4617 := &yyv4616[yyj4616] + yyv4617.CodecDecodeSelf(d) } } - if yyrt4600 { - for ; yyj4600 < yyl4600; yyj4600++ { - yyv4600 = append(yyv4600, WeightedPodAffinityTerm{}) - yyh4600.ElemContainerState(yyj4600) + if yyrt4616 { + for ; yyj4616 < yyl4616; yyj4616++ { + yyv4616 = append(yyv4616, WeightedPodAffinityTerm{}) + yyh4616.ElemContainerState(yyj4616) if r.TryDecodeAsNil() { - yyv4600[yyj4600] = WeightedPodAffinityTerm{} + yyv4616[yyj4616] = WeightedPodAffinityTerm{} } else { - yyv4602 := &yyv4600[yyj4600] - yyv4602.CodecDecodeSelf(d) + yyv4618 := &yyv4616[yyj4616] + yyv4618.CodecDecodeSelf(d) } } } } else { - yyj4600 := 0 - for ; !r.CheckBreak(); yyj4600++ { + yyj4616 := 0 + for ; !r.CheckBreak(); yyj4616++ { - if yyj4600 >= len(yyv4600) { - yyv4600 = append(yyv4600, WeightedPodAffinityTerm{}) // var yyz4600 WeightedPodAffinityTerm - yyc4600 = true + if yyj4616 >= len(yyv4616) { + yyv4616 = append(yyv4616, WeightedPodAffinityTerm{}) // var yyz4616 WeightedPodAffinityTerm + yyc4616 = true } - yyh4600.ElemContainerState(yyj4600) - if yyj4600 < len(yyv4600) { + yyh4616.ElemContainerState(yyj4616) + if yyj4616 < len(yyv4616) { if r.TryDecodeAsNil() { - yyv4600[yyj4600] = WeightedPodAffinityTerm{} + yyv4616[yyj4616] = WeightedPodAffinityTerm{} } else { - yyv4603 := &yyv4600[yyj4600] - yyv4603.CodecDecodeSelf(d) + yyv4619 := &yyv4616[yyj4616] + yyv4619.CodecDecodeSelf(d) } } else { @@ -57809,17 +58012,17 @@ func (x codecSelfer1234) decSliceWeightedPodAffinityTerm(v *[]WeightedPodAffinit } } - if yyj4600 < len(yyv4600) { - yyv4600 = yyv4600[:yyj4600] - yyc4600 = true - } else if yyj4600 == 0 && yyv4600 == nil { - yyv4600 = []WeightedPodAffinityTerm{} - yyc4600 = true + if yyj4616 < len(yyv4616) { + yyv4616 = yyv4616[:yyj4616] + yyc4616 = true + } else if yyj4616 == 0 && yyv4616 == nil { + yyv4616 = []WeightedPodAffinityTerm{} + yyc4616 = true } } - yyh4600.End() - if yyc4600 { - *v = yyv4600 + yyh4616.End() + if yyc4616 { + *v = yyv4616 } } @@ -57828,10 +58031,10 @@ func (x codecSelfer1234) encSlicePreferredSchedulingTerm(v []PreferredScheduling z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4604 := range v { + for _, yyv4620 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4605 := &yyv4604 - yy4605.CodecEncodeSelf(e) + yy4621 := &yyv4620 + yy4621.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57841,83 +58044,83 @@ func (x codecSelfer1234) decSlicePreferredSchedulingTerm(v *[]PreferredSchedulin z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4606 := *v - yyh4606, yyl4606 := z.DecSliceHelperStart() - var yyc4606 bool - if yyl4606 == 0 { - if yyv4606 == nil { - yyv4606 = []PreferredSchedulingTerm{} - yyc4606 = true - } else if len(yyv4606) != 0 { - yyv4606 = yyv4606[:0] - yyc4606 = true + yyv4622 := *v + yyh4622, yyl4622 := z.DecSliceHelperStart() + var yyc4622 bool + if yyl4622 == 0 { + if yyv4622 == nil { + yyv4622 = []PreferredSchedulingTerm{} + yyc4622 = true + } else if len(yyv4622) != 0 { + yyv4622 = yyv4622[:0] + yyc4622 = true } - } else if yyl4606 > 0 { - var yyrr4606, yyrl4606 int - var yyrt4606 bool - if yyl4606 > cap(yyv4606) { + } else if yyl4622 > 0 { + var yyrr4622, yyrl4622 int + var yyrt4622 bool + if yyl4622 > cap(yyv4622) { - yyrg4606 := len(yyv4606) > 0 - yyv24606 := yyv4606 - yyrl4606, yyrt4606 = z.DecInferLen(yyl4606, z.DecBasicHandle().MaxInitLen, 32) - if yyrt4606 { - if yyrl4606 <= cap(yyv4606) { - yyv4606 = yyv4606[:yyrl4606] + yyrg4622 := len(yyv4622) > 0 + yyv24622 := yyv4622 + yyrl4622, yyrt4622 = z.DecInferLen(yyl4622, z.DecBasicHandle().MaxInitLen, 32) + if yyrt4622 { + if yyrl4622 <= cap(yyv4622) { + yyv4622 = yyv4622[:yyrl4622] } else { - yyv4606 = make([]PreferredSchedulingTerm, yyrl4606) + yyv4622 = make([]PreferredSchedulingTerm, yyrl4622) } } else { - yyv4606 = make([]PreferredSchedulingTerm, yyrl4606) + yyv4622 = make([]PreferredSchedulingTerm, yyrl4622) } - yyc4606 = true - yyrr4606 = len(yyv4606) - if yyrg4606 { - copy(yyv4606, yyv24606) + yyc4622 = true + yyrr4622 = len(yyv4622) + if yyrg4622 { + copy(yyv4622, yyv24622) } - } else if yyl4606 != len(yyv4606) { - yyv4606 = yyv4606[:yyl4606] - yyc4606 = true + } else if yyl4622 != len(yyv4622) { + yyv4622 = yyv4622[:yyl4622] + yyc4622 = true } - yyj4606 := 0 - for ; yyj4606 < yyrr4606; yyj4606++ { - yyh4606.ElemContainerState(yyj4606) + yyj4622 := 0 + for ; yyj4622 < yyrr4622; yyj4622++ { + yyh4622.ElemContainerState(yyj4622) if r.TryDecodeAsNil() { - yyv4606[yyj4606] = PreferredSchedulingTerm{} + yyv4622[yyj4622] = PreferredSchedulingTerm{} } else { - yyv4607 := &yyv4606[yyj4606] - yyv4607.CodecDecodeSelf(d) + yyv4623 := &yyv4622[yyj4622] + yyv4623.CodecDecodeSelf(d) } } - if yyrt4606 { - for ; yyj4606 < yyl4606; yyj4606++ { - yyv4606 = append(yyv4606, PreferredSchedulingTerm{}) - yyh4606.ElemContainerState(yyj4606) + if yyrt4622 { + for ; yyj4622 < yyl4622; yyj4622++ { + yyv4622 = append(yyv4622, PreferredSchedulingTerm{}) + yyh4622.ElemContainerState(yyj4622) if r.TryDecodeAsNil() { - yyv4606[yyj4606] = PreferredSchedulingTerm{} + yyv4622[yyj4622] = PreferredSchedulingTerm{} } else { - yyv4608 := &yyv4606[yyj4606] - yyv4608.CodecDecodeSelf(d) + yyv4624 := &yyv4622[yyj4622] + yyv4624.CodecDecodeSelf(d) } } } } else { - yyj4606 := 0 - for ; !r.CheckBreak(); yyj4606++ { + yyj4622 := 0 + for ; !r.CheckBreak(); yyj4622++ { - if yyj4606 >= len(yyv4606) { - yyv4606 = append(yyv4606, PreferredSchedulingTerm{}) // var yyz4606 PreferredSchedulingTerm - yyc4606 = true + if yyj4622 >= len(yyv4622) { + yyv4622 = append(yyv4622, PreferredSchedulingTerm{}) // var yyz4622 PreferredSchedulingTerm + yyc4622 = true } - yyh4606.ElemContainerState(yyj4606) - if yyj4606 < len(yyv4606) { + yyh4622.ElemContainerState(yyj4622) + if yyj4622 < len(yyv4622) { if r.TryDecodeAsNil() { - yyv4606[yyj4606] = PreferredSchedulingTerm{} + yyv4622[yyj4622] = PreferredSchedulingTerm{} } else { - yyv4609 := &yyv4606[yyj4606] - yyv4609.CodecDecodeSelf(d) + yyv4625 := &yyv4622[yyj4622] + yyv4625.CodecDecodeSelf(d) } } else { @@ -57925,17 +58128,17 @@ func (x codecSelfer1234) decSlicePreferredSchedulingTerm(v *[]PreferredSchedulin } } - if yyj4606 < len(yyv4606) { - yyv4606 = yyv4606[:yyj4606] - yyc4606 = true - } else if yyj4606 == 0 && yyv4606 == nil { - yyv4606 = []PreferredSchedulingTerm{} - yyc4606 = true + if yyj4622 < len(yyv4622) { + yyv4622 = yyv4622[:yyj4622] + yyc4622 = true + } else if yyj4622 == 0 && yyv4622 == nil { + yyv4622 = []PreferredSchedulingTerm{} + yyc4622 = true } } - yyh4606.End() - if yyc4606 { - *v = yyv4606 + yyh4622.End() + if yyc4622 { + *v = yyv4622 } } @@ -57944,10 +58147,10 @@ func (x codecSelfer1234) encSliceVolume(v []Volume, e *codec1978.Encoder) { z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4610 := range v { + for _, yyv4626 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4611 := &yyv4610 - yy4611.CodecEncodeSelf(e) + yy4627 := &yyv4626 + yy4627.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -57957,83 +58160,83 @@ func (x codecSelfer1234) decSliceVolume(v *[]Volume, d *codec1978.Decoder) { z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4612 := *v - yyh4612, yyl4612 := z.DecSliceHelperStart() - var yyc4612 bool - if yyl4612 == 0 { - if yyv4612 == nil { - yyv4612 = []Volume{} - yyc4612 = true - } else if len(yyv4612) != 0 { - yyv4612 = yyv4612[:0] - yyc4612 = true + yyv4628 := *v + yyh4628, yyl4628 := z.DecSliceHelperStart() + var yyc4628 bool + if yyl4628 == 0 { + if yyv4628 == nil { + yyv4628 = []Volume{} + yyc4628 = true + } else if len(yyv4628) != 0 { + yyv4628 = yyv4628[:0] + yyc4628 = true } - } else if yyl4612 > 0 { - var yyrr4612, yyrl4612 int - var yyrt4612 bool - if yyl4612 > cap(yyv4612) { + } else if yyl4628 > 0 { + var yyrr4628, yyrl4628 int + var yyrt4628 bool + if yyl4628 > cap(yyv4628) { - yyrg4612 := len(yyv4612) > 0 - yyv24612 := yyv4612 - yyrl4612, yyrt4612 = z.DecInferLen(yyl4612, z.DecBasicHandle().MaxInitLen, 192) - if yyrt4612 { - if yyrl4612 <= cap(yyv4612) { - yyv4612 = yyv4612[:yyrl4612] + yyrg4628 := len(yyv4628) > 0 + yyv24628 := yyv4628 + yyrl4628, yyrt4628 = z.DecInferLen(yyl4628, z.DecBasicHandle().MaxInitLen, 192) + if yyrt4628 { + if yyrl4628 <= cap(yyv4628) { + yyv4628 = yyv4628[:yyrl4628] } else { - yyv4612 = make([]Volume, yyrl4612) + yyv4628 = make([]Volume, yyrl4628) } } else { - yyv4612 = make([]Volume, yyrl4612) + yyv4628 = make([]Volume, yyrl4628) } - yyc4612 = true - yyrr4612 = len(yyv4612) - if yyrg4612 { - copy(yyv4612, yyv24612) + yyc4628 = true + yyrr4628 = len(yyv4628) + if yyrg4628 { + copy(yyv4628, yyv24628) } - } else if yyl4612 != len(yyv4612) { - yyv4612 = yyv4612[:yyl4612] - yyc4612 = true + } else if yyl4628 != len(yyv4628) { + yyv4628 = yyv4628[:yyl4628] + yyc4628 = true } - yyj4612 := 0 - for ; yyj4612 < yyrr4612; yyj4612++ { - yyh4612.ElemContainerState(yyj4612) + yyj4628 := 0 + for ; yyj4628 < yyrr4628; yyj4628++ { + yyh4628.ElemContainerState(yyj4628) if r.TryDecodeAsNil() { - yyv4612[yyj4612] = Volume{} + yyv4628[yyj4628] = Volume{} } else { - yyv4613 := &yyv4612[yyj4612] - yyv4613.CodecDecodeSelf(d) + yyv4629 := &yyv4628[yyj4628] + yyv4629.CodecDecodeSelf(d) } } - if yyrt4612 { - for ; yyj4612 < yyl4612; yyj4612++ { - yyv4612 = append(yyv4612, Volume{}) - yyh4612.ElemContainerState(yyj4612) + if yyrt4628 { + for ; yyj4628 < yyl4628; yyj4628++ { + yyv4628 = append(yyv4628, Volume{}) + yyh4628.ElemContainerState(yyj4628) if r.TryDecodeAsNil() { - yyv4612[yyj4612] = Volume{} + yyv4628[yyj4628] = Volume{} } else { - yyv4614 := &yyv4612[yyj4612] - yyv4614.CodecDecodeSelf(d) + yyv4630 := &yyv4628[yyj4628] + yyv4630.CodecDecodeSelf(d) } } } } else { - yyj4612 := 0 - for ; !r.CheckBreak(); yyj4612++ { + yyj4628 := 0 + for ; !r.CheckBreak(); yyj4628++ { - if yyj4612 >= len(yyv4612) { - yyv4612 = append(yyv4612, Volume{}) // var yyz4612 Volume - yyc4612 = true + if yyj4628 >= len(yyv4628) { + yyv4628 = append(yyv4628, Volume{}) // var yyz4628 Volume + yyc4628 = true } - yyh4612.ElemContainerState(yyj4612) - if yyj4612 < len(yyv4612) { + yyh4628.ElemContainerState(yyj4628) + if yyj4628 < len(yyv4628) { if r.TryDecodeAsNil() { - yyv4612[yyj4612] = Volume{} + yyv4628[yyj4628] = Volume{} } else { - yyv4615 := &yyv4612[yyj4612] - yyv4615.CodecDecodeSelf(d) + yyv4631 := &yyv4628[yyj4628] + yyv4631.CodecDecodeSelf(d) } } else { @@ -58041,17 +58244,17 @@ func (x codecSelfer1234) decSliceVolume(v *[]Volume, d *codec1978.Decoder) { } } - if yyj4612 < len(yyv4612) { - yyv4612 = yyv4612[:yyj4612] - yyc4612 = true - } else if yyj4612 == 0 && yyv4612 == nil { - yyv4612 = []Volume{} - yyc4612 = true + if yyj4628 < len(yyv4628) { + yyv4628 = yyv4628[:yyj4628] + yyc4628 = true + } else if yyj4628 == 0 && yyv4628 == nil { + yyv4628 = []Volume{} + yyc4628 = true } } - yyh4612.End() - if yyc4612 { - *v = yyv4612 + yyh4628.End() + if yyc4628 { + *v = yyv4628 } } @@ -58060,10 +58263,10 @@ func (x codecSelfer1234) encSliceContainer(v []Container, e *codec1978.Encoder) z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4616 := range v { + for _, yyv4632 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4617 := &yyv4616 - yy4617.CodecEncodeSelf(e) + yy4633 := &yyv4632 + yy4633.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58073,83 +58276,83 @@ func (x codecSelfer1234) decSliceContainer(v *[]Container, d *codec1978.Decoder) z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4618 := *v - yyh4618, yyl4618 := z.DecSliceHelperStart() - var yyc4618 bool - if yyl4618 == 0 { - if yyv4618 == nil { - yyv4618 = []Container{} - yyc4618 = true - } else if len(yyv4618) != 0 { - yyv4618 = yyv4618[:0] - yyc4618 = true + yyv4634 := *v + yyh4634, yyl4634 := z.DecSliceHelperStart() + var yyc4634 bool + if yyl4634 == 0 { + if yyv4634 == nil { + yyv4634 = []Container{} + yyc4634 = true + } else if len(yyv4634) != 0 { + yyv4634 = yyv4634[:0] + yyc4634 = true } - } else if yyl4618 > 0 { - var yyrr4618, yyrl4618 int - var yyrt4618 bool - if yyl4618 > cap(yyv4618) { + } else if yyl4634 > 0 { + var yyrr4634, yyrl4634 int + var yyrt4634 bool + if yyl4634 > cap(yyv4634) { - yyrg4618 := len(yyv4618) > 0 - yyv24618 := yyv4618 - yyrl4618, yyrt4618 = z.DecInferLen(yyl4618, z.DecBasicHandle().MaxInitLen, 256) - if yyrt4618 { - if yyrl4618 <= cap(yyv4618) { - yyv4618 = yyv4618[:yyrl4618] + yyrg4634 := len(yyv4634) > 0 + yyv24634 := yyv4634 + yyrl4634, yyrt4634 = z.DecInferLen(yyl4634, z.DecBasicHandle().MaxInitLen, 256) + if yyrt4634 { + if yyrl4634 <= cap(yyv4634) { + yyv4634 = yyv4634[:yyrl4634] } else { - yyv4618 = make([]Container, yyrl4618) + yyv4634 = make([]Container, yyrl4634) } } else { - yyv4618 = make([]Container, yyrl4618) + yyv4634 = make([]Container, yyrl4634) } - yyc4618 = true - yyrr4618 = len(yyv4618) - if yyrg4618 { - copy(yyv4618, yyv24618) + yyc4634 = true + yyrr4634 = len(yyv4634) + if yyrg4634 { + copy(yyv4634, yyv24634) } - } else if yyl4618 != len(yyv4618) { - yyv4618 = yyv4618[:yyl4618] - yyc4618 = true + } else if yyl4634 != len(yyv4634) { + yyv4634 = yyv4634[:yyl4634] + yyc4634 = true } - yyj4618 := 0 - for ; yyj4618 < yyrr4618; yyj4618++ { - yyh4618.ElemContainerState(yyj4618) + yyj4634 := 0 + for ; yyj4634 < yyrr4634; yyj4634++ { + yyh4634.ElemContainerState(yyj4634) if r.TryDecodeAsNil() { - yyv4618[yyj4618] = Container{} + yyv4634[yyj4634] = Container{} } else { - yyv4619 := &yyv4618[yyj4618] - yyv4619.CodecDecodeSelf(d) + yyv4635 := &yyv4634[yyj4634] + yyv4635.CodecDecodeSelf(d) } } - if yyrt4618 { - for ; yyj4618 < yyl4618; yyj4618++ { - yyv4618 = append(yyv4618, Container{}) - yyh4618.ElemContainerState(yyj4618) + if yyrt4634 { + for ; yyj4634 < yyl4634; yyj4634++ { + yyv4634 = append(yyv4634, Container{}) + yyh4634.ElemContainerState(yyj4634) if r.TryDecodeAsNil() { - yyv4618[yyj4618] = Container{} + yyv4634[yyj4634] = Container{} } else { - yyv4620 := &yyv4618[yyj4618] - yyv4620.CodecDecodeSelf(d) + yyv4636 := &yyv4634[yyj4634] + yyv4636.CodecDecodeSelf(d) } } } } else { - yyj4618 := 0 - for ; !r.CheckBreak(); yyj4618++ { + yyj4634 := 0 + for ; !r.CheckBreak(); yyj4634++ { - if yyj4618 >= len(yyv4618) { - yyv4618 = append(yyv4618, Container{}) // var yyz4618 Container - yyc4618 = true + if yyj4634 >= len(yyv4634) { + yyv4634 = append(yyv4634, Container{}) // var yyz4634 Container + yyc4634 = true } - yyh4618.ElemContainerState(yyj4618) - if yyj4618 < len(yyv4618) { + yyh4634.ElemContainerState(yyj4634) + if yyj4634 < len(yyv4634) { if r.TryDecodeAsNil() { - yyv4618[yyj4618] = Container{} + yyv4634[yyj4634] = Container{} } else { - yyv4621 := &yyv4618[yyj4618] - yyv4621.CodecDecodeSelf(d) + yyv4637 := &yyv4634[yyj4634] + yyv4637.CodecDecodeSelf(d) } } else { @@ -58157,17 +58360,17 @@ func (x codecSelfer1234) decSliceContainer(v *[]Container, d *codec1978.Decoder) } } - if yyj4618 < len(yyv4618) { - yyv4618 = yyv4618[:yyj4618] - yyc4618 = true - } else if yyj4618 == 0 && yyv4618 == nil { - yyv4618 = []Container{} - yyc4618 = true + if yyj4634 < len(yyv4634) { + yyv4634 = yyv4634[:yyj4634] + yyc4634 = true + } else if yyj4634 == 0 && yyv4634 == nil { + yyv4634 = []Container{} + yyc4634 = true } } - yyh4618.End() - if yyc4618 { - *v = yyv4618 + yyh4634.End() + if yyc4634 { + *v = yyv4634 } } @@ -58176,10 +58379,10 @@ func (x codecSelfer1234) encSliceLocalObjectReference(v []LocalObjectReference, z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4622 := range v { + for _, yyv4638 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4623 := &yyv4622 - yy4623.CodecEncodeSelf(e) + yy4639 := &yyv4638 + yy4639.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58189,83 +58392,83 @@ func (x codecSelfer1234) decSliceLocalObjectReference(v *[]LocalObjectReference, z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4624 := *v - yyh4624, yyl4624 := z.DecSliceHelperStart() - var yyc4624 bool - if yyl4624 == 0 { - if yyv4624 == nil { - yyv4624 = []LocalObjectReference{} - yyc4624 = true - } else if len(yyv4624) != 0 { - yyv4624 = yyv4624[:0] - yyc4624 = true + yyv4640 := *v + yyh4640, yyl4640 := z.DecSliceHelperStart() + var yyc4640 bool + if yyl4640 == 0 { + if yyv4640 == nil { + yyv4640 = []LocalObjectReference{} + yyc4640 = true + } else if len(yyv4640) != 0 { + yyv4640 = yyv4640[:0] + yyc4640 = true } - } else if yyl4624 > 0 { - var yyrr4624, yyrl4624 int - var yyrt4624 bool - if yyl4624 > cap(yyv4624) { + } else if yyl4640 > 0 { + var yyrr4640, yyrl4640 int + var yyrt4640 bool + if yyl4640 > cap(yyv4640) { - yyrg4624 := len(yyv4624) > 0 - yyv24624 := yyv4624 - yyrl4624, yyrt4624 = z.DecInferLen(yyl4624, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4624 { - if yyrl4624 <= cap(yyv4624) { - yyv4624 = yyv4624[:yyrl4624] + yyrg4640 := len(yyv4640) > 0 + yyv24640 := yyv4640 + yyrl4640, yyrt4640 = z.DecInferLen(yyl4640, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4640 { + if yyrl4640 <= cap(yyv4640) { + yyv4640 = yyv4640[:yyrl4640] } else { - yyv4624 = make([]LocalObjectReference, yyrl4624) + yyv4640 = make([]LocalObjectReference, yyrl4640) } } else { - yyv4624 = make([]LocalObjectReference, yyrl4624) + yyv4640 = make([]LocalObjectReference, yyrl4640) } - yyc4624 = true - yyrr4624 = len(yyv4624) - if yyrg4624 { - copy(yyv4624, yyv24624) + yyc4640 = true + yyrr4640 = len(yyv4640) + if yyrg4640 { + copy(yyv4640, yyv24640) } - } else if yyl4624 != len(yyv4624) { - yyv4624 = yyv4624[:yyl4624] - yyc4624 = true + } else if yyl4640 != len(yyv4640) { + yyv4640 = yyv4640[:yyl4640] + yyc4640 = true } - yyj4624 := 0 - for ; yyj4624 < yyrr4624; yyj4624++ { - yyh4624.ElemContainerState(yyj4624) + yyj4640 := 0 + for ; yyj4640 < yyrr4640; yyj4640++ { + yyh4640.ElemContainerState(yyj4640) if r.TryDecodeAsNil() { - yyv4624[yyj4624] = LocalObjectReference{} + yyv4640[yyj4640] = LocalObjectReference{} } else { - yyv4625 := &yyv4624[yyj4624] - yyv4625.CodecDecodeSelf(d) + yyv4641 := &yyv4640[yyj4640] + yyv4641.CodecDecodeSelf(d) } } - if yyrt4624 { - for ; yyj4624 < yyl4624; yyj4624++ { - yyv4624 = append(yyv4624, LocalObjectReference{}) - yyh4624.ElemContainerState(yyj4624) + if yyrt4640 { + for ; yyj4640 < yyl4640; yyj4640++ { + yyv4640 = append(yyv4640, LocalObjectReference{}) + yyh4640.ElemContainerState(yyj4640) if r.TryDecodeAsNil() { - yyv4624[yyj4624] = LocalObjectReference{} + yyv4640[yyj4640] = LocalObjectReference{} } else { - yyv4626 := &yyv4624[yyj4624] - yyv4626.CodecDecodeSelf(d) + yyv4642 := &yyv4640[yyj4640] + yyv4642.CodecDecodeSelf(d) } } } } else { - yyj4624 := 0 - for ; !r.CheckBreak(); yyj4624++ { + yyj4640 := 0 + for ; !r.CheckBreak(); yyj4640++ { - if yyj4624 >= len(yyv4624) { - yyv4624 = append(yyv4624, LocalObjectReference{}) // var yyz4624 LocalObjectReference - yyc4624 = true + if yyj4640 >= len(yyv4640) { + yyv4640 = append(yyv4640, LocalObjectReference{}) // var yyz4640 LocalObjectReference + yyc4640 = true } - yyh4624.ElemContainerState(yyj4624) - if yyj4624 < len(yyv4624) { + yyh4640.ElemContainerState(yyj4640) + if yyj4640 < len(yyv4640) { if r.TryDecodeAsNil() { - yyv4624[yyj4624] = LocalObjectReference{} + yyv4640[yyj4640] = LocalObjectReference{} } else { - yyv4627 := &yyv4624[yyj4624] - yyv4627.CodecDecodeSelf(d) + yyv4643 := &yyv4640[yyj4640] + yyv4643.CodecDecodeSelf(d) } } else { @@ -58273,17 +58476,17 @@ func (x codecSelfer1234) decSliceLocalObjectReference(v *[]LocalObjectReference, } } - if yyj4624 < len(yyv4624) { - yyv4624 = yyv4624[:yyj4624] - yyc4624 = true - } else if yyj4624 == 0 && yyv4624 == nil { - yyv4624 = []LocalObjectReference{} - yyc4624 = true + if yyj4640 < len(yyv4640) { + yyv4640 = yyv4640[:yyj4640] + yyc4640 = true + } else if yyj4640 == 0 && yyv4640 == nil { + yyv4640 = []LocalObjectReference{} + yyc4640 = true } } - yyh4624.End() - if yyc4624 { - *v = yyv4624 + yyh4640.End() + if yyc4640 { + *v = yyv4640 } } @@ -58292,10 +58495,10 @@ func (x codecSelfer1234) encSlicePodCondition(v []PodCondition, e *codec1978.Enc z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4628 := range v { + for _, yyv4644 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4629 := &yyv4628 - yy4629.CodecEncodeSelf(e) + yy4645 := &yyv4644 + yy4645.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58305,83 +58508,83 @@ func (x codecSelfer1234) decSlicePodCondition(v *[]PodCondition, d *codec1978.De z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4630 := *v - yyh4630, yyl4630 := z.DecSliceHelperStart() - var yyc4630 bool - if yyl4630 == 0 { - if yyv4630 == nil { - yyv4630 = []PodCondition{} - yyc4630 = true - } else if len(yyv4630) != 0 { - yyv4630 = yyv4630[:0] - yyc4630 = true + yyv4646 := *v + yyh4646, yyl4646 := z.DecSliceHelperStart() + var yyc4646 bool + if yyl4646 == 0 { + if yyv4646 == nil { + yyv4646 = []PodCondition{} + yyc4646 = true + } else if len(yyv4646) != 0 { + yyv4646 = yyv4646[:0] + yyc4646 = true } - } else if yyl4630 > 0 { - var yyrr4630, yyrl4630 int - var yyrt4630 bool - if yyl4630 > cap(yyv4630) { + } else if yyl4646 > 0 { + var yyrr4646, yyrl4646 int + var yyrt4646 bool + if yyl4646 > cap(yyv4646) { - yyrg4630 := len(yyv4630) > 0 - yyv24630 := yyv4630 - yyrl4630, yyrt4630 = z.DecInferLen(yyl4630, z.DecBasicHandle().MaxInitLen, 112) - if yyrt4630 { - if yyrl4630 <= cap(yyv4630) { - yyv4630 = yyv4630[:yyrl4630] + yyrg4646 := len(yyv4646) > 0 + yyv24646 := yyv4646 + yyrl4646, yyrt4646 = z.DecInferLen(yyl4646, z.DecBasicHandle().MaxInitLen, 112) + if yyrt4646 { + if yyrl4646 <= cap(yyv4646) { + yyv4646 = yyv4646[:yyrl4646] } else { - yyv4630 = make([]PodCondition, yyrl4630) + yyv4646 = make([]PodCondition, yyrl4646) } } else { - yyv4630 = make([]PodCondition, yyrl4630) + yyv4646 = make([]PodCondition, yyrl4646) } - yyc4630 = true - yyrr4630 = len(yyv4630) - if yyrg4630 { - copy(yyv4630, yyv24630) + yyc4646 = true + yyrr4646 = len(yyv4646) + if yyrg4646 { + copy(yyv4646, yyv24646) } - } else if yyl4630 != len(yyv4630) { - yyv4630 = yyv4630[:yyl4630] - yyc4630 = true + } else if yyl4646 != len(yyv4646) { + yyv4646 = yyv4646[:yyl4646] + yyc4646 = true } - yyj4630 := 0 - for ; yyj4630 < yyrr4630; yyj4630++ { - yyh4630.ElemContainerState(yyj4630) + yyj4646 := 0 + for ; yyj4646 < yyrr4646; yyj4646++ { + yyh4646.ElemContainerState(yyj4646) if r.TryDecodeAsNil() { - yyv4630[yyj4630] = PodCondition{} + yyv4646[yyj4646] = PodCondition{} } else { - yyv4631 := &yyv4630[yyj4630] - yyv4631.CodecDecodeSelf(d) + yyv4647 := &yyv4646[yyj4646] + yyv4647.CodecDecodeSelf(d) } } - if yyrt4630 { - for ; yyj4630 < yyl4630; yyj4630++ { - yyv4630 = append(yyv4630, PodCondition{}) - yyh4630.ElemContainerState(yyj4630) + if yyrt4646 { + for ; yyj4646 < yyl4646; yyj4646++ { + yyv4646 = append(yyv4646, PodCondition{}) + yyh4646.ElemContainerState(yyj4646) if r.TryDecodeAsNil() { - yyv4630[yyj4630] = PodCondition{} + yyv4646[yyj4646] = PodCondition{} } else { - yyv4632 := &yyv4630[yyj4630] - yyv4632.CodecDecodeSelf(d) + yyv4648 := &yyv4646[yyj4646] + yyv4648.CodecDecodeSelf(d) } } } } else { - yyj4630 := 0 - for ; !r.CheckBreak(); yyj4630++ { + yyj4646 := 0 + for ; !r.CheckBreak(); yyj4646++ { - if yyj4630 >= len(yyv4630) { - yyv4630 = append(yyv4630, PodCondition{}) // var yyz4630 PodCondition - yyc4630 = true + if yyj4646 >= len(yyv4646) { + yyv4646 = append(yyv4646, PodCondition{}) // var yyz4646 PodCondition + yyc4646 = true } - yyh4630.ElemContainerState(yyj4630) - if yyj4630 < len(yyv4630) { + yyh4646.ElemContainerState(yyj4646) + if yyj4646 < len(yyv4646) { if r.TryDecodeAsNil() { - yyv4630[yyj4630] = PodCondition{} + yyv4646[yyj4646] = PodCondition{} } else { - yyv4633 := &yyv4630[yyj4630] - yyv4633.CodecDecodeSelf(d) + yyv4649 := &yyv4646[yyj4646] + yyv4649.CodecDecodeSelf(d) } } else { @@ -58389,17 +58592,17 @@ func (x codecSelfer1234) decSlicePodCondition(v *[]PodCondition, d *codec1978.De } } - if yyj4630 < len(yyv4630) { - yyv4630 = yyv4630[:yyj4630] - yyc4630 = true - } else if yyj4630 == 0 && yyv4630 == nil { - yyv4630 = []PodCondition{} - yyc4630 = true + if yyj4646 < len(yyv4646) { + yyv4646 = yyv4646[:yyj4646] + yyc4646 = true + } else if yyj4646 == 0 && yyv4646 == nil { + yyv4646 = []PodCondition{} + yyc4646 = true } } - yyh4630.End() - if yyc4630 { - *v = yyv4630 + yyh4646.End() + if yyc4646 { + *v = yyv4646 } } @@ -58408,10 +58611,10 @@ func (x codecSelfer1234) encSliceContainerStatus(v []ContainerStatus, e *codec19 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4634 := range v { + for _, yyv4650 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4635 := &yyv4634 - yy4635.CodecEncodeSelf(e) + yy4651 := &yyv4650 + yy4651.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58421,83 +58624,83 @@ func (x codecSelfer1234) decSliceContainerStatus(v *[]ContainerStatus, d *codec1 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4636 := *v - yyh4636, yyl4636 := z.DecSliceHelperStart() - var yyc4636 bool - if yyl4636 == 0 { - if yyv4636 == nil { - yyv4636 = []ContainerStatus{} - yyc4636 = true - } else if len(yyv4636) != 0 { - yyv4636 = yyv4636[:0] - yyc4636 = true + yyv4652 := *v + yyh4652, yyl4652 := z.DecSliceHelperStart() + var yyc4652 bool + if yyl4652 == 0 { + if yyv4652 == nil { + yyv4652 = []ContainerStatus{} + yyc4652 = true + } else if len(yyv4652) != 0 { + yyv4652 = yyv4652[:0] + yyc4652 = true } - } else if yyl4636 > 0 { - var yyrr4636, yyrl4636 int - var yyrt4636 bool - if yyl4636 > cap(yyv4636) { + } else if yyl4652 > 0 { + var yyrr4652, yyrl4652 int + var yyrt4652 bool + if yyl4652 > cap(yyv4652) { - yyrg4636 := len(yyv4636) > 0 - yyv24636 := yyv4636 - yyrl4636, yyrt4636 = z.DecInferLen(yyl4636, z.DecBasicHandle().MaxInitLen, 120) - if yyrt4636 { - if yyrl4636 <= cap(yyv4636) { - yyv4636 = yyv4636[:yyrl4636] + yyrg4652 := len(yyv4652) > 0 + yyv24652 := yyv4652 + yyrl4652, yyrt4652 = z.DecInferLen(yyl4652, z.DecBasicHandle().MaxInitLen, 120) + if yyrt4652 { + if yyrl4652 <= cap(yyv4652) { + yyv4652 = yyv4652[:yyrl4652] } else { - yyv4636 = make([]ContainerStatus, yyrl4636) + yyv4652 = make([]ContainerStatus, yyrl4652) } } else { - yyv4636 = make([]ContainerStatus, yyrl4636) + yyv4652 = make([]ContainerStatus, yyrl4652) } - yyc4636 = true - yyrr4636 = len(yyv4636) - if yyrg4636 { - copy(yyv4636, yyv24636) + yyc4652 = true + yyrr4652 = len(yyv4652) + if yyrg4652 { + copy(yyv4652, yyv24652) } - } else if yyl4636 != len(yyv4636) { - yyv4636 = yyv4636[:yyl4636] - yyc4636 = true + } else if yyl4652 != len(yyv4652) { + yyv4652 = yyv4652[:yyl4652] + yyc4652 = true } - yyj4636 := 0 - for ; yyj4636 < yyrr4636; yyj4636++ { - yyh4636.ElemContainerState(yyj4636) + yyj4652 := 0 + for ; yyj4652 < yyrr4652; yyj4652++ { + yyh4652.ElemContainerState(yyj4652) if r.TryDecodeAsNil() { - yyv4636[yyj4636] = ContainerStatus{} + yyv4652[yyj4652] = ContainerStatus{} } else { - yyv4637 := &yyv4636[yyj4636] - yyv4637.CodecDecodeSelf(d) + yyv4653 := &yyv4652[yyj4652] + yyv4653.CodecDecodeSelf(d) } } - if yyrt4636 { - for ; yyj4636 < yyl4636; yyj4636++ { - yyv4636 = append(yyv4636, ContainerStatus{}) - yyh4636.ElemContainerState(yyj4636) + if yyrt4652 { + for ; yyj4652 < yyl4652; yyj4652++ { + yyv4652 = append(yyv4652, ContainerStatus{}) + yyh4652.ElemContainerState(yyj4652) if r.TryDecodeAsNil() { - yyv4636[yyj4636] = ContainerStatus{} + yyv4652[yyj4652] = ContainerStatus{} } else { - yyv4638 := &yyv4636[yyj4636] - yyv4638.CodecDecodeSelf(d) + yyv4654 := &yyv4652[yyj4652] + yyv4654.CodecDecodeSelf(d) } } } } else { - yyj4636 := 0 - for ; !r.CheckBreak(); yyj4636++ { + yyj4652 := 0 + for ; !r.CheckBreak(); yyj4652++ { - if yyj4636 >= len(yyv4636) { - yyv4636 = append(yyv4636, ContainerStatus{}) // var yyz4636 ContainerStatus - yyc4636 = true + if yyj4652 >= len(yyv4652) { + yyv4652 = append(yyv4652, ContainerStatus{}) // var yyz4652 ContainerStatus + yyc4652 = true } - yyh4636.ElemContainerState(yyj4636) - if yyj4636 < len(yyv4636) { + yyh4652.ElemContainerState(yyj4652) + if yyj4652 < len(yyv4652) { if r.TryDecodeAsNil() { - yyv4636[yyj4636] = ContainerStatus{} + yyv4652[yyj4652] = ContainerStatus{} } else { - yyv4639 := &yyv4636[yyj4636] - yyv4639.CodecDecodeSelf(d) + yyv4655 := &yyv4652[yyj4652] + yyv4655.CodecDecodeSelf(d) } } else { @@ -58505,17 +58708,17 @@ func (x codecSelfer1234) decSliceContainerStatus(v *[]ContainerStatus, d *codec1 } } - if yyj4636 < len(yyv4636) { - yyv4636 = yyv4636[:yyj4636] - yyc4636 = true - } else if yyj4636 == 0 && yyv4636 == nil { - yyv4636 = []ContainerStatus{} - yyc4636 = true + if yyj4652 < len(yyv4652) { + yyv4652 = yyv4652[:yyj4652] + yyc4652 = true + } else if yyj4652 == 0 && yyv4652 == nil { + yyv4652 = []ContainerStatus{} + yyc4652 = true } } - yyh4636.End() - if yyc4636 { - *v = yyv4636 + yyh4652.End() + if yyc4652 { + *v = yyv4652 } } @@ -58524,10 +58727,10 @@ func (x codecSelfer1234) encSlicePodTemplate(v []PodTemplate, e *codec1978.Encod z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4640 := range v { + for _, yyv4656 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4641 := &yyv4640 - yy4641.CodecEncodeSelf(e) + yy4657 := &yyv4656 + yy4657.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58537,83 +58740,83 @@ func (x codecSelfer1234) decSlicePodTemplate(v *[]PodTemplate, d *codec1978.Deco z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4642 := *v - yyh4642, yyl4642 := z.DecSliceHelperStart() - var yyc4642 bool - if yyl4642 == 0 { - if yyv4642 == nil { - yyv4642 = []PodTemplate{} - yyc4642 = true - } else if len(yyv4642) != 0 { - yyv4642 = yyv4642[:0] - yyc4642 = true + yyv4658 := *v + yyh4658, yyl4658 := z.DecSliceHelperStart() + var yyc4658 bool + if yyl4658 == 0 { + if yyv4658 == nil { + yyv4658 = []PodTemplate{} + yyc4658 = true + } else if len(yyv4658) != 0 { + yyv4658 = yyv4658[:0] + yyc4658 = true } - } else if yyl4642 > 0 { - var yyrr4642, yyrl4642 int - var yyrt4642 bool - if yyl4642 > cap(yyv4642) { + } else if yyl4658 > 0 { + var yyrr4658, yyrl4658 int + var yyrt4658 bool + if yyl4658 > cap(yyv4658) { - yyrg4642 := len(yyv4642) > 0 - yyv24642 := yyv4642 - yyrl4642, yyrt4642 = z.DecInferLen(yyl4642, z.DecBasicHandle().MaxInitLen, 704) - if yyrt4642 { - if yyrl4642 <= cap(yyv4642) { - yyv4642 = yyv4642[:yyrl4642] + yyrg4658 := len(yyv4658) > 0 + yyv24658 := yyv4658 + yyrl4658, yyrt4658 = z.DecInferLen(yyl4658, z.DecBasicHandle().MaxInitLen, 704) + if yyrt4658 { + if yyrl4658 <= cap(yyv4658) { + yyv4658 = yyv4658[:yyrl4658] } else { - yyv4642 = make([]PodTemplate, yyrl4642) + yyv4658 = make([]PodTemplate, yyrl4658) } } else { - yyv4642 = make([]PodTemplate, yyrl4642) + yyv4658 = make([]PodTemplate, yyrl4658) } - yyc4642 = true - yyrr4642 = len(yyv4642) - if yyrg4642 { - copy(yyv4642, yyv24642) + yyc4658 = true + yyrr4658 = len(yyv4658) + if yyrg4658 { + copy(yyv4658, yyv24658) } - } else if yyl4642 != len(yyv4642) { - yyv4642 = yyv4642[:yyl4642] - yyc4642 = true + } else if yyl4658 != len(yyv4658) { + yyv4658 = yyv4658[:yyl4658] + yyc4658 = true } - yyj4642 := 0 - for ; yyj4642 < yyrr4642; yyj4642++ { - yyh4642.ElemContainerState(yyj4642) + yyj4658 := 0 + for ; yyj4658 < yyrr4658; yyj4658++ { + yyh4658.ElemContainerState(yyj4658) if r.TryDecodeAsNil() { - yyv4642[yyj4642] = PodTemplate{} + yyv4658[yyj4658] = PodTemplate{} } else { - yyv4643 := &yyv4642[yyj4642] - yyv4643.CodecDecodeSelf(d) + yyv4659 := &yyv4658[yyj4658] + yyv4659.CodecDecodeSelf(d) } } - if yyrt4642 { - for ; yyj4642 < yyl4642; yyj4642++ { - yyv4642 = append(yyv4642, PodTemplate{}) - yyh4642.ElemContainerState(yyj4642) + if yyrt4658 { + for ; yyj4658 < yyl4658; yyj4658++ { + yyv4658 = append(yyv4658, PodTemplate{}) + yyh4658.ElemContainerState(yyj4658) if r.TryDecodeAsNil() { - yyv4642[yyj4642] = PodTemplate{} + yyv4658[yyj4658] = PodTemplate{} } else { - yyv4644 := &yyv4642[yyj4642] - yyv4644.CodecDecodeSelf(d) + yyv4660 := &yyv4658[yyj4658] + yyv4660.CodecDecodeSelf(d) } } } } else { - yyj4642 := 0 - for ; !r.CheckBreak(); yyj4642++ { + yyj4658 := 0 + for ; !r.CheckBreak(); yyj4658++ { - if yyj4642 >= len(yyv4642) { - yyv4642 = append(yyv4642, PodTemplate{}) // var yyz4642 PodTemplate - yyc4642 = true + if yyj4658 >= len(yyv4658) { + yyv4658 = append(yyv4658, PodTemplate{}) // var yyz4658 PodTemplate + yyc4658 = true } - yyh4642.ElemContainerState(yyj4642) - if yyj4642 < len(yyv4642) { + yyh4658.ElemContainerState(yyj4658) + if yyj4658 < len(yyv4658) { if r.TryDecodeAsNil() { - yyv4642[yyj4642] = PodTemplate{} + yyv4658[yyj4658] = PodTemplate{} } else { - yyv4645 := &yyv4642[yyj4642] - yyv4645.CodecDecodeSelf(d) + yyv4661 := &yyv4658[yyj4658] + yyv4661.CodecDecodeSelf(d) } } else { @@ -58621,17 +58824,17 @@ func (x codecSelfer1234) decSlicePodTemplate(v *[]PodTemplate, d *codec1978.Deco } } - if yyj4642 < len(yyv4642) { - yyv4642 = yyv4642[:yyj4642] - yyc4642 = true - } else if yyj4642 == 0 && yyv4642 == nil { - yyv4642 = []PodTemplate{} - yyc4642 = true + if yyj4658 < len(yyv4658) { + yyv4658 = yyv4658[:yyj4658] + yyc4658 = true + } else if yyj4658 == 0 && yyv4658 == nil { + yyv4658 = []PodTemplate{} + yyc4658 = true } } - yyh4642.End() - if yyc4642 { - *v = yyv4642 + yyh4658.End() + if yyc4658 { + *v = yyv4658 } } @@ -58640,10 +58843,10 @@ func (x codecSelfer1234) encSliceReplicationController(v []ReplicationController z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4646 := range v { + for _, yyv4662 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4647 := &yyv4646 - yy4647.CodecEncodeSelf(e) + yy4663 := &yyv4662 + yy4663.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58653,83 +58856,83 @@ func (x codecSelfer1234) decSliceReplicationController(v *[]ReplicationControlle z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4648 := *v - yyh4648, yyl4648 := z.DecSliceHelperStart() - var yyc4648 bool - if yyl4648 == 0 { - if yyv4648 == nil { - yyv4648 = []ReplicationController{} - yyc4648 = true - } else if len(yyv4648) != 0 { - yyv4648 = yyv4648[:0] - yyc4648 = true + yyv4664 := *v + yyh4664, yyl4664 := z.DecSliceHelperStart() + var yyc4664 bool + if yyl4664 == 0 { + if yyv4664 == nil { + yyv4664 = []ReplicationController{} + yyc4664 = true + } else if len(yyv4664) != 0 { + yyv4664 = yyv4664[:0] + yyc4664 = true } - } else if yyl4648 > 0 { - var yyrr4648, yyrl4648 int - var yyrt4648 bool - if yyl4648 > cap(yyv4648) { + } else if yyl4664 > 0 { + var yyrr4664, yyrl4664 int + var yyrt4664 bool + if yyl4664 > cap(yyv4664) { - yyrg4648 := len(yyv4648) > 0 - yyv24648 := yyv4648 - yyrl4648, yyrt4648 = z.DecInferLen(yyl4648, z.DecBasicHandle().MaxInitLen, 304) - if yyrt4648 { - if yyrl4648 <= cap(yyv4648) { - yyv4648 = yyv4648[:yyrl4648] + yyrg4664 := len(yyv4664) > 0 + yyv24664 := yyv4664 + yyrl4664, yyrt4664 = z.DecInferLen(yyl4664, z.DecBasicHandle().MaxInitLen, 304) + if yyrt4664 { + if yyrl4664 <= cap(yyv4664) { + yyv4664 = yyv4664[:yyrl4664] } else { - yyv4648 = make([]ReplicationController, yyrl4648) + yyv4664 = make([]ReplicationController, yyrl4664) } } else { - yyv4648 = make([]ReplicationController, yyrl4648) + yyv4664 = make([]ReplicationController, yyrl4664) } - yyc4648 = true - yyrr4648 = len(yyv4648) - if yyrg4648 { - copy(yyv4648, yyv24648) + yyc4664 = true + yyrr4664 = len(yyv4664) + if yyrg4664 { + copy(yyv4664, yyv24664) } - } else if yyl4648 != len(yyv4648) { - yyv4648 = yyv4648[:yyl4648] - yyc4648 = true + } else if yyl4664 != len(yyv4664) { + yyv4664 = yyv4664[:yyl4664] + yyc4664 = true } - yyj4648 := 0 - for ; yyj4648 < yyrr4648; yyj4648++ { - yyh4648.ElemContainerState(yyj4648) + yyj4664 := 0 + for ; yyj4664 < yyrr4664; yyj4664++ { + yyh4664.ElemContainerState(yyj4664) if r.TryDecodeAsNil() { - yyv4648[yyj4648] = ReplicationController{} + yyv4664[yyj4664] = ReplicationController{} } else { - yyv4649 := &yyv4648[yyj4648] - yyv4649.CodecDecodeSelf(d) + yyv4665 := &yyv4664[yyj4664] + yyv4665.CodecDecodeSelf(d) } } - if yyrt4648 { - for ; yyj4648 < yyl4648; yyj4648++ { - yyv4648 = append(yyv4648, ReplicationController{}) - yyh4648.ElemContainerState(yyj4648) + if yyrt4664 { + for ; yyj4664 < yyl4664; yyj4664++ { + yyv4664 = append(yyv4664, ReplicationController{}) + yyh4664.ElemContainerState(yyj4664) if r.TryDecodeAsNil() { - yyv4648[yyj4648] = ReplicationController{} + yyv4664[yyj4664] = ReplicationController{} } else { - yyv4650 := &yyv4648[yyj4648] - yyv4650.CodecDecodeSelf(d) + yyv4666 := &yyv4664[yyj4664] + yyv4666.CodecDecodeSelf(d) } } } } else { - yyj4648 := 0 - for ; !r.CheckBreak(); yyj4648++ { + yyj4664 := 0 + for ; !r.CheckBreak(); yyj4664++ { - if yyj4648 >= len(yyv4648) { - yyv4648 = append(yyv4648, ReplicationController{}) // var yyz4648 ReplicationController - yyc4648 = true + if yyj4664 >= len(yyv4664) { + yyv4664 = append(yyv4664, ReplicationController{}) // var yyz4664 ReplicationController + yyc4664 = true } - yyh4648.ElemContainerState(yyj4648) - if yyj4648 < len(yyv4648) { + yyh4664.ElemContainerState(yyj4664) + if yyj4664 < len(yyv4664) { if r.TryDecodeAsNil() { - yyv4648[yyj4648] = ReplicationController{} + yyv4664[yyj4664] = ReplicationController{} } else { - yyv4651 := &yyv4648[yyj4648] - yyv4651.CodecDecodeSelf(d) + yyv4667 := &yyv4664[yyj4664] + yyv4667.CodecDecodeSelf(d) } } else { @@ -58737,17 +58940,17 @@ func (x codecSelfer1234) decSliceReplicationController(v *[]ReplicationControlle } } - if yyj4648 < len(yyv4648) { - yyv4648 = yyv4648[:yyj4648] - yyc4648 = true - } else if yyj4648 == 0 && yyv4648 == nil { - yyv4648 = []ReplicationController{} - yyc4648 = true + if yyj4664 < len(yyv4664) { + yyv4664 = yyv4664[:yyj4664] + yyc4664 = true + } else if yyj4664 == 0 && yyv4664 == nil { + yyv4664 = []ReplicationController{} + yyc4664 = true } } - yyh4648.End() - if yyc4648 { - *v = yyv4648 + yyh4664.End() + if yyc4664 { + *v = yyv4664 } } @@ -58756,10 +58959,10 @@ func (x codecSelfer1234) encSliceService(v []Service, e *codec1978.Encoder) { z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4652 := range v { + for _, yyv4668 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4653 := &yyv4652 - yy4653.CodecEncodeSelf(e) + yy4669 := &yyv4668 + yy4669.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58769,83 +58972,83 @@ func (x codecSelfer1234) decSliceService(v *[]Service, d *codec1978.Decoder) { z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4654 := *v - yyh4654, yyl4654 := z.DecSliceHelperStart() - var yyc4654 bool - if yyl4654 == 0 { - if yyv4654 == nil { - yyv4654 = []Service{} - yyc4654 = true - } else if len(yyv4654) != 0 { - yyv4654 = yyv4654[:0] - yyc4654 = true + yyv4670 := *v + yyh4670, yyl4670 := z.DecSliceHelperStart() + var yyc4670 bool + if yyl4670 == 0 { + if yyv4670 == nil { + yyv4670 = []Service{} + yyc4670 = true + } else if len(yyv4670) != 0 { + yyv4670 = yyv4670[:0] + yyc4670 = true } - } else if yyl4654 > 0 { - var yyrr4654, yyrl4654 int - var yyrt4654 bool - if yyl4654 > cap(yyv4654) { + } else if yyl4670 > 0 { + var yyrr4670, yyrl4670 int + var yyrt4670 bool + if yyl4670 > cap(yyv4670) { - yyrg4654 := len(yyv4654) > 0 - yyv24654 := yyv4654 - yyrl4654, yyrt4654 = z.DecInferLen(yyl4654, z.DecBasicHandle().MaxInitLen, 440) - if yyrt4654 { - if yyrl4654 <= cap(yyv4654) { - yyv4654 = yyv4654[:yyrl4654] + yyrg4670 := len(yyv4670) > 0 + yyv24670 := yyv4670 + yyrl4670, yyrt4670 = z.DecInferLen(yyl4670, z.DecBasicHandle().MaxInitLen, 440) + if yyrt4670 { + if yyrl4670 <= cap(yyv4670) { + yyv4670 = yyv4670[:yyrl4670] } else { - yyv4654 = make([]Service, yyrl4654) + yyv4670 = make([]Service, yyrl4670) } } else { - yyv4654 = make([]Service, yyrl4654) + yyv4670 = make([]Service, yyrl4670) } - yyc4654 = true - yyrr4654 = len(yyv4654) - if yyrg4654 { - copy(yyv4654, yyv24654) + yyc4670 = true + yyrr4670 = len(yyv4670) + if yyrg4670 { + copy(yyv4670, yyv24670) } - } else if yyl4654 != len(yyv4654) { - yyv4654 = yyv4654[:yyl4654] - yyc4654 = true + } else if yyl4670 != len(yyv4670) { + yyv4670 = yyv4670[:yyl4670] + yyc4670 = true } - yyj4654 := 0 - for ; yyj4654 < yyrr4654; yyj4654++ { - yyh4654.ElemContainerState(yyj4654) + yyj4670 := 0 + for ; yyj4670 < yyrr4670; yyj4670++ { + yyh4670.ElemContainerState(yyj4670) if r.TryDecodeAsNil() { - yyv4654[yyj4654] = Service{} + yyv4670[yyj4670] = Service{} } else { - yyv4655 := &yyv4654[yyj4654] - yyv4655.CodecDecodeSelf(d) + yyv4671 := &yyv4670[yyj4670] + yyv4671.CodecDecodeSelf(d) } } - if yyrt4654 { - for ; yyj4654 < yyl4654; yyj4654++ { - yyv4654 = append(yyv4654, Service{}) - yyh4654.ElemContainerState(yyj4654) + if yyrt4670 { + for ; yyj4670 < yyl4670; yyj4670++ { + yyv4670 = append(yyv4670, Service{}) + yyh4670.ElemContainerState(yyj4670) if r.TryDecodeAsNil() { - yyv4654[yyj4654] = Service{} + yyv4670[yyj4670] = Service{} } else { - yyv4656 := &yyv4654[yyj4654] - yyv4656.CodecDecodeSelf(d) + yyv4672 := &yyv4670[yyj4670] + yyv4672.CodecDecodeSelf(d) } } } } else { - yyj4654 := 0 - for ; !r.CheckBreak(); yyj4654++ { + yyj4670 := 0 + for ; !r.CheckBreak(); yyj4670++ { - if yyj4654 >= len(yyv4654) { - yyv4654 = append(yyv4654, Service{}) // var yyz4654 Service - yyc4654 = true + if yyj4670 >= len(yyv4670) { + yyv4670 = append(yyv4670, Service{}) // var yyz4670 Service + yyc4670 = true } - yyh4654.ElemContainerState(yyj4654) - if yyj4654 < len(yyv4654) { + yyh4670.ElemContainerState(yyj4670) + if yyj4670 < len(yyv4670) { if r.TryDecodeAsNil() { - yyv4654[yyj4654] = Service{} + yyv4670[yyj4670] = Service{} } else { - yyv4657 := &yyv4654[yyj4654] - yyv4657.CodecDecodeSelf(d) + yyv4673 := &yyv4670[yyj4670] + yyv4673.CodecDecodeSelf(d) } } else { @@ -58853,17 +59056,17 @@ func (x codecSelfer1234) decSliceService(v *[]Service, d *codec1978.Decoder) { } } - if yyj4654 < len(yyv4654) { - yyv4654 = yyv4654[:yyj4654] - yyc4654 = true - } else if yyj4654 == 0 && yyv4654 == nil { - yyv4654 = []Service{} - yyc4654 = true + if yyj4670 < len(yyv4670) { + yyv4670 = yyv4670[:yyj4670] + yyc4670 = true + } else if yyj4670 == 0 && yyv4670 == nil { + yyv4670 = []Service{} + yyc4670 = true } } - yyh4654.End() - if yyc4654 { - *v = yyv4654 + yyh4670.End() + if yyc4670 { + *v = yyv4670 } } @@ -58872,10 +59075,10 @@ func (x codecSelfer1234) encSliceLoadBalancerIngress(v []LoadBalancerIngress, e z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4658 := range v { + for _, yyv4674 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4659 := &yyv4658 - yy4659.CodecEncodeSelf(e) + yy4675 := &yyv4674 + yy4675.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -58885,83 +59088,83 @@ func (x codecSelfer1234) decSliceLoadBalancerIngress(v *[]LoadBalancerIngress, d z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4660 := *v - yyh4660, yyl4660 := z.DecSliceHelperStart() - var yyc4660 bool - if yyl4660 == 0 { - if yyv4660 == nil { - yyv4660 = []LoadBalancerIngress{} - yyc4660 = true - } else if len(yyv4660) != 0 { - yyv4660 = yyv4660[:0] - yyc4660 = true + yyv4676 := *v + yyh4676, yyl4676 := z.DecSliceHelperStart() + var yyc4676 bool + if yyl4676 == 0 { + if yyv4676 == nil { + yyv4676 = []LoadBalancerIngress{} + yyc4676 = true + } else if len(yyv4676) != 0 { + yyv4676 = yyv4676[:0] + yyc4676 = true } - } else if yyl4660 > 0 { - var yyrr4660, yyrl4660 int - var yyrt4660 bool - if yyl4660 > cap(yyv4660) { + } else if yyl4676 > 0 { + var yyrr4676, yyrl4676 int + var yyrt4676 bool + if yyl4676 > cap(yyv4676) { - yyrg4660 := len(yyv4660) > 0 - yyv24660 := yyv4660 - yyrl4660, yyrt4660 = z.DecInferLen(yyl4660, z.DecBasicHandle().MaxInitLen, 32) - if yyrt4660 { - if yyrl4660 <= cap(yyv4660) { - yyv4660 = yyv4660[:yyrl4660] + yyrg4676 := len(yyv4676) > 0 + yyv24676 := yyv4676 + yyrl4676, yyrt4676 = z.DecInferLen(yyl4676, z.DecBasicHandle().MaxInitLen, 32) + if yyrt4676 { + if yyrl4676 <= cap(yyv4676) { + yyv4676 = yyv4676[:yyrl4676] } else { - yyv4660 = make([]LoadBalancerIngress, yyrl4660) + yyv4676 = make([]LoadBalancerIngress, yyrl4676) } } else { - yyv4660 = make([]LoadBalancerIngress, yyrl4660) + yyv4676 = make([]LoadBalancerIngress, yyrl4676) } - yyc4660 = true - yyrr4660 = len(yyv4660) - if yyrg4660 { - copy(yyv4660, yyv24660) + yyc4676 = true + yyrr4676 = len(yyv4676) + if yyrg4676 { + copy(yyv4676, yyv24676) } - } else if yyl4660 != len(yyv4660) { - yyv4660 = yyv4660[:yyl4660] - yyc4660 = true + } else if yyl4676 != len(yyv4676) { + yyv4676 = yyv4676[:yyl4676] + yyc4676 = true } - yyj4660 := 0 - for ; yyj4660 < yyrr4660; yyj4660++ { - yyh4660.ElemContainerState(yyj4660) + yyj4676 := 0 + for ; yyj4676 < yyrr4676; yyj4676++ { + yyh4676.ElemContainerState(yyj4676) if r.TryDecodeAsNil() { - yyv4660[yyj4660] = LoadBalancerIngress{} + yyv4676[yyj4676] = LoadBalancerIngress{} } else { - yyv4661 := &yyv4660[yyj4660] - yyv4661.CodecDecodeSelf(d) + yyv4677 := &yyv4676[yyj4676] + yyv4677.CodecDecodeSelf(d) } } - if yyrt4660 { - for ; yyj4660 < yyl4660; yyj4660++ { - yyv4660 = append(yyv4660, LoadBalancerIngress{}) - yyh4660.ElemContainerState(yyj4660) + if yyrt4676 { + for ; yyj4676 < yyl4676; yyj4676++ { + yyv4676 = append(yyv4676, LoadBalancerIngress{}) + yyh4676.ElemContainerState(yyj4676) if r.TryDecodeAsNil() { - yyv4660[yyj4660] = LoadBalancerIngress{} + yyv4676[yyj4676] = LoadBalancerIngress{} } else { - yyv4662 := &yyv4660[yyj4660] - yyv4662.CodecDecodeSelf(d) + yyv4678 := &yyv4676[yyj4676] + yyv4678.CodecDecodeSelf(d) } } } } else { - yyj4660 := 0 - for ; !r.CheckBreak(); yyj4660++ { + yyj4676 := 0 + for ; !r.CheckBreak(); yyj4676++ { - if yyj4660 >= len(yyv4660) { - yyv4660 = append(yyv4660, LoadBalancerIngress{}) // var yyz4660 LoadBalancerIngress - yyc4660 = true + if yyj4676 >= len(yyv4676) { + yyv4676 = append(yyv4676, LoadBalancerIngress{}) // var yyz4676 LoadBalancerIngress + yyc4676 = true } - yyh4660.ElemContainerState(yyj4660) - if yyj4660 < len(yyv4660) { + yyh4676.ElemContainerState(yyj4676) + if yyj4676 < len(yyv4676) { if r.TryDecodeAsNil() { - yyv4660[yyj4660] = LoadBalancerIngress{} + yyv4676[yyj4676] = LoadBalancerIngress{} } else { - yyv4663 := &yyv4660[yyj4660] - yyv4663.CodecDecodeSelf(d) + yyv4679 := &yyv4676[yyj4676] + yyv4679.CodecDecodeSelf(d) } } else { @@ -58969,17 +59172,17 @@ func (x codecSelfer1234) decSliceLoadBalancerIngress(v *[]LoadBalancerIngress, d } } - if yyj4660 < len(yyv4660) { - yyv4660 = yyv4660[:yyj4660] - yyc4660 = true - } else if yyj4660 == 0 && yyv4660 == nil { - yyv4660 = []LoadBalancerIngress{} - yyc4660 = true + if yyj4676 < len(yyv4676) { + yyv4676 = yyv4676[:yyj4676] + yyc4676 = true + } else if yyj4676 == 0 && yyv4676 == nil { + yyv4676 = []LoadBalancerIngress{} + yyc4676 = true } } - yyh4660.End() - if yyc4660 { - *v = yyv4660 + yyh4676.End() + if yyc4676 { + *v = yyv4676 } } @@ -58988,10 +59191,10 @@ func (x codecSelfer1234) encSliceServicePort(v []ServicePort, e *codec1978.Encod z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4664 := range v { + for _, yyv4680 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4665 := &yyv4664 - yy4665.CodecEncodeSelf(e) + yy4681 := &yyv4680 + yy4681.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59001,83 +59204,83 @@ func (x codecSelfer1234) decSliceServicePort(v *[]ServicePort, d *codec1978.Deco z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4666 := *v - yyh4666, yyl4666 := z.DecSliceHelperStart() - var yyc4666 bool - if yyl4666 == 0 { - if yyv4666 == nil { - yyv4666 = []ServicePort{} - yyc4666 = true - } else if len(yyv4666) != 0 { - yyv4666 = yyv4666[:0] - yyc4666 = true + yyv4682 := *v + yyh4682, yyl4682 := z.DecSliceHelperStart() + var yyc4682 bool + if yyl4682 == 0 { + if yyv4682 == nil { + yyv4682 = []ServicePort{} + yyc4682 = true + } else if len(yyv4682) != 0 { + yyv4682 = yyv4682[:0] + yyc4682 = true } - } else if yyl4666 > 0 { - var yyrr4666, yyrl4666 int - var yyrt4666 bool - if yyl4666 > cap(yyv4666) { + } else if yyl4682 > 0 { + var yyrr4682, yyrl4682 int + var yyrt4682 bool + if yyl4682 > cap(yyv4682) { - yyrg4666 := len(yyv4666) > 0 - yyv24666 := yyv4666 - yyrl4666, yyrt4666 = z.DecInferLen(yyl4666, z.DecBasicHandle().MaxInitLen, 80) - if yyrt4666 { - if yyrl4666 <= cap(yyv4666) { - yyv4666 = yyv4666[:yyrl4666] + yyrg4682 := len(yyv4682) > 0 + yyv24682 := yyv4682 + yyrl4682, yyrt4682 = z.DecInferLen(yyl4682, z.DecBasicHandle().MaxInitLen, 80) + if yyrt4682 { + if yyrl4682 <= cap(yyv4682) { + yyv4682 = yyv4682[:yyrl4682] } else { - yyv4666 = make([]ServicePort, yyrl4666) + yyv4682 = make([]ServicePort, yyrl4682) } } else { - yyv4666 = make([]ServicePort, yyrl4666) + yyv4682 = make([]ServicePort, yyrl4682) } - yyc4666 = true - yyrr4666 = len(yyv4666) - if yyrg4666 { - copy(yyv4666, yyv24666) + yyc4682 = true + yyrr4682 = len(yyv4682) + if yyrg4682 { + copy(yyv4682, yyv24682) } - } else if yyl4666 != len(yyv4666) { - yyv4666 = yyv4666[:yyl4666] - yyc4666 = true + } else if yyl4682 != len(yyv4682) { + yyv4682 = yyv4682[:yyl4682] + yyc4682 = true } - yyj4666 := 0 - for ; yyj4666 < yyrr4666; yyj4666++ { - yyh4666.ElemContainerState(yyj4666) + yyj4682 := 0 + for ; yyj4682 < yyrr4682; yyj4682++ { + yyh4682.ElemContainerState(yyj4682) if r.TryDecodeAsNil() { - yyv4666[yyj4666] = ServicePort{} + yyv4682[yyj4682] = ServicePort{} } else { - yyv4667 := &yyv4666[yyj4666] - yyv4667.CodecDecodeSelf(d) + yyv4683 := &yyv4682[yyj4682] + yyv4683.CodecDecodeSelf(d) } } - if yyrt4666 { - for ; yyj4666 < yyl4666; yyj4666++ { - yyv4666 = append(yyv4666, ServicePort{}) - yyh4666.ElemContainerState(yyj4666) + if yyrt4682 { + for ; yyj4682 < yyl4682; yyj4682++ { + yyv4682 = append(yyv4682, ServicePort{}) + yyh4682.ElemContainerState(yyj4682) if r.TryDecodeAsNil() { - yyv4666[yyj4666] = ServicePort{} + yyv4682[yyj4682] = ServicePort{} } else { - yyv4668 := &yyv4666[yyj4666] - yyv4668.CodecDecodeSelf(d) + yyv4684 := &yyv4682[yyj4682] + yyv4684.CodecDecodeSelf(d) } } } } else { - yyj4666 := 0 - for ; !r.CheckBreak(); yyj4666++ { + yyj4682 := 0 + for ; !r.CheckBreak(); yyj4682++ { - if yyj4666 >= len(yyv4666) { - yyv4666 = append(yyv4666, ServicePort{}) // var yyz4666 ServicePort - yyc4666 = true + if yyj4682 >= len(yyv4682) { + yyv4682 = append(yyv4682, ServicePort{}) // var yyz4682 ServicePort + yyc4682 = true } - yyh4666.ElemContainerState(yyj4666) - if yyj4666 < len(yyv4666) { + yyh4682.ElemContainerState(yyj4682) + if yyj4682 < len(yyv4682) { if r.TryDecodeAsNil() { - yyv4666[yyj4666] = ServicePort{} + yyv4682[yyj4682] = ServicePort{} } else { - yyv4669 := &yyv4666[yyj4666] - yyv4669.CodecDecodeSelf(d) + yyv4685 := &yyv4682[yyj4682] + yyv4685.CodecDecodeSelf(d) } } else { @@ -59085,17 +59288,17 @@ func (x codecSelfer1234) decSliceServicePort(v *[]ServicePort, d *codec1978.Deco } } - if yyj4666 < len(yyv4666) { - yyv4666 = yyv4666[:yyj4666] - yyc4666 = true - } else if yyj4666 == 0 && yyv4666 == nil { - yyv4666 = []ServicePort{} - yyc4666 = true + if yyj4682 < len(yyv4682) { + yyv4682 = yyv4682[:yyj4682] + yyc4682 = true + } else if yyj4682 == 0 && yyv4682 == nil { + yyv4682 = []ServicePort{} + yyc4682 = true } } - yyh4666.End() - if yyc4666 { - *v = yyv4666 + yyh4682.End() + if yyc4682 { + *v = yyv4682 } } @@ -59104,10 +59307,10 @@ func (x codecSelfer1234) encSliceObjectReference(v []ObjectReference, e *codec19 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4670 := range v { + for _, yyv4686 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4671 := &yyv4670 - yy4671.CodecEncodeSelf(e) + yy4687 := &yyv4686 + yy4687.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59117,83 +59320,83 @@ func (x codecSelfer1234) decSliceObjectReference(v *[]ObjectReference, d *codec1 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4672 := *v - yyh4672, yyl4672 := z.DecSliceHelperStart() - var yyc4672 bool - if yyl4672 == 0 { - if yyv4672 == nil { - yyv4672 = []ObjectReference{} - yyc4672 = true - } else if len(yyv4672) != 0 { - yyv4672 = yyv4672[:0] - yyc4672 = true + yyv4688 := *v + yyh4688, yyl4688 := z.DecSliceHelperStart() + var yyc4688 bool + if yyl4688 == 0 { + if yyv4688 == nil { + yyv4688 = []ObjectReference{} + yyc4688 = true + } else if len(yyv4688) != 0 { + yyv4688 = yyv4688[:0] + yyc4688 = true } - } else if yyl4672 > 0 { - var yyrr4672, yyrl4672 int - var yyrt4672 bool - if yyl4672 > cap(yyv4672) { + } else if yyl4688 > 0 { + var yyrr4688, yyrl4688 int + var yyrt4688 bool + if yyl4688 > cap(yyv4688) { - yyrg4672 := len(yyv4672) > 0 - yyv24672 := yyv4672 - yyrl4672, yyrt4672 = z.DecInferLen(yyl4672, z.DecBasicHandle().MaxInitLen, 112) - if yyrt4672 { - if yyrl4672 <= cap(yyv4672) { - yyv4672 = yyv4672[:yyrl4672] + yyrg4688 := len(yyv4688) > 0 + yyv24688 := yyv4688 + yyrl4688, yyrt4688 = z.DecInferLen(yyl4688, z.DecBasicHandle().MaxInitLen, 112) + if yyrt4688 { + if yyrl4688 <= cap(yyv4688) { + yyv4688 = yyv4688[:yyrl4688] } else { - yyv4672 = make([]ObjectReference, yyrl4672) + yyv4688 = make([]ObjectReference, yyrl4688) } } else { - yyv4672 = make([]ObjectReference, yyrl4672) + yyv4688 = make([]ObjectReference, yyrl4688) } - yyc4672 = true - yyrr4672 = len(yyv4672) - if yyrg4672 { - copy(yyv4672, yyv24672) + yyc4688 = true + yyrr4688 = len(yyv4688) + if yyrg4688 { + copy(yyv4688, yyv24688) } - } else if yyl4672 != len(yyv4672) { - yyv4672 = yyv4672[:yyl4672] - yyc4672 = true + } else if yyl4688 != len(yyv4688) { + yyv4688 = yyv4688[:yyl4688] + yyc4688 = true } - yyj4672 := 0 - for ; yyj4672 < yyrr4672; yyj4672++ { - yyh4672.ElemContainerState(yyj4672) + yyj4688 := 0 + for ; yyj4688 < yyrr4688; yyj4688++ { + yyh4688.ElemContainerState(yyj4688) if r.TryDecodeAsNil() { - yyv4672[yyj4672] = ObjectReference{} + yyv4688[yyj4688] = ObjectReference{} } else { - yyv4673 := &yyv4672[yyj4672] - yyv4673.CodecDecodeSelf(d) + yyv4689 := &yyv4688[yyj4688] + yyv4689.CodecDecodeSelf(d) } } - if yyrt4672 { - for ; yyj4672 < yyl4672; yyj4672++ { - yyv4672 = append(yyv4672, ObjectReference{}) - yyh4672.ElemContainerState(yyj4672) + if yyrt4688 { + for ; yyj4688 < yyl4688; yyj4688++ { + yyv4688 = append(yyv4688, ObjectReference{}) + yyh4688.ElemContainerState(yyj4688) if r.TryDecodeAsNil() { - yyv4672[yyj4672] = ObjectReference{} + yyv4688[yyj4688] = ObjectReference{} } else { - yyv4674 := &yyv4672[yyj4672] - yyv4674.CodecDecodeSelf(d) + yyv4690 := &yyv4688[yyj4688] + yyv4690.CodecDecodeSelf(d) } } } } else { - yyj4672 := 0 - for ; !r.CheckBreak(); yyj4672++ { + yyj4688 := 0 + for ; !r.CheckBreak(); yyj4688++ { - if yyj4672 >= len(yyv4672) { - yyv4672 = append(yyv4672, ObjectReference{}) // var yyz4672 ObjectReference - yyc4672 = true + if yyj4688 >= len(yyv4688) { + yyv4688 = append(yyv4688, ObjectReference{}) // var yyz4688 ObjectReference + yyc4688 = true } - yyh4672.ElemContainerState(yyj4672) - if yyj4672 < len(yyv4672) { + yyh4688.ElemContainerState(yyj4688) + if yyj4688 < len(yyv4688) { if r.TryDecodeAsNil() { - yyv4672[yyj4672] = ObjectReference{} + yyv4688[yyj4688] = ObjectReference{} } else { - yyv4675 := &yyv4672[yyj4672] - yyv4675.CodecDecodeSelf(d) + yyv4691 := &yyv4688[yyj4688] + yyv4691.CodecDecodeSelf(d) } } else { @@ -59201,17 +59404,17 @@ func (x codecSelfer1234) decSliceObjectReference(v *[]ObjectReference, d *codec1 } } - if yyj4672 < len(yyv4672) { - yyv4672 = yyv4672[:yyj4672] - yyc4672 = true - } else if yyj4672 == 0 && yyv4672 == nil { - yyv4672 = []ObjectReference{} - yyc4672 = true + if yyj4688 < len(yyv4688) { + yyv4688 = yyv4688[:yyj4688] + yyc4688 = true + } else if yyj4688 == 0 && yyv4688 == nil { + yyv4688 = []ObjectReference{} + yyc4688 = true } } - yyh4672.End() - if yyc4672 { - *v = yyv4672 + yyh4688.End() + if yyc4688 { + *v = yyv4688 } } @@ -59220,10 +59423,10 @@ func (x codecSelfer1234) encSliceServiceAccount(v []ServiceAccount, e *codec1978 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4676 := range v { + for _, yyv4692 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4677 := &yyv4676 - yy4677.CodecEncodeSelf(e) + yy4693 := &yyv4692 + yy4693.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59233,83 +59436,83 @@ func (x codecSelfer1234) decSliceServiceAccount(v *[]ServiceAccount, d *codec197 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4678 := *v - yyh4678, yyl4678 := z.DecSliceHelperStart() - var yyc4678 bool - if yyl4678 == 0 { - if yyv4678 == nil { - yyv4678 = []ServiceAccount{} - yyc4678 = true - } else if len(yyv4678) != 0 { - yyv4678 = yyv4678[:0] - yyc4678 = true + yyv4694 := *v + yyh4694, yyl4694 := z.DecSliceHelperStart() + var yyc4694 bool + if yyl4694 == 0 { + if yyv4694 == nil { + yyv4694 = []ServiceAccount{} + yyc4694 = true + } else if len(yyv4694) != 0 { + yyv4694 = yyv4694[:0] + yyc4694 = true } - } else if yyl4678 > 0 { - var yyrr4678, yyrl4678 int - var yyrt4678 bool - if yyl4678 > cap(yyv4678) { + } else if yyl4694 > 0 { + var yyrr4694, yyrl4694 int + var yyrt4694 bool + if yyl4694 > cap(yyv4694) { - yyrg4678 := len(yyv4678) > 0 - yyv24678 := yyv4678 - yyrl4678, yyrt4678 = z.DecInferLen(yyl4678, z.DecBasicHandle().MaxInitLen, 304) - if yyrt4678 { - if yyrl4678 <= cap(yyv4678) { - yyv4678 = yyv4678[:yyrl4678] + yyrg4694 := len(yyv4694) > 0 + yyv24694 := yyv4694 + yyrl4694, yyrt4694 = z.DecInferLen(yyl4694, z.DecBasicHandle().MaxInitLen, 304) + if yyrt4694 { + if yyrl4694 <= cap(yyv4694) { + yyv4694 = yyv4694[:yyrl4694] } else { - yyv4678 = make([]ServiceAccount, yyrl4678) + yyv4694 = make([]ServiceAccount, yyrl4694) } } else { - yyv4678 = make([]ServiceAccount, yyrl4678) + yyv4694 = make([]ServiceAccount, yyrl4694) } - yyc4678 = true - yyrr4678 = len(yyv4678) - if yyrg4678 { - copy(yyv4678, yyv24678) + yyc4694 = true + yyrr4694 = len(yyv4694) + if yyrg4694 { + copy(yyv4694, yyv24694) } - } else if yyl4678 != len(yyv4678) { - yyv4678 = yyv4678[:yyl4678] - yyc4678 = true + } else if yyl4694 != len(yyv4694) { + yyv4694 = yyv4694[:yyl4694] + yyc4694 = true } - yyj4678 := 0 - for ; yyj4678 < yyrr4678; yyj4678++ { - yyh4678.ElemContainerState(yyj4678) + yyj4694 := 0 + for ; yyj4694 < yyrr4694; yyj4694++ { + yyh4694.ElemContainerState(yyj4694) if r.TryDecodeAsNil() { - yyv4678[yyj4678] = ServiceAccount{} + yyv4694[yyj4694] = ServiceAccount{} } else { - yyv4679 := &yyv4678[yyj4678] - yyv4679.CodecDecodeSelf(d) + yyv4695 := &yyv4694[yyj4694] + yyv4695.CodecDecodeSelf(d) } } - if yyrt4678 { - for ; yyj4678 < yyl4678; yyj4678++ { - yyv4678 = append(yyv4678, ServiceAccount{}) - yyh4678.ElemContainerState(yyj4678) + if yyrt4694 { + for ; yyj4694 < yyl4694; yyj4694++ { + yyv4694 = append(yyv4694, ServiceAccount{}) + yyh4694.ElemContainerState(yyj4694) if r.TryDecodeAsNil() { - yyv4678[yyj4678] = ServiceAccount{} + yyv4694[yyj4694] = ServiceAccount{} } else { - yyv4680 := &yyv4678[yyj4678] - yyv4680.CodecDecodeSelf(d) + yyv4696 := &yyv4694[yyj4694] + yyv4696.CodecDecodeSelf(d) } } } } else { - yyj4678 := 0 - for ; !r.CheckBreak(); yyj4678++ { + yyj4694 := 0 + for ; !r.CheckBreak(); yyj4694++ { - if yyj4678 >= len(yyv4678) { - yyv4678 = append(yyv4678, ServiceAccount{}) // var yyz4678 ServiceAccount - yyc4678 = true + if yyj4694 >= len(yyv4694) { + yyv4694 = append(yyv4694, ServiceAccount{}) // var yyz4694 ServiceAccount + yyc4694 = true } - yyh4678.ElemContainerState(yyj4678) - if yyj4678 < len(yyv4678) { + yyh4694.ElemContainerState(yyj4694) + if yyj4694 < len(yyv4694) { if r.TryDecodeAsNil() { - yyv4678[yyj4678] = ServiceAccount{} + yyv4694[yyj4694] = ServiceAccount{} } else { - yyv4681 := &yyv4678[yyj4678] - yyv4681.CodecDecodeSelf(d) + yyv4697 := &yyv4694[yyj4694] + yyv4697.CodecDecodeSelf(d) } } else { @@ -59317,17 +59520,17 @@ func (x codecSelfer1234) decSliceServiceAccount(v *[]ServiceAccount, d *codec197 } } - if yyj4678 < len(yyv4678) { - yyv4678 = yyv4678[:yyj4678] - yyc4678 = true - } else if yyj4678 == 0 && yyv4678 == nil { - yyv4678 = []ServiceAccount{} - yyc4678 = true + if yyj4694 < len(yyv4694) { + yyv4694 = yyv4694[:yyj4694] + yyc4694 = true + } else if yyj4694 == 0 && yyv4694 == nil { + yyv4694 = []ServiceAccount{} + yyc4694 = true } } - yyh4678.End() - if yyc4678 { - *v = yyv4678 + yyh4694.End() + if yyc4694 { + *v = yyv4694 } } @@ -59336,10 +59539,10 @@ func (x codecSelfer1234) encSliceEndpointSubset(v []EndpointSubset, e *codec1978 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4682 := range v { + for _, yyv4698 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4683 := &yyv4682 - yy4683.CodecEncodeSelf(e) + yy4699 := &yyv4698 + yy4699.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59349,83 +59552,83 @@ func (x codecSelfer1234) decSliceEndpointSubset(v *[]EndpointSubset, d *codec197 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4684 := *v - yyh4684, yyl4684 := z.DecSliceHelperStart() - var yyc4684 bool - if yyl4684 == 0 { - if yyv4684 == nil { - yyv4684 = []EndpointSubset{} - yyc4684 = true - } else if len(yyv4684) != 0 { - yyv4684 = yyv4684[:0] - yyc4684 = true + yyv4700 := *v + yyh4700, yyl4700 := z.DecSliceHelperStart() + var yyc4700 bool + if yyl4700 == 0 { + if yyv4700 == nil { + yyv4700 = []EndpointSubset{} + yyc4700 = true + } else if len(yyv4700) != 0 { + yyv4700 = yyv4700[:0] + yyc4700 = true } - } else if yyl4684 > 0 { - var yyrr4684, yyrl4684 int - var yyrt4684 bool - if yyl4684 > cap(yyv4684) { + } else if yyl4700 > 0 { + var yyrr4700, yyrl4700 int + var yyrt4700 bool + if yyl4700 > cap(yyv4700) { - yyrg4684 := len(yyv4684) > 0 - yyv24684 := yyv4684 - yyrl4684, yyrt4684 = z.DecInferLen(yyl4684, z.DecBasicHandle().MaxInitLen, 72) - if yyrt4684 { - if yyrl4684 <= cap(yyv4684) { - yyv4684 = yyv4684[:yyrl4684] + yyrg4700 := len(yyv4700) > 0 + yyv24700 := yyv4700 + yyrl4700, yyrt4700 = z.DecInferLen(yyl4700, z.DecBasicHandle().MaxInitLen, 72) + if yyrt4700 { + if yyrl4700 <= cap(yyv4700) { + yyv4700 = yyv4700[:yyrl4700] } else { - yyv4684 = make([]EndpointSubset, yyrl4684) + yyv4700 = make([]EndpointSubset, yyrl4700) } } else { - yyv4684 = make([]EndpointSubset, yyrl4684) + yyv4700 = make([]EndpointSubset, yyrl4700) } - yyc4684 = true - yyrr4684 = len(yyv4684) - if yyrg4684 { - copy(yyv4684, yyv24684) + yyc4700 = true + yyrr4700 = len(yyv4700) + if yyrg4700 { + copy(yyv4700, yyv24700) } - } else if yyl4684 != len(yyv4684) { - yyv4684 = yyv4684[:yyl4684] - yyc4684 = true + } else if yyl4700 != len(yyv4700) { + yyv4700 = yyv4700[:yyl4700] + yyc4700 = true } - yyj4684 := 0 - for ; yyj4684 < yyrr4684; yyj4684++ { - yyh4684.ElemContainerState(yyj4684) + yyj4700 := 0 + for ; yyj4700 < yyrr4700; yyj4700++ { + yyh4700.ElemContainerState(yyj4700) if r.TryDecodeAsNil() { - yyv4684[yyj4684] = EndpointSubset{} + yyv4700[yyj4700] = EndpointSubset{} } else { - yyv4685 := &yyv4684[yyj4684] - yyv4685.CodecDecodeSelf(d) + yyv4701 := &yyv4700[yyj4700] + yyv4701.CodecDecodeSelf(d) } } - if yyrt4684 { - for ; yyj4684 < yyl4684; yyj4684++ { - yyv4684 = append(yyv4684, EndpointSubset{}) - yyh4684.ElemContainerState(yyj4684) + if yyrt4700 { + for ; yyj4700 < yyl4700; yyj4700++ { + yyv4700 = append(yyv4700, EndpointSubset{}) + yyh4700.ElemContainerState(yyj4700) if r.TryDecodeAsNil() { - yyv4684[yyj4684] = EndpointSubset{} + yyv4700[yyj4700] = EndpointSubset{} } else { - yyv4686 := &yyv4684[yyj4684] - yyv4686.CodecDecodeSelf(d) + yyv4702 := &yyv4700[yyj4700] + yyv4702.CodecDecodeSelf(d) } } } } else { - yyj4684 := 0 - for ; !r.CheckBreak(); yyj4684++ { + yyj4700 := 0 + for ; !r.CheckBreak(); yyj4700++ { - if yyj4684 >= len(yyv4684) { - yyv4684 = append(yyv4684, EndpointSubset{}) // var yyz4684 EndpointSubset - yyc4684 = true + if yyj4700 >= len(yyv4700) { + yyv4700 = append(yyv4700, EndpointSubset{}) // var yyz4700 EndpointSubset + yyc4700 = true } - yyh4684.ElemContainerState(yyj4684) - if yyj4684 < len(yyv4684) { + yyh4700.ElemContainerState(yyj4700) + if yyj4700 < len(yyv4700) { if r.TryDecodeAsNil() { - yyv4684[yyj4684] = EndpointSubset{} + yyv4700[yyj4700] = EndpointSubset{} } else { - yyv4687 := &yyv4684[yyj4684] - yyv4687.CodecDecodeSelf(d) + yyv4703 := &yyv4700[yyj4700] + yyv4703.CodecDecodeSelf(d) } } else { @@ -59433,17 +59636,17 @@ func (x codecSelfer1234) decSliceEndpointSubset(v *[]EndpointSubset, d *codec197 } } - if yyj4684 < len(yyv4684) { - yyv4684 = yyv4684[:yyj4684] - yyc4684 = true - } else if yyj4684 == 0 && yyv4684 == nil { - yyv4684 = []EndpointSubset{} - yyc4684 = true + if yyj4700 < len(yyv4700) { + yyv4700 = yyv4700[:yyj4700] + yyc4700 = true + } else if yyj4700 == 0 && yyv4700 == nil { + yyv4700 = []EndpointSubset{} + yyc4700 = true } } - yyh4684.End() - if yyc4684 { - *v = yyv4684 + yyh4700.End() + if yyc4700 { + *v = yyv4700 } } @@ -59452,10 +59655,10 @@ func (x codecSelfer1234) encSliceEndpointAddress(v []EndpointAddress, e *codec19 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4688 := range v { + for _, yyv4704 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4689 := &yyv4688 - yy4689.CodecEncodeSelf(e) + yy4705 := &yyv4704 + yy4705.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59465,83 +59668,83 @@ func (x codecSelfer1234) decSliceEndpointAddress(v *[]EndpointAddress, d *codec1 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4690 := *v - yyh4690, yyl4690 := z.DecSliceHelperStart() - var yyc4690 bool - if yyl4690 == 0 { - if yyv4690 == nil { - yyv4690 = []EndpointAddress{} - yyc4690 = true - } else if len(yyv4690) != 0 { - yyv4690 = yyv4690[:0] - yyc4690 = true + yyv4706 := *v + yyh4706, yyl4706 := z.DecSliceHelperStart() + var yyc4706 bool + if yyl4706 == 0 { + if yyv4706 == nil { + yyv4706 = []EndpointAddress{} + yyc4706 = true + } else if len(yyv4706) != 0 { + yyv4706 = yyv4706[:0] + yyc4706 = true } - } else if yyl4690 > 0 { - var yyrr4690, yyrl4690 int - var yyrt4690 bool - if yyl4690 > cap(yyv4690) { + } else if yyl4706 > 0 { + var yyrr4706, yyrl4706 int + var yyrt4706 bool + if yyl4706 > cap(yyv4706) { - yyrg4690 := len(yyv4690) > 0 - yyv24690 := yyv4690 - yyrl4690, yyrt4690 = z.DecInferLen(yyl4690, z.DecBasicHandle().MaxInitLen, 48) - if yyrt4690 { - if yyrl4690 <= cap(yyv4690) { - yyv4690 = yyv4690[:yyrl4690] + yyrg4706 := len(yyv4706) > 0 + yyv24706 := yyv4706 + yyrl4706, yyrt4706 = z.DecInferLen(yyl4706, z.DecBasicHandle().MaxInitLen, 48) + if yyrt4706 { + if yyrl4706 <= cap(yyv4706) { + yyv4706 = yyv4706[:yyrl4706] } else { - yyv4690 = make([]EndpointAddress, yyrl4690) + yyv4706 = make([]EndpointAddress, yyrl4706) } } else { - yyv4690 = make([]EndpointAddress, yyrl4690) + yyv4706 = make([]EndpointAddress, yyrl4706) } - yyc4690 = true - yyrr4690 = len(yyv4690) - if yyrg4690 { - copy(yyv4690, yyv24690) + yyc4706 = true + yyrr4706 = len(yyv4706) + if yyrg4706 { + copy(yyv4706, yyv24706) } - } else if yyl4690 != len(yyv4690) { - yyv4690 = yyv4690[:yyl4690] - yyc4690 = true + } else if yyl4706 != len(yyv4706) { + yyv4706 = yyv4706[:yyl4706] + yyc4706 = true } - yyj4690 := 0 - for ; yyj4690 < yyrr4690; yyj4690++ { - yyh4690.ElemContainerState(yyj4690) + yyj4706 := 0 + for ; yyj4706 < yyrr4706; yyj4706++ { + yyh4706.ElemContainerState(yyj4706) if r.TryDecodeAsNil() { - yyv4690[yyj4690] = EndpointAddress{} + yyv4706[yyj4706] = EndpointAddress{} } else { - yyv4691 := &yyv4690[yyj4690] - yyv4691.CodecDecodeSelf(d) + yyv4707 := &yyv4706[yyj4706] + yyv4707.CodecDecodeSelf(d) } } - if yyrt4690 { - for ; yyj4690 < yyl4690; yyj4690++ { - yyv4690 = append(yyv4690, EndpointAddress{}) - yyh4690.ElemContainerState(yyj4690) + if yyrt4706 { + for ; yyj4706 < yyl4706; yyj4706++ { + yyv4706 = append(yyv4706, EndpointAddress{}) + yyh4706.ElemContainerState(yyj4706) if r.TryDecodeAsNil() { - yyv4690[yyj4690] = EndpointAddress{} + yyv4706[yyj4706] = EndpointAddress{} } else { - yyv4692 := &yyv4690[yyj4690] - yyv4692.CodecDecodeSelf(d) + yyv4708 := &yyv4706[yyj4706] + yyv4708.CodecDecodeSelf(d) } } } } else { - yyj4690 := 0 - for ; !r.CheckBreak(); yyj4690++ { + yyj4706 := 0 + for ; !r.CheckBreak(); yyj4706++ { - if yyj4690 >= len(yyv4690) { - yyv4690 = append(yyv4690, EndpointAddress{}) // var yyz4690 EndpointAddress - yyc4690 = true + if yyj4706 >= len(yyv4706) { + yyv4706 = append(yyv4706, EndpointAddress{}) // var yyz4706 EndpointAddress + yyc4706 = true } - yyh4690.ElemContainerState(yyj4690) - if yyj4690 < len(yyv4690) { + yyh4706.ElemContainerState(yyj4706) + if yyj4706 < len(yyv4706) { if r.TryDecodeAsNil() { - yyv4690[yyj4690] = EndpointAddress{} + yyv4706[yyj4706] = EndpointAddress{} } else { - yyv4693 := &yyv4690[yyj4690] - yyv4693.CodecDecodeSelf(d) + yyv4709 := &yyv4706[yyj4706] + yyv4709.CodecDecodeSelf(d) } } else { @@ -59549,17 +59752,17 @@ func (x codecSelfer1234) decSliceEndpointAddress(v *[]EndpointAddress, d *codec1 } } - if yyj4690 < len(yyv4690) { - yyv4690 = yyv4690[:yyj4690] - yyc4690 = true - } else if yyj4690 == 0 && yyv4690 == nil { - yyv4690 = []EndpointAddress{} - yyc4690 = true + if yyj4706 < len(yyv4706) { + yyv4706 = yyv4706[:yyj4706] + yyc4706 = true + } else if yyj4706 == 0 && yyv4706 == nil { + yyv4706 = []EndpointAddress{} + yyc4706 = true } } - yyh4690.End() - if yyc4690 { - *v = yyv4690 + yyh4706.End() + if yyc4706 { + *v = yyv4706 } } @@ -59568,10 +59771,10 @@ func (x codecSelfer1234) encSliceEndpointPort(v []EndpointPort, e *codec1978.Enc z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4694 := range v { + for _, yyv4710 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4695 := &yyv4694 - yy4695.CodecEncodeSelf(e) + yy4711 := &yyv4710 + yy4711.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59581,83 +59784,83 @@ func (x codecSelfer1234) decSliceEndpointPort(v *[]EndpointPort, d *codec1978.De z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4696 := *v - yyh4696, yyl4696 := z.DecSliceHelperStart() - var yyc4696 bool - if yyl4696 == 0 { - if yyv4696 == nil { - yyv4696 = []EndpointPort{} - yyc4696 = true - } else if len(yyv4696) != 0 { - yyv4696 = yyv4696[:0] - yyc4696 = true + yyv4712 := *v + yyh4712, yyl4712 := z.DecSliceHelperStart() + var yyc4712 bool + if yyl4712 == 0 { + if yyv4712 == nil { + yyv4712 = []EndpointPort{} + yyc4712 = true + } else if len(yyv4712) != 0 { + yyv4712 = yyv4712[:0] + yyc4712 = true } - } else if yyl4696 > 0 { - var yyrr4696, yyrl4696 int - var yyrt4696 bool - if yyl4696 > cap(yyv4696) { + } else if yyl4712 > 0 { + var yyrr4712, yyrl4712 int + var yyrt4712 bool + if yyl4712 > cap(yyv4712) { - yyrg4696 := len(yyv4696) > 0 - yyv24696 := yyv4696 - yyrl4696, yyrt4696 = z.DecInferLen(yyl4696, z.DecBasicHandle().MaxInitLen, 40) - if yyrt4696 { - if yyrl4696 <= cap(yyv4696) { - yyv4696 = yyv4696[:yyrl4696] + yyrg4712 := len(yyv4712) > 0 + yyv24712 := yyv4712 + yyrl4712, yyrt4712 = z.DecInferLen(yyl4712, z.DecBasicHandle().MaxInitLen, 40) + if yyrt4712 { + if yyrl4712 <= cap(yyv4712) { + yyv4712 = yyv4712[:yyrl4712] } else { - yyv4696 = make([]EndpointPort, yyrl4696) + yyv4712 = make([]EndpointPort, yyrl4712) } } else { - yyv4696 = make([]EndpointPort, yyrl4696) + yyv4712 = make([]EndpointPort, yyrl4712) } - yyc4696 = true - yyrr4696 = len(yyv4696) - if yyrg4696 { - copy(yyv4696, yyv24696) + yyc4712 = true + yyrr4712 = len(yyv4712) + if yyrg4712 { + copy(yyv4712, yyv24712) } - } else if yyl4696 != len(yyv4696) { - yyv4696 = yyv4696[:yyl4696] - yyc4696 = true + } else if yyl4712 != len(yyv4712) { + yyv4712 = yyv4712[:yyl4712] + yyc4712 = true } - yyj4696 := 0 - for ; yyj4696 < yyrr4696; yyj4696++ { - yyh4696.ElemContainerState(yyj4696) + yyj4712 := 0 + for ; yyj4712 < yyrr4712; yyj4712++ { + yyh4712.ElemContainerState(yyj4712) if r.TryDecodeAsNil() { - yyv4696[yyj4696] = EndpointPort{} + yyv4712[yyj4712] = EndpointPort{} } else { - yyv4697 := &yyv4696[yyj4696] - yyv4697.CodecDecodeSelf(d) + yyv4713 := &yyv4712[yyj4712] + yyv4713.CodecDecodeSelf(d) } } - if yyrt4696 { - for ; yyj4696 < yyl4696; yyj4696++ { - yyv4696 = append(yyv4696, EndpointPort{}) - yyh4696.ElemContainerState(yyj4696) + if yyrt4712 { + for ; yyj4712 < yyl4712; yyj4712++ { + yyv4712 = append(yyv4712, EndpointPort{}) + yyh4712.ElemContainerState(yyj4712) if r.TryDecodeAsNil() { - yyv4696[yyj4696] = EndpointPort{} + yyv4712[yyj4712] = EndpointPort{} } else { - yyv4698 := &yyv4696[yyj4696] - yyv4698.CodecDecodeSelf(d) + yyv4714 := &yyv4712[yyj4712] + yyv4714.CodecDecodeSelf(d) } } } } else { - yyj4696 := 0 - for ; !r.CheckBreak(); yyj4696++ { + yyj4712 := 0 + for ; !r.CheckBreak(); yyj4712++ { - if yyj4696 >= len(yyv4696) { - yyv4696 = append(yyv4696, EndpointPort{}) // var yyz4696 EndpointPort - yyc4696 = true + if yyj4712 >= len(yyv4712) { + yyv4712 = append(yyv4712, EndpointPort{}) // var yyz4712 EndpointPort + yyc4712 = true } - yyh4696.ElemContainerState(yyj4696) - if yyj4696 < len(yyv4696) { + yyh4712.ElemContainerState(yyj4712) + if yyj4712 < len(yyv4712) { if r.TryDecodeAsNil() { - yyv4696[yyj4696] = EndpointPort{} + yyv4712[yyj4712] = EndpointPort{} } else { - yyv4699 := &yyv4696[yyj4696] - yyv4699.CodecDecodeSelf(d) + yyv4715 := &yyv4712[yyj4712] + yyv4715.CodecDecodeSelf(d) } } else { @@ -59665,17 +59868,17 @@ func (x codecSelfer1234) decSliceEndpointPort(v *[]EndpointPort, d *codec1978.De } } - if yyj4696 < len(yyv4696) { - yyv4696 = yyv4696[:yyj4696] - yyc4696 = true - } else if yyj4696 == 0 && yyv4696 == nil { - yyv4696 = []EndpointPort{} - yyc4696 = true + if yyj4712 < len(yyv4712) { + yyv4712 = yyv4712[:yyj4712] + yyc4712 = true + } else if yyj4712 == 0 && yyv4712 == nil { + yyv4712 = []EndpointPort{} + yyc4712 = true } } - yyh4696.End() - if yyc4696 { - *v = yyv4696 + yyh4712.End() + if yyc4712 { + *v = yyv4712 } } @@ -59684,10 +59887,10 @@ func (x codecSelfer1234) encSliceEndpoints(v []Endpoints, e *codec1978.Encoder) z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4700 := range v { + for _, yyv4716 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4701 := &yyv4700 - yy4701.CodecEncodeSelf(e) + yy4717 := &yyv4716 + yy4717.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59697,83 +59900,83 @@ func (x codecSelfer1234) decSliceEndpoints(v *[]Endpoints, d *codec1978.Decoder) z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4702 := *v - yyh4702, yyl4702 := z.DecSliceHelperStart() - var yyc4702 bool - if yyl4702 == 0 { - if yyv4702 == nil { - yyv4702 = []Endpoints{} - yyc4702 = true - } else if len(yyv4702) != 0 { - yyv4702 = yyv4702[:0] - yyc4702 = true + yyv4718 := *v + yyh4718, yyl4718 := z.DecSliceHelperStart() + var yyc4718 bool + if yyl4718 == 0 { + if yyv4718 == nil { + yyv4718 = []Endpoints{} + yyc4718 = true + } else if len(yyv4718) != 0 { + yyv4718 = yyv4718[:0] + yyc4718 = true } - } else if yyl4702 > 0 { - var yyrr4702, yyrl4702 int - var yyrt4702 bool - if yyl4702 > cap(yyv4702) { + } else if yyl4718 > 0 { + var yyrr4718, yyrl4718 int + var yyrt4718 bool + if yyl4718 > cap(yyv4718) { - yyrg4702 := len(yyv4702) > 0 - yyv24702 := yyv4702 - yyrl4702, yyrt4702 = z.DecInferLen(yyl4702, z.DecBasicHandle().MaxInitLen, 280) - if yyrt4702 { - if yyrl4702 <= cap(yyv4702) { - yyv4702 = yyv4702[:yyrl4702] + yyrg4718 := len(yyv4718) > 0 + yyv24718 := yyv4718 + yyrl4718, yyrt4718 = z.DecInferLen(yyl4718, z.DecBasicHandle().MaxInitLen, 280) + if yyrt4718 { + if yyrl4718 <= cap(yyv4718) { + yyv4718 = yyv4718[:yyrl4718] } else { - yyv4702 = make([]Endpoints, yyrl4702) + yyv4718 = make([]Endpoints, yyrl4718) } } else { - yyv4702 = make([]Endpoints, yyrl4702) + yyv4718 = make([]Endpoints, yyrl4718) } - yyc4702 = true - yyrr4702 = len(yyv4702) - if yyrg4702 { - copy(yyv4702, yyv24702) + yyc4718 = true + yyrr4718 = len(yyv4718) + if yyrg4718 { + copy(yyv4718, yyv24718) } - } else if yyl4702 != len(yyv4702) { - yyv4702 = yyv4702[:yyl4702] - yyc4702 = true + } else if yyl4718 != len(yyv4718) { + yyv4718 = yyv4718[:yyl4718] + yyc4718 = true } - yyj4702 := 0 - for ; yyj4702 < yyrr4702; yyj4702++ { - yyh4702.ElemContainerState(yyj4702) + yyj4718 := 0 + for ; yyj4718 < yyrr4718; yyj4718++ { + yyh4718.ElemContainerState(yyj4718) if r.TryDecodeAsNil() { - yyv4702[yyj4702] = Endpoints{} + yyv4718[yyj4718] = Endpoints{} } else { - yyv4703 := &yyv4702[yyj4702] - yyv4703.CodecDecodeSelf(d) + yyv4719 := &yyv4718[yyj4718] + yyv4719.CodecDecodeSelf(d) } } - if yyrt4702 { - for ; yyj4702 < yyl4702; yyj4702++ { - yyv4702 = append(yyv4702, Endpoints{}) - yyh4702.ElemContainerState(yyj4702) + if yyrt4718 { + for ; yyj4718 < yyl4718; yyj4718++ { + yyv4718 = append(yyv4718, Endpoints{}) + yyh4718.ElemContainerState(yyj4718) if r.TryDecodeAsNil() { - yyv4702[yyj4702] = Endpoints{} + yyv4718[yyj4718] = Endpoints{} } else { - yyv4704 := &yyv4702[yyj4702] - yyv4704.CodecDecodeSelf(d) + yyv4720 := &yyv4718[yyj4718] + yyv4720.CodecDecodeSelf(d) } } } } else { - yyj4702 := 0 - for ; !r.CheckBreak(); yyj4702++ { + yyj4718 := 0 + for ; !r.CheckBreak(); yyj4718++ { - if yyj4702 >= len(yyv4702) { - yyv4702 = append(yyv4702, Endpoints{}) // var yyz4702 Endpoints - yyc4702 = true + if yyj4718 >= len(yyv4718) { + yyv4718 = append(yyv4718, Endpoints{}) // var yyz4718 Endpoints + yyc4718 = true } - yyh4702.ElemContainerState(yyj4702) - if yyj4702 < len(yyv4702) { + yyh4718.ElemContainerState(yyj4718) + if yyj4718 < len(yyv4718) { if r.TryDecodeAsNil() { - yyv4702[yyj4702] = Endpoints{} + yyv4718[yyj4718] = Endpoints{} } else { - yyv4705 := &yyv4702[yyj4702] - yyv4705.CodecDecodeSelf(d) + yyv4721 := &yyv4718[yyj4718] + yyv4721.CodecDecodeSelf(d) } } else { @@ -59781,17 +59984,17 @@ func (x codecSelfer1234) decSliceEndpoints(v *[]Endpoints, d *codec1978.Decoder) } } - if yyj4702 < len(yyv4702) { - yyv4702 = yyv4702[:yyj4702] - yyc4702 = true - } else if yyj4702 == 0 && yyv4702 == nil { - yyv4702 = []Endpoints{} - yyc4702 = true + if yyj4718 < len(yyv4718) { + yyv4718 = yyv4718[:yyj4718] + yyc4718 = true + } else if yyj4718 == 0 && yyv4718 == nil { + yyv4718 = []Endpoints{} + yyc4718 = true } } - yyh4702.End() - if yyc4702 { - *v = yyv4702 + yyh4718.End() + if yyc4718 { + *v = yyv4718 } } @@ -59800,10 +60003,10 @@ func (x codecSelfer1234) encSliceNodeCondition(v []NodeCondition, e *codec1978.E z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4706 := range v { + for _, yyv4722 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4707 := &yyv4706 - yy4707.CodecEncodeSelf(e) + yy4723 := &yyv4722 + yy4723.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59813,83 +60016,83 @@ func (x codecSelfer1234) decSliceNodeCondition(v *[]NodeCondition, d *codec1978. z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4708 := *v - yyh4708, yyl4708 := z.DecSliceHelperStart() - var yyc4708 bool - if yyl4708 == 0 { - if yyv4708 == nil { - yyv4708 = []NodeCondition{} - yyc4708 = true - } else if len(yyv4708) != 0 { - yyv4708 = yyv4708[:0] - yyc4708 = true + yyv4724 := *v + yyh4724, yyl4724 := z.DecSliceHelperStart() + var yyc4724 bool + if yyl4724 == 0 { + if yyv4724 == nil { + yyv4724 = []NodeCondition{} + yyc4724 = true + } else if len(yyv4724) != 0 { + yyv4724 = yyv4724[:0] + yyc4724 = true } - } else if yyl4708 > 0 { - var yyrr4708, yyrl4708 int - var yyrt4708 bool - if yyl4708 > cap(yyv4708) { + } else if yyl4724 > 0 { + var yyrr4724, yyrl4724 int + var yyrt4724 bool + if yyl4724 > cap(yyv4724) { - yyrg4708 := len(yyv4708) > 0 - yyv24708 := yyv4708 - yyrl4708, yyrt4708 = z.DecInferLen(yyl4708, z.DecBasicHandle().MaxInitLen, 112) - if yyrt4708 { - if yyrl4708 <= cap(yyv4708) { - yyv4708 = yyv4708[:yyrl4708] + yyrg4724 := len(yyv4724) > 0 + yyv24724 := yyv4724 + yyrl4724, yyrt4724 = z.DecInferLen(yyl4724, z.DecBasicHandle().MaxInitLen, 112) + if yyrt4724 { + if yyrl4724 <= cap(yyv4724) { + yyv4724 = yyv4724[:yyrl4724] } else { - yyv4708 = make([]NodeCondition, yyrl4708) + yyv4724 = make([]NodeCondition, yyrl4724) } } else { - yyv4708 = make([]NodeCondition, yyrl4708) + yyv4724 = make([]NodeCondition, yyrl4724) } - yyc4708 = true - yyrr4708 = len(yyv4708) - if yyrg4708 { - copy(yyv4708, yyv24708) + yyc4724 = true + yyrr4724 = len(yyv4724) + if yyrg4724 { + copy(yyv4724, yyv24724) } - } else if yyl4708 != len(yyv4708) { - yyv4708 = yyv4708[:yyl4708] - yyc4708 = true + } else if yyl4724 != len(yyv4724) { + yyv4724 = yyv4724[:yyl4724] + yyc4724 = true } - yyj4708 := 0 - for ; yyj4708 < yyrr4708; yyj4708++ { - yyh4708.ElemContainerState(yyj4708) + yyj4724 := 0 + for ; yyj4724 < yyrr4724; yyj4724++ { + yyh4724.ElemContainerState(yyj4724) if r.TryDecodeAsNil() { - yyv4708[yyj4708] = NodeCondition{} + yyv4724[yyj4724] = NodeCondition{} } else { - yyv4709 := &yyv4708[yyj4708] - yyv4709.CodecDecodeSelf(d) + yyv4725 := &yyv4724[yyj4724] + yyv4725.CodecDecodeSelf(d) } } - if yyrt4708 { - for ; yyj4708 < yyl4708; yyj4708++ { - yyv4708 = append(yyv4708, NodeCondition{}) - yyh4708.ElemContainerState(yyj4708) + if yyrt4724 { + for ; yyj4724 < yyl4724; yyj4724++ { + yyv4724 = append(yyv4724, NodeCondition{}) + yyh4724.ElemContainerState(yyj4724) if r.TryDecodeAsNil() { - yyv4708[yyj4708] = NodeCondition{} + yyv4724[yyj4724] = NodeCondition{} } else { - yyv4710 := &yyv4708[yyj4708] - yyv4710.CodecDecodeSelf(d) + yyv4726 := &yyv4724[yyj4724] + yyv4726.CodecDecodeSelf(d) } } } } else { - yyj4708 := 0 - for ; !r.CheckBreak(); yyj4708++ { + yyj4724 := 0 + for ; !r.CheckBreak(); yyj4724++ { - if yyj4708 >= len(yyv4708) { - yyv4708 = append(yyv4708, NodeCondition{}) // var yyz4708 NodeCondition - yyc4708 = true + if yyj4724 >= len(yyv4724) { + yyv4724 = append(yyv4724, NodeCondition{}) // var yyz4724 NodeCondition + yyc4724 = true } - yyh4708.ElemContainerState(yyj4708) - if yyj4708 < len(yyv4708) { + yyh4724.ElemContainerState(yyj4724) + if yyj4724 < len(yyv4724) { if r.TryDecodeAsNil() { - yyv4708[yyj4708] = NodeCondition{} + yyv4724[yyj4724] = NodeCondition{} } else { - yyv4711 := &yyv4708[yyj4708] - yyv4711.CodecDecodeSelf(d) + yyv4727 := &yyv4724[yyj4724] + yyv4727.CodecDecodeSelf(d) } } else { @@ -59897,17 +60100,17 @@ func (x codecSelfer1234) decSliceNodeCondition(v *[]NodeCondition, d *codec1978. } } - if yyj4708 < len(yyv4708) { - yyv4708 = yyv4708[:yyj4708] - yyc4708 = true - } else if yyj4708 == 0 && yyv4708 == nil { - yyv4708 = []NodeCondition{} - yyc4708 = true + if yyj4724 < len(yyv4724) { + yyv4724 = yyv4724[:yyj4724] + yyc4724 = true + } else if yyj4724 == 0 && yyv4724 == nil { + yyv4724 = []NodeCondition{} + yyc4724 = true } } - yyh4708.End() - if yyc4708 { - *v = yyv4708 + yyh4724.End() + if yyc4724 { + *v = yyv4724 } } @@ -59916,10 +60119,10 @@ func (x codecSelfer1234) encSliceNodeAddress(v []NodeAddress, e *codec1978.Encod z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4712 := range v { + for _, yyv4728 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4713 := &yyv4712 - yy4713.CodecEncodeSelf(e) + yy4729 := &yyv4728 + yy4729.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -59929,83 +60132,83 @@ func (x codecSelfer1234) decSliceNodeAddress(v *[]NodeAddress, d *codec1978.Deco z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4714 := *v - yyh4714, yyl4714 := z.DecSliceHelperStart() - var yyc4714 bool - if yyl4714 == 0 { - if yyv4714 == nil { - yyv4714 = []NodeAddress{} - yyc4714 = true - } else if len(yyv4714) != 0 { - yyv4714 = yyv4714[:0] - yyc4714 = true + yyv4730 := *v + yyh4730, yyl4730 := z.DecSliceHelperStart() + var yyc4730 bool + if yyl4730 == 0 { + if yyv4730 == nil { + yyv4730 = []NodeAddress{} + yyc4730 = true + } else if len(yyv4730) != 0 { + yyv4730 = yyv4730[:0] + yyc4730 = true } - } else if yyl4714 > 0 { - var yyrr4714, yyrl4714 int - var yyrt4714 bool - if yyl4714 > cap(yyv4714) { + } else if yyl4730 > 0 { + var yyrr4730, yyrl4730 int + var yyrt4730 bool + if yyl4730 > cap(yyv4730) { - yyrg4714 := len(yyv4714) > 0 - yyv24714 := yyv4714 - yyrl4714, yyrt4714 = z.DecInferLen(yyl4714, z.DecBasicHandle().MaxInitLen, 32) - if yyrt4714 { - if yyrl4714 <= cap(yyv4714) { - yyv4714 = yyv4714[:yyrl4714] + yyrg4730 := len(yyv4730) > 0 + yyv24730 := yyv4730 + yyrl4730, yyrt4730 = z.DecInferLen(yyl4730, z.DecBasicHandle().MaxInitLen, 32) + if yyrt4730 { + if yyrl4730 <= cap(yyv4730) { + yyv4730 = yyv4730[:yyrl4730] } else { - yyv4714 = make([]NodeAddress, yyrl4714) + yyv4730 = make([]NodeAddress, yyrl4730) } } else { - yyv4714 = make([]NodeAddress, yyrl4714) + yyv4730 = make([]NodeAddress, yyrl4730) } - yyc4714 = true - yyrr4714 = len(yyv4714) - if yyrg4714 { - copy(yyv4714, yyv24714) + yyc4730 = true + yyrr4730 = len(yyv4730) + if yyrg4730 { + copy(yyv4730, yyv24730) } - } else if yyl4714 != len(yyv4714) { - yyv4714 = yyv4714[:yyl4714] - yyc4714 = true + } else if yyl4730 != len(yyv4730) { + yyv4730 = yyv4730[:yyl4730] + yyc4730 = true } - yyj4714 := 0 - for ; yyj4714 < yyrr4714; yyj4714++ { - yyh4714.ElemContainerState(yyj4714) + yyj4730 := 0 + for ; yyj4730 < yyrr4730; yyj4730++ { + yyh4730.ElemContainerState(yyj4730) if r.TryDecodeAsNil() { - yyv4714[yyj4714] = NodeAddress{} + yyv4730[yyj4730] = NodeAddress{} } else { - yyv4715 := &yyv4714[yyj4714] - yyv4715.CodecDecodeSelf(d) + yyv4731 := &yyv4730[yyj4730] + yyv4731.CodecDecodeSelf(d) } } - if yyrt4714 { - for ; yyj4714 < yyl4714; yyj4714++ { - yyv4714 = append(yyv4714, NodeAddress{}) - yyh4714.ElemContainerState(yyj4714) + if yyrt4730 { + for ; yyj4730 < yyl4730; yyj4730++ { + yyv4730 = append(yyv4730, NodeAddress{}) + yyh4730.ElemContainerState(yyj4730) if r.TryDecodeAsNil() { - yyv4714[yyj4714] = NodeAddress{} + yyv4730[yyj4730] = NodeAddress{} } else { - yyv4716 := &yyv4714[yyj4714] - yyv4716.CodecDecodeSelf(d) + yyv4732 := &yyv4730[yyj4730] + yyv4732.CodecDecodeSelf(d) } } } } else { - yyj4714 := 0 - for ; !r.CheckBreak(); yyj4714++ { + yyj4730 := 0 + for ; !r.CheckBreak(); yyj4730++ { - if yyj4714 >= len(yyv4714) { - yyv4714 = append(yyv4714, NodeAddress{}) // var yyz4714 NodeAddress - yyc4714 = true + if yyj4730 >= len(yyv4730) { + yyv4730 = append(yyv4730, NodeAddress{}) // var yyz4730 NodeAddress + yyc4730 = true } - yyh4714.ElemContainerState(yyj4714) - if yyj4714 < len(yyv4714) { + yyh4730.ElemContainerState(yyj4730) + if yyj4730 < len(yyv4730) { if r.TryDecodeAsNil() { - yyv4714[yyj4714] = NodeAddress{} + yyv4730[yyj4730] = NodeAddress{} } else { - yyv4717 := &yyv4714[yyj4714] - yyv4717.CodecDecodeSelf(d) + yyv4733 := &yyv4730[yyj4730] + yyv4733.CodecDecodeSelf(d) } } else { @@ -60013,17 +60216,17 @@ func (x codecSelfer1234) decSliceNodeAddress(v *[]NodeAddress, d *codec1978.Deco } } - if yyj4714 < len(yyv4714) { - yyv4714 = yyv4714[:yyj4714] - yyc4714 = true - } else if yyj4714 == 0 && yyv4714 == nil { - yyv4714 = []NodeAddress{} - yyc4714 = true + if yyj4730 < len(yyv4730) { + yyv4730 = yyv4730[:yyj4730] + yyc4730 = true + } else if yyj4730 == 0 && yyv4730 == nil { + yyv4730 = []NodeAddress{} + yyc4730 = true } } - yyh4714.End() - if yyc4714 { - *v = yyv4714 + yyh4730.End() + if yyc4730 { + *v = yyv4730 } } @@ -60032,10 +60235,10 @@ func (x codecSelfer1234) encSliceContainerImage(v []ContainerImage, e *codec1978 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4718 := range v { + for _, yyv4734 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4719 := &yyv4718 - yy4719.CodecEncodeSelf(e) + yy4735 := &yyv4734 + yy4735.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -60045,83 +60248,83 @@ func (x codecSelfer1234) decSliceContainerImage(v *[]ContainerImage, d *codec197 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4720 := *v - yyh4720, yyl4720 := z.DecSliceHelperStart() - var yyc4720 bool - if yyl4720 == 0 { - if yyv4720 == nil { - yyv4720 = []ContainerImage{} - yyc4720 = true - } else if len(yyv4720) != 0 { - yyv4720 = yyv4720[:0] - yyc4720 = true + yyv4736 := *v + yyh4736, yyl4736 := z.DecSliceHelperStart() + var yyc4736 bool + if yyl4736 == 0 { + if yyv4736 == nil { + yyv4736 = []ContainerImage{} + yyc4736 = true + } else if len(yyv4736) != 0 { + yyv4736 = yyv4736[:0] + yyc4736 = true } - } else if yyl4720 > 0 { - var yyrr4720, yyrl4720 int - var yyrt4720 bool - if yyl4720 > cap(yyv4720) { + } else if yyl4736 > 0 { + var yyrr4736, yyrl4736 int + var yyrt4736 bool + if yyl4736 > cap(yyv4736) { - yyrg4720 := len(yyv4720) > 0 - yyv24720 := yyv4720 - yyrl4720, yyrt4720 = z.DecInferLen(yyl4720, z.DecBasicHandle().MaxInitLen, 32) - if yyrt4720 { - if yyrl4720 <= cap(yyv4720) { - yyv4720 = yyv4720[:yyrl4720] + yyrg4736 := len(yyv4736) > 0 + yyv24736 := yyv4736 + yyrl4736, yyrt4736 = z.DecInferLen(yyl4736, z.DecBasicHandle().MaxInitLen, 32) + if yyrt4736 { + if yyrl4736 <= cap(yyv4736) { + yyv4736 = yyv4736[:yyrl4736] } else { - yyv4720 = make([]ContainerImage, yyrl4720) + yyv4736 = make([]ContainerImage, yyrl4736) } } else { - yyv4720 = make([]ContainerImage, yyrl4720) + yyv4736 = make([]ContainerImage, yyrl4736) } - yyc4720 = true - yyrr4720 = len(yyv4720) - if yyrg4720 { - copy(yyv4720, yyv24720) + yyc4736 = true + yyrr4736 = len(yyv4736) + if yyrg4736 { + copy(yyv4736, yyv24736) } - } else if yyl4720 != len(yyv4720) { - yyv4720 = yyv4720[:yyl4720] - yyc4720 = true + } else if yyl4736 != len(yyv4736) { + yyv4736 = yyv4736[:yyl4736] + yyc4736 = true } - yyj4720 := 0 - for ; yyj4720 < yyrr4720; yyj4720++ { - yyh4720.ElemContainerState(yyj4720) + yyj4736 := 0 + for ; yyj4736 < yyrr4736; yyj4736++ { + yyh4736.ElemContainerState(yyj4736) if r.TryDecodeAsNil() { - yyv4720[yyj4720] = ContainerImage{} + yyv4736[yyj4736] = ContainerImage{} } else { - yyv4721 := &yyv4720[yyj4720] - yyv4721.CodecDecodeSelf(d) + yyv4737 := &yyv4736[yyj4736] + yyv4737.CodecDecodeSelf(d) } } - if yyrt4720 { - for ; yyj4720 < yyl4720; yyj4720++ { - yyv4720 = append(yyv4720, ContainerImage{}) - yyh4720.ElemContainerState(yyj4720) + if yyrt4736 { + for ; yyj4736 < yyl4736; yyj4736++ { + yyv4736 = append(yyv4736, ContainerImage{}) + yyh4736.ElemContainerState(yyj4736) if r.TryDecodeAsNil() { - yyv4720[yyj4720] = ContainerImage{} + yyv4736[yyj4736] = ContainerImage{} } else { - yyv4722 := &yyv4720[yyj4720] - yyv4722.CodecDecodeSelf(d) + yyv4738 := &yyv4736[yyj4736] + yyv4738.CodecDecodeSelf(d) } } } } else { - yyj4720 := 0 - for ; !r.CheckBreak(); yyj4720++ { + yyj4736 := 0 + for ; !r.CheckBreak(); yyj4736++ { - if yyj4720 >= len(yyv4720) { - yyv4720 = append(yyv4720, ContainerImage{}) // var yyz4720 ContainerImage - yyc4720 = true + if yyj4736 >= len(yyv4736) { + yyv4736 = append(yyv4736, ContainerImage{}) // var yyz4736 ContainerImage + yyc4736 = true } - yyh4720.ElemContainerState(yyj4720) - if yyj4720 < len(yyv4720) { + yyh4736.ElemContainerState(yyj4736) + if yyj4736 < len(yyv4736) { if r.TryDecodeAsNil() { - yyv4720[yyj4720] = ContainerImage{} + yyv4736[yyj4736] = ContainerImage{} } else { - yyv4723 := &yyv4720[yyj4720] - yyv4723.CodecDecodeSelf(d) + yyv4739 := &yyv4736[yyj4736] + yyv4739.CodecDecodeSelf(d) } } else { @@ -60129,17 +60332,17 @@ func (x codecSelfer1234) decSliceContainerImage(v *[]ContainerImage, d *codec197 } } - if yyj4720 < len(yyv4720) { - yyv4720 = yyv4720[:yyj4720] - yyc4720 = true - } else if yyj4720 == 0 && yyv4720 == nil { - yyv4720 = []ContainerImage{} - yyc4720 = true + if yyj4736 < len(yyv4736) { + yyv4736 = yyv4736[:yyj4736] + yyc4736 = true + } else if yyj4736 == 0 && yyv4736 == nil { + yyv4736 = []ContainerImage{} + yyc4736 = true } } - yyh4720.End() - if yyc4720 { - *v = yyv4720 + yyh4736.End() + if yyc4736 { + *v = yyv4736 } } @@ -60148,9 +60351,9 @@ func (x codecSelfer1234) encSliceUniqueVolumeName(v []UniqueVolumeName, e *codec z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4724 := range v { + for _, yyv4740 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yyv4724.CodecEncodeSelf(e) + yyv4740.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -60160,75 +60363,75 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4725 := *v - yyh4725, yyl4725 := z.DecSliceHelperStart() - var yyc4725 bool - if yyl4725 == 0 { - if yyv4725 == nil { - yyv4725 = []UniqueVolumeName{} - yyc4725 = true - } else if len(yyv4725) != 0 { - yyv4725 = yyv4725[:0] - yyc4725 = true + yyv4741 := *v + yyh4741, yyl4741 := z.DecSliceHelperStart() + var yyc4741 bool + if yyl4741 == 0 { + if yyv4741 == nil { + yyv4741 = []UniqueVolumeName{} + yyc4741 = true + } else if len(yyv4741) != 0 { + yyv4741 = yyv4741[:0] + yyc4741 = true } - } else if yyl4725 > 0 { - var yyrr4725, yyrl4725 int - var yyrt4725 bool - if yyl4725 > cap(yyv4725) { + } else if yyl4741 > 0 { + var yyrr4741, yyrl4741 int + var yyrt4741 bool + if yyl4741 > cap(yyv4741) { - yyrl4725, yyrt4725 = z.DecInferLen(yyl4725, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4725 { - if yyrl4725 <= cap(yyv4725) { - yyv4725 = yyv4725[:yyrl4725] + yyrl4741, yyrt4741 = z.DecInferLen(yyl4741, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4741 { + if yyrl4741 <= cap(yyv4741) { + yyv4741 = yyv4741[:yyrl4741] } else { - yyv4725 = make([]UniqueVolumeName, yyrl4725) + yyv4741 = make([]UniqueVolumeName, yyrl4741) } } else { - yyv4725 = make([]UniqueVolumeName, yyrl4725) + yyv4741 = make([]UniqueVolumeName, yyrl4741) } - yyc4725 = true - yyrr4725 = len(yyv4725) - } else if yyl4725 != len(yyv4725) { - yyv4725 = yyv4725[:yyl4725] - yyc4725 = true + yyc4741 = true + yyrr4741 = len(yyv4741) + } else if yyl4741 != len(yyv4741) { + yyv4741 = yyv4741[:yyl4741] + yyc4741 = true } - yyj4725 := 0 - for ; yyj4725 < yyrr4725; yyj4725++ { - yyh4725.ElemContainerState(yyj4725) + yyj4741 := 0 + for ; yyj4741 < yyrr4741; yyj4741++ { + yyh4741.ElemContainerState(yyj4741) if r.TryDecodeAsNil() { - yyv4725[yyj4725] = "" + yyv4741[yyj4741] = "" } else { - yyv4725[yyj4725] = UniqueVolumeName(r.DecodeString()) + yyv4741[yyj4741] = UniqueVolumeName(r.DecodeString()) } } - if yyrt4725 { - for ; yyj4725 < yyl4725; yyj4725++ { - yyv4725 = append(yyv4725, "") - yyh4725.ElemContainerState(yyj4725) + if yyrt4741 { + for ; yyj4741 < yyl4741; yyj4741++ { + yyv4741 = append(yyv4741, "") + yyh4741.ElemContainerState(yyj4741) if r.TryDecodeAsNil() { - yyv4725[yyj4725] = "" + yyv4741[yyj4741] = "" } else { - yyv4725[yyj4725] = UniqueVolumeName(r.DecodeString()) + yyv4741[yyj4741] = UniqueVolumeName(r.DecodeString()) } } } } else { - yyj4725 := 0 - for ; !r.CheckBreak(); yyj4725++ { + yyj4741 := 0 + for ; !r.CheckBreak(); yyj4741++ { - if yyj4725 >= len(yyv4725) { - yyv4725 = append(yyv4725, "") // var yyz4725 UniqueVolumeName - yyc4725 = true + if yyj4741 >= len(yyv4741) { + yyv4741 = append(yyv4741, "") // var yyz4741 UniqueVolumeName + yyc4741 = true } - yyh4725.ElemContainerState(yyj4725) - if yyj4725 < len(yyv4725) { + yyh4741.ElemContainerState(yyj4741) + if yyj4741 < len(yyv4741) { if r.TryDecodeAsNil() { - yyv4725[yyj4725] = "" + yyv4741[yyj4741] = "" } else { - yyv4725[yyj4725] = UniqueVolumeName(r.DecodeString()) + yyv4741[yyj4741] = UniqueVolumeName(r.DecodeString()) } } else { @@ -60236,17 +60439,17 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code } } - if yyj4725 < len(yyv4725) { - yyv4725 = yyv4725[:yyj4725] - yyc4725 = true - } else if yyj4725 == 0 && yyv4725 == nil { - yyv4725 = []UniqueVolumeName{} - yyc4725 = true + if yyj4741 < len(yyv4741) { + yyv4741 = yyv4741[:yyj4741] + yyc4741 = true + } else if yyj4741 == 0 && yyv4741 == nil { + yyv4741 = []UniqueVolumeName{} + yyc4741 = true } } - yyh4725.End() - if yyc4725 { - *v = yyv4725 + yyh4741.End() + if yyc4741 { + *v = yyv4741 } } @@ -60255,10 +60458,10 @@ func (x codecSelfer1234) encSliceAttachedVolume(v []AttachedVolume, e *codec1978 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4729 := range v { + for _, yyv4745 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4730 := &yyv4729 - yy4730.CodecEncodeSelf(e) + yy4746 := &yyv4745 + yy4746.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -60268,83 +60471,83 @@ func (x codecSelfer1234) decSliceAttachedVolume(v *[]AttachedVolume, d *codec197 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4731 := *v - yyh4731, yyl4731 := z.DecSliceHelperStart() - var yyc4731 bool - if yyl4731 == 0 { - if yyv4731 == nil { - yyv4731 = []AttachedVolume{} - yyc4731 = true - } else if len(yyv4731) != 0 { - yyv4731 = yyv4731[:0] - yyc4731 = true + yyv4747 := *v + yyh4747, yyl4747 := z.DecSliceHelperStart() + var yyc4747 bool + if yyl4747 == 0 { + if yyv4747 == nil { + yyv4747 = []AttachedVolume{} + yyc4747 = true + } else if len(yyv4747) != 0 { + yyv4747 = yyv4747[:0] + yyc4747 = true } - } else if yyl4731 > 0 { - var yyrr4731, yyrl4731 int - var yyrt4731 bool - if yyl4731 > cap(yyv4731) { + } else if yyl4747 > 0 { + var yyrr4747, yyrl4747 int + var yyrt4747 bool + if yyl4747 > cap(yyv4747) { - yyrg4731 := len(yyv4731) > 0 - yyv24731 := yyv4731 - yyrl4731, yyrt4731 = z.DecInferLen(yyl4731, z.DecBasicHandle().MaxInitLen, 32) - if yyrt4731 { - if yyrl4731 <= cap(yyv4731) { - yyv4731 = yyv4731[:yyrl4731] + yyrg4747 := len(yyv4747) > 0 + yyv24747 := yyv4747 + yyrl4747, yyrt4747 = z.DecInferLen(yyl4747, z.DecBasicHandle().MaxInitLen, 32) + if yyrt4747 { + if yyrl4747 <= cap(yyv4747) { + yyv4747 = yyv4747[:yyrl4747] } else { - yyv4731 = make([]AttachedVolume, yyrl4731) + yyv4747 = make([]AttachedVolume, yyrl4747) } } else { - yyv4731 = make([]AttachedVolume, yyrl4731) + yyv4747 = make([]AttachedVolume, yyrl4747) } - yyc4731 = true - yyrr4731 = len(yyv4731) - if yyrg4731 { - copy(yyv4731, yyv24731) + yyc4747 = true + yyrr4747 = len(yyv4747) + if yyrg4747 { + copy(yyv4747, yyv24747) } - } else if yyl4731 != len(yyv4731) { - yyv4731 = yyv4731[:yyl4731] - yyc4731 = true + } else if yyl4747 != len(yyv4747) { + yyv4747 = yyv4747[:yyl4747] + yyc4747 = true } - yyj4731 := 0 - for ; yyj4731 < yyrr4731; yyj4731++ { - yyh4731.ElemContainerState(yyj4731) + yyj4747 := 0 + for ; yyj4747 < yyrr4747; yyj4747++ { + yyh4747.ElemContainerState(yyj4747) if r.TryDecodeAsNil() { - yyv4731[yyj4731] = AttachedVolume{} + yyv4747[yyj4747] = AttachedVolume{} } else { - yyv4732 := &yyv4731[yyj4731] - yyv4732.CodecDecodeSelf(d) + yyv4748 := &yyv4747[yyj4747] + yyv4748.CodecDecodeSelf(d) } } - if yyrt4731 { - for ; yyj4731 < yyl4731; yyj4731++ { - yyv4731 = append(yyv4731, AttachedVolume{}) - yyh4731.ElemContainerState(yyj4731) + if yyrt4747 { + for ; yyj4747 < yyl4747; yyj4747++ { + yyv4747 = append(yyv4747, AttachedVolume{}) + yyh4747.ElemContainerState(yyj4747) if r.TryDecodeAsNil() { - yyv4731[yyj4731] = AttachedVolume{} + yyv4747[yyj4747] = AttachedVolume{} } else { - yyv4733 := &yyv4731[yyj4731] - yyv4733.CodecDecodeSelf(d) + yyv4749 := &yyv4747[yyj4747] + yyv4749.CodecDecodeSelf(d) } } } } else { - yyj4731 := 0 - for ; !r.CheckBreak(); yyj4731++ { + yyj4747 := 0 + for ; !r.CheckBreak(); yyj4747++ { - if yyj4731 >= len(yyv4731) { - yyv4731 = append(yyv4731, AttachedVolume{}) // var yyz4731 AttachedVolume - yyc4731 = true + if yyj4747 >= len(yyv4747) { + yyv4747 = append(yyv4747, AttachedVolume{}) // var yyz4747 AttachedVolume + yyc4747 = true } - yyh4731.ElemContainerState(yyj4731) - if yyj4731 < len(yyv4731) { + yyh4747.ElemContainerState(yyj4747) + if yyj4747 < len(yyv4747) { if r.TryDecodeAsNil() { - yyv4731[yyj4731] = AttachedVolume{} + yyv4747[yyj4747] = AttachedVolume{} } else { - yyv4734 := &yyv4731[yyj4731] - yyv4734.CodecDecodeSelf(d) + yyv4750 := &yyv4747[yyj4747] + yyv4750.CodecDecodeSelf(d) } } else { @@ -60352,251 +60555,21 @@ func (x codecSelfer1234) decSliceAttachedVolume(v *[]AttachedVolume, d *codec197 } } - if yyj4731 < len(yyv4731) { - yyv4731 = yyv4731[:yyj4731] - yyc4731 = true - } else if yyj4731 == 0 && yyv4731 == nil { - yyv4731 = []AttachedVolume{} - yyc4731 = true + if yyj4747 < len(yyv4747) { + yyv4747 = yyv4747[:yyj4747] + yyc4747 = true + } else if yyj4747 == 0 && yyv4747 == nil { + yyv4747 = []AttachedVolume{} + yyc4747 = true } } - yyh4731.End() - if yyc4731 { - *v = yyv4731 + yyh4747.End() + if yyc4747 { + *v = yyv4747 } } func (x codecSelfer1234) encSlicePreferAvoidPodsEntry(v []PreferAvoidPodsEntry, e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - r.EncodeArrayStart(len(v)) - for _, yyv4735 := range v { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4736 := &yyv4735 - yy4736.CodecEncodeSelf(e) - } - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x codecSelfer1234) decSlicePreferAvoidPodsEntry(v *[]PreferAvoidPodsEntry, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - - yyv4737 := *v - yyh4737, yyl4737 := z.DecSliceHelperStart() - var yyc4737 bool - if yyl4737 == 0 { - if yyv4737 == nil { - yyv4737 = []PreferAvoidPodsEntry{} - yyc4737 = true - } else if len(yyv4737) != 0 { - yyv4737 = yyv4737[:0] - yyc4737 = true - } - } else if yyl4737 > 0 { - var yyrr4737, yyrl4737 int - var yyrt4737 bool - if yyl4737 > cap(yyv4737) { - - yyrg4737 := len(yyv4737) > 0 - yyv24737 := yyv4737 - yyrl4737, yyrt4737 = z.DecInferLen(yyl4737, z.DecBasicHandle().MaxInitLen, 64) - if yyrt4737 { - if yyrl4737 <= cap(yyv4737) { - yyv4737 = yyv4737[:yyrl4737] - } else { - yyv4737 = make([]PreferAvoidPodsEntry, yyrl4737) - } - } else { - yyv4737 = make([]PreferAvoidPodsEntry, yyrl4737) - } - yyc4737 = true - yyrr4737 = len(yyv4737) - if yyrg4737 { - copy(yyv4737, yyv24737) - } - } else if yyl4737 != len(yyv4737) { - yyv4737 = yyv4737[:yyl4737] - yyc4737 = true - } - yyj4737 := 0 - for ; yyj4737 < yyrr4737; yyj4737++ { - yyh4737.ElemContainerState(yyj4737) - if r.TryDecodeAsNil() { - yyv4737[yyj4737] = PreferAvoidPodsEntry{} - } else { - yyv4738 := &yyv4737[yyj4737] - yyv4738.CodecDecodeSelf(d) - } - - } - if yyrt4737 { - for ; yyj4737 < yyl4737; yyj4737++ { - yyv4737 = append(yyv4737, PreferAvoidPodsEntry{}) - yyh4737.ElemContainerState(yyj4737) - if r.TryDecodeAsNil() { - yyv4737[yyj4737] = PreferAvoidPodsEntry{} - } else { - yyv4739 := &yyv4737[yyj4737] - yyv4739.CodecDecodeSelf(d) - } - - } - } - - } else { - yyj4737 := 0 - for ; !r.CheckBreak(); yyj4737++ { - - if yyj4737 >= len(yyv4737) { - yyv4737 = append(yyv4737, PreferAvoidPodsEntry{}) // var yyz4737 PreferAvoidPodsEntry - yyc4737 = true - } - yyh4737.ElemContainerState(yyj4737) - if yyj4737 < len(yyv4737) { - if r.TryDecodeAsNil() { - yyv4737[yyj4737] = PreferAvoidPodsEntry{} - } else { - yyv4740 := &yyv4737[yyj4737] - yyv4740.CodecDecodeSelf(d) - } - - } else { - z.DecSwallow() - } - - } - if yyj4737 < len(yyv4737) { - yyv4737 = yyv4737[:yyj4737] - yyc4737 = true - } else if yyj4737 == 0 && yyv4737 == nil { - yyv4737 = []PreferAvoidPodsEntry{} - yyc4737 = true - } - } - yyh4737.End() - if yyc4737 { - *v = yyv4737 - } -} - -func (x codecSelfer1234) encResourceList(v ResourceList, e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - r.EncodeMapStart(len(v)) - for yyk4741, yyv4741 := range v { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - yyk4741.CodecEncodeSelf(e) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy4742 := &yyv4741 - yym4743 := z.EncBinary() - _ = yym4743 - if false { - } else if z.HasExtensions() && z.EncExt(yy4742) { - } else if !yym4743 && z.IsJSONHandle() { - z.EncJSONMarshal(yy4742) - } else { - z.EncFallback(yy4742) - } - } - z.EncSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x codecSelfer1234) decResourceList(v *ResourceList, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - - yyv4744 := *v - yyl4744 := r.ReadMapStart() - yybh4744 := z.DecBasicHandle() - if yyv4744 == nil { - yyrl4744, _ := z.DecInferLen(yyl4744, yybh4744.MaxInitLen, 72) - yyv4744 = make(map[ResourceName]pkg3_resource.Quantity, yyrl4744) - *v = yyv4744 - } - var yymk4744 ResourceName - var yymv4744 pkg3_resource.Quantity - var yymg4744 bool - if yybh4744.MapValueReset { - yymg4744 = true - } - if yyl4744 > 0 { - for yyj4744 := 0; yyj4744 < yyl4744; yyj4744++ { - z.DecSendContainerState(codecSelfer_containerMapKey1234) - if r.TryDecodeAsNil() { - yymk4744 = "" - } else { - yymk4744 = ResourceName(r.DecodeString()) - } - - if yymg4744 { - yymv4744 = yyv4744[yymk4744] - } else { - yymv4744 = pkg3_resource.Quantity{} - } - z.DecSendContainerState(codecSelfer_containerMapValue1234) - if r.TryDecodeAsNil() { - yymv4744 = pkg3_resource.Quantity{} - } else { - yyv4746 := &yymv4744 - yym4747 := z.DecBinary() - _ = yym4747 - if false { - } else if z.HasExtensions() && z.DecExt(yyv4746) { - } else if !yym4747 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv4746) - } else { - z.DecFallback(yyv4746, false) - } - } - - if yyv4744 != nil { - yyv4744[yymk4744] = yymv4744 - } - } - } else if yyl4744 < 0 { - for yyj4744 := 0; !r.CheckBreak(); yyj4744++ { - z.DecSendContainerState(codecSelfer_containerMapKey1234) - if r.TryDecodeAsNil() { - yymk4744 = "" - } else { - yymk4744 = ResourceName(r.DecodeString()) - } - - if yymg4744 { - yymv4744 = yyv4744[yymk4744] - } else { - yymv4744 = pkg3_resource.Quantity{} - } - z.DecSendContainerState(codecSelfer_containerMapValue1234) - if r.TryDecodeAsNil() { - yymv4744 = pkg3_resource.Quantity{} - } else { - yyv4749 := &yymv4744 - yym4750 := z.DecBinary() - _ = yym4750 - if false { - } else if z.HasExtensions() && z.DecExt(yyv4749) { - } else if !yym4750 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv4749) - } else { - z.DecFallback(yyv4749, false) - } - } - - if yyv4744 != nil { - yyv4744[yymk4744] = yymv4744 - } - } - } // else len==0: TODO: Should we clear map entries? - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x codecSelfer1234) encSliceNode(v []Node, e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -60609,7 +60582,7 @@ func (x codecSelfer1234) encSliceNode(v []Node, e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } -func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { +func (x codecSelfer1234) decSlicePreferAvoidPodsEntry(v *[]PreferAvoidPodsEntry, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r @@ -60619,7 +60592,7 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { var yyc4753 bool if yyl4753 == 0 { if yyv4753 == nil { - yyv4753 = []Node{} + yyv4753 = []PreferAvoidPodsEntry{} yyc4753 = true } else if len(yyv4753) != 0 { yyv4753 = yyv4753[:0] @@ -60632,15 +60605,15 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { yyrg4753 := len(yyv4753) > 0 yyv24753 := yyv4753 - yyrl4753, yyrt4753 = z.DecInferLen(yyl4753, z.DecBasicHandle().MaxInitLen, 632) + yyrl4753, yyrt4753 = z.DecInferLen(yyl4753, z.DecBasicHandle().MaxInitLen, 64) if yyrt4753 { if yyrl4753 <= cap(yyv4753) { yyv4753 = yyv4753[:yyrl4753] } else { - yyv4753 = make([]Node, yyrl4753) + yyv4753 = make([]PreferAvoidPodsEntry, yyrl4753) } } else { - yyv4753 = make([]Node, yyrl4753) + yyv4753 = make([]PreferAvoidPodsEntry, yyrl4753) } yyc4753 = true yyrr4753 = len(yyv4753) @@ -60655,7 +60628,7 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { for ; yyj4753 < yyrr4753; yyj4753++ { yyh4753.ElemContainerState(yyj4753) if r.TryDecodeAsNil() { - yyv4753[yyj4753] = Node{} + yyv4753[yyj4753] = PreferAvoidPodsEntry{} } else { yyv4754 := &yyv4753[yyj4753] yyv4754.CodecDecodeSelf(d) @@ -60664,10 +60637,10 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { } if yyrt4753 { for ; yyj4753 < yyl4753; yyj4753++ { - yyv4753 = append(yyv4753, Node{}) + yyv4753 = append(yyv4753, PreferAvoidPodsEntry{}) yyh4753.ElemContainerState(yyj4753) if r.TryDecodeAsNil() { - yyv4753[yyj4753] = Node{} + yyv4753[yyj4753] = PreferAvoidPodsEntry{} } else { yyv4755 := &yyv4753[yyj4753] yyv4755.CodecDecodeSelf(d) @@ -60681,13 +60654,13 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { for ; !r.CheckBreak(); yyj4753++ { if yyj4753 >= len(yyv4753) { - yyv4753 = append(yyv4753, Node{}) // var yyz4753 Node + yyv4753 = append(yyv4753, PreferAvoidPodsEntry{}) // var yyz4753 PreferAvoidPodsEntry yyc4753 = true } yyh4753.ElemContainerState(yyj4753) if yyj4753 < len(yyv4753) { if r.TryDecodeAsNil() { - yyv4753[yyj4753] = Node{} + yyv4753[yyj4753] = PreferAvoidPodsEntry{} } else { yyv4756 := &yyv4753[yyj4753] yyv4756.CodecDecodeSelf(d) @@ -60702,7 +60675,7 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { yyv4753 = yyv4753[:yyj4753] yyc4753 = true } else if yyj4753 == 0 && yyv4753 == nil { - yyv4753 = []Node{} + yyv4753 = []PreferAvoidPodsEntry{} yyc4753 = true } } @@ -60712,14 +60685,244 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { } } +func (x codecSelfer1234) encResourceList(v ResourceList, e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeMapStart(len(v)) + for yyk4757, yyv4757 := range v { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + yyk4757.CodecEncodeSelf(e) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy4758 := &yyv4757 + yym4759 := z.EncBinary() + _ = yym4759 + if false { + } else if z.HasExtensions() && z.EncExt(yy4758) { + } else if !yym4759 && z.IsJSONHandle() { + z.EncJSONMarshal(yy4758) + } else { + z.EncFallback(yy4758) + } + } + z.EncSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x codecSelfer1234) decResourceList(v *ResourceList, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv4760 := *v + yyl4760 := r.ReadMapStart() + yybh4760 := z.DecBasicHandle() + if yyv4760 == nil { + yyrl4760, _ := z.DecInferLen(yyl4760, yybh4760.MaxInitLen, 72) + yyv4760 = make(map[ResourceName]pkg3_resource.Quantity, yyrl4760) + *v = yyv4760 + } + var yymk4760 ResourceName + var yymv4760 pkg3_resource.Quantity + var yymg4760 bool + if yybh4760.MapValueReset { + yymg4760 = true + } + if yyl4760 > 0 { + for yyj4760 := 0; yyj4760 < yyl4760; yyj4760++ { + z.DecSendContainerState(codecSelfer_containerMapKey1234) + if r.TryDecodeAsNil() { + yymk4760 = "" + } else { + yymk4760 = ResourceName(r.DecodeString()) + } + + if yymg4760 { + yymv4760 = yyv4760[yymk4760] + } else { + yymv4760 = pkg3_resource.Quantity{} + } + z.DecSendContainerState(codecSelfer_containerMapValue1234) + if r.TryDecodeAsNil() { + yymv4760 = pkg3_resource.Quantity{} + } else { + yyv4762 := &yymv4760 + yym4763 := z.DecBinary() + _ = yym4763 + if false { + } else if z.HasExtensions() && z.DecExt(yyv4762) { + } else if !yym4763 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv4762) + } else { + z.DecFallback(yyv4762, false) + } + } + + if yyv4760 != nil { + yyv4760[yymk4760] = yymv4760 + } + } + } else if yyl4760 < 0 { + for yyj4760 := 0; !r.CheckBreak(); yyj4760++ { + z.DecSendContainerState(codecSelfer_containerMapKey1234) + if r.TryDecodeAsNil() { + yymk4760 = "" + } else { + yymk4760 = ResourceName(r.DecodeString()) + } + + if yymg4760 { + yymv4760 = yyv4760[yymk4760] + } else { + yymv4760 = pkg3_resource.Quantity{} + } + z.DecSendContainerState(codecSelfer_containerMapValue1234) + if r.TryDecodeAsNil() { + yymv4760 = pkg3_resource.Quantity{} + } else { + yyv4765 := &yymv4760 + yym4766 := z.DecBinary() + _ = yym4766 + if false { + } else if z.HasExtensions() && z.DecExt(yyv4765) { + } else if !yym4766 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv4765) + } else { + z.DecFallback(yyv4765, false) + } + } + + if yyv4760 != nil { + yyv4760[yymk4760] = yymv4760 + } + } + } // else len==0: TODO: Should we clear map entries? + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x codecSelfer1234) encSliceNode(v []Node, e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv4767 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy4768 := &yyv4767 + yy4768.CodecEncodeSelf(e) + } + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv4769 := *v + yyh4769, yyl4769 := z.DecSliceHelperStart() + var yyc4769 bool + if yyl4769 == 0 { + if yyv4769 == nil { + yyv4769 = []Node{} + yyc4769 = true + } else if len(yyv4769) != 0 { + yyv4769 = yyv4769[:0] + yyc4769 = true + } + } else if yyl4769 > 0 { + var yyrr4769, yyrl4769 int + var yyrt4769 bool + if yyl4769 > cap(yyv4769) { + + yyrg4769 := len(yyv4769) > 0 + yyv24769 := yyv4769 + yyrl4769, yyrt4769 = z.DecInferLen(yyl4769, z.DecBasicHandle().MaxInitLen, 632) + if yyrt4769 { + if yyrl4769 <= cap(yyv4769) { + yyv4769 = yyv4769[:yyrl4769] + } else { + yyv4769 = make([]Node, yyrl4769) + } + } else { + yyv4769 = make([]Node, yyrl4769) + } + yyc4769 = true + yyrr4769 = len(yyv4769) + if yyrg4769 { + copy(yyv4769, yyv24769) + } + } else if yyl4769 != len(yyv4769) { + yyv4769 = yyv4769[:yyl4769] + yyc4769 = true + } + yyj4769 := 0 + for ; yyj4769 < yyrr4769; yyj4769++ { + yyh4769.ElemContainerState(yyj4769) + if r.TryDecodeAsNil() { + yyv4769[yyj4769] = Node{} + } else { + yyv4770 := &yyv4769[yyj4769] + yyv4770.CodecDecodeSelf(d) + } + + } + if yyrt4769 { + for ; yyj4769 < yyl4769; yyj4769++ { + yyv4769 = append(yyv4769, Node{}) + yyh4769.ElemContainerState(yyj4769) + if r.TryDecodeAsNil() { + yyv4769[yyj4769] = Node{} + } else { + yyv4771 := &yyv4769[yyj4769] + yyv4771.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj4769 := 0 + for ; !r.CheckBreak(); yyj4769++ { + + if yyj4769 >= len(yyv4769) { + yyv4769 = append(yyv4769, Node{}) // var yyz4769 Node + yyc4769 = true + } + yyh4769.ElemContainerState(yyj4769) + if yyj4769 < len(yyv4769) { + if r.TryDecodeAsNil() { + yyv4769[yyj4769] = Node{} + } else { + yyv4772 := &yyv4769[yyj4769] + yyv4772.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj4769 < len(yyv4769) { + yyv4769 = yyv4769[:yyj4769] + yyc4769 = true + } else if yyj4769 == 0 && yyv4769 == nil { + yyv4769 = []Node{} + yyc4769 = true + } + } + yyh4769.End() + if yyc4769 { + *v = yyv4769 + } +} + func (x codecSelfer1234) encSliceFinalizerName(v []FinalizerName, e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4757 := range v { + for _, yyv4773 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yyv4757.CodecEncodeSelf(e) + yyv4773.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -60729,75 +60932,75 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978. z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4758 := *v - yyh4758, yyl4758 := z.DecSliceHelperStart() - var yyc4758 bool - if yyl4758 == 0 { - if yyv4758 == nil { - yyv4758 = []FinalizerName{} - yyc4758 = true - } else if len(yyv4758) != 0 { - yyv4758 = yyv4758[:0] - yyc4758 = true + yyv4774 := *v + yyh4774, yyl4774 := z.DecSliceHelperStart() + var yyc4774 bool + if yyl4774 == 0 { + if yyv4774 == nil { + yyv4774 = []FinalizerName{} + yyc4774 = true + } else if len(yyv4774) != 0 { + yyv4774 = yyv4774[:0] + yyc4774 = true } - } else if yyl4758 > 0 { - var yyrr4758, yyrl4758 int - var yyrt4758 bool - if yyl4758 > cap(yyv4758) { + } else if yyl4774 > 0 { + var yyrr4774, yyrl4774 int + var yyrt4774 bool + if yyl4774 > cap(yyv4774) { - yyrl4758, yyrt4758 = z.DecInferLen(yyl4758, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4758 { - if yyrl4758 <= cap(yyv4758) { - yyv4758 = yyv4758[:yyrl4758] + yyrl4774, yyrt4774 = z.DecInferLen(yyl4774, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4774 { + if yyrl4774 <= cap(yyv4774) { + yyv4774 = yyv4774[:yyrl4774] } else { - yyv4758 = make([]FinalizerName, yyrl4758) + yyv4774 = make([]FinalizerName, yyrl4774) } } else { - yyv4758 = make([]FinalizerName, yyrl4758) + yyv4774 = make([]FinalizerName, yyrl4774) } - yyc4758 = true - yyrr4758 = len(yyv4758) - } else if yyl4758 != len(yyv4758) { - yyv4758 = yyv4758[:yyl4758] - yyc4758 = true + yyc4774 = true + yyrr4774 = len(yyv4774) + } else if yyl4774 != len(yyv4774) { + yyv4774 = yyv4774[:yyl4774] + yyc4774 = true } - yyj4758 := 0 - for ; yyj4758 < yyrr4758; yyj4758++ { - yyh4758.ElemContainerState(yyj4758) + yyj4774 := 0 + for ; yyj4774 < yyrr4774; yyj4774++ { + yyh4774.ElemContainerState(yyj4774) if r.TryDecodeAsNil() { - yyv4758[yyj4758] = "" + yyv4774[yyj4774] = "" } else { - yyv4758[yyj4758] = FinalizerName(r.DecodeString()) + yyv4774[yyj4774] = FinalizerName(r.DecodeString()) } } - if yyrt4758 { - for ; yyj4758 < yyl4758; yyj4758++ { - yyv4758 = append(yyv4758, "") - yyh4758.ElemContainerState(yyj4758) + if yyrt4774 { + for ; yyj4774 < yyl4774; yyj4774++ { + yyv4774 = append(yyv4774, "") + yyh4774.ElemContainerState(yyj4774) if r.TryDecodeAsNil() { - yyv4758[yyj4758] = "" + yyv4774[yyj4774] = "" } else { - yyv4758[yyj4758] = FinalizerName(r.DecodeString()) + yyv4774[yyj4774] = FinalizerName(r.DecodeString()) } } } } else { - yyj4758 := 0 - for ; !r.CheckBreak(); yyj4758++ { + yyj4774 := 0 + for ; !r.CheckBreak(); yyj4774++ { - if yyj4758 >= len(yyv4758) { - yyv4758 = append(yyv4758, "") // var yyz4758 FinalizerName - yyc4758 = true + if yyj4774 >= len(yyv4774) { + yyv4774 = append(yyv4774, "") // var yyz4774 FinalizerName + yyc4774 = true } - yyh4758.ElemContainerState(yyj4758) - if yyj4758 < len(yyv4758) { + yyh4774.ElemContainerState(yyj4774) + if yyj4774 < len(yyv4774) { if r.TryDecodeAsNil() { - yyv4758[yyj4758] = "" + yyv4774[yyj4774] = "" } else { - yyv4758[yyj4758] = FinalizerName(r.DecodeString()) + yyv4774[yyj4774] = FinalizerName(r.DecodeString()) } } else { @@ -60805,17 +61008,17 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978. } } - if yyj4758 < len(yyv4758) { - yyv4758 = yyv4758[:yyj4758] - yyc4758 = true - } else if yyj4758 == 0 && yyv4758 == nil { - yyv4758 = []FinalizerName{} - yyc4758 = true + if yyj4774 < len(yyv4774) { + yyv4774 = yyv4774[:yyj4774] + yyc4774 = true + } else if yyj4774 == 0 && yyv4774 == nil { + yyv4774 = []FinalizerName{} + yyc4774 = true } } - yyh4758.End() - if yyc4758 { - *v = yyv4758 + yyh4774.End() + if yyc4774 { + *v = yyv4774 } } @@ -60824,10 +61027,10 @@ func (x codecSelfer1234) encSliceNamespace(v []Namespace, e *codec1978.Encoder) z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4762 := range v { + for _, yyv4778 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4763 := &yyv4762 - yy4763.CodecEncodeSelf(e) + yy4779 := &yyv4778 + yy4779.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -60837,83 +61040,83 @@ func (x codecSelfer1234) decSliceNamespace(v *[]Namespace, d *codec1978.Decoder) z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4764 := *v - yyh4764, yyl4764 := z.DecSliceHelperStart() - var yyc4764 bool - if yyl4764 == 0 { - if yyv4764 == nil { - yyv4764 = []Namespace{} - yyc4764 = true - } else if len(yyv4764) != 0 { - yyv4764 = yyv4764[:0] - yyc4764 = true + yyv4780 := *v + yyh4780, yyl4780 := z.DecSliceHelperStart() + var yyc4780 bool + if yyl4780 == 0 { + if yyv4780 == nil { + yyv4780 = []Namespace{} + yyc4780 = true + } else if len(yyv4780) != 0 { + yyv4780 = yyv4780[:0] + yyc4780 = true } - } else if yyl4764 > 0 { - var yyrr4764, yyrl4764 int - var yyrt4764 bool - if yyl4764 > cap(yyv4764) { + } else if yyl4780 > 0 { + var yyrr4780, yyrl4780 int + var yyrt4780 bool + if yyl4780 > cap(yyv4780) { - yyrg4764 := len(yyv4764) > 0 - yyv24764 := yyv4764 - yyrl4764, yyrt4764 = z.DecInferLen(yyl4764, z.DecBasicHandle().MaxInitLen, 296) - if yyrt4764 { - if yyrl4764 <= cap(yyv4764) { - yyv4764 = yyv4764[:yyrl4764] + yyrg4780 := len(yyv4780) > 0 + yyv24780 := yyv4780 + yyrl4780, yyrt4780 = z.DecInferLen(yyl4780, z.DecBasicHandle().MaxInitLen, 296) + if yyrt4780 { + if yyrl4780 <= cap(yyv4780) { + yyv4780 = yyv4780[:yyrl4780] } else { - yyv4764 = make([]Namespace, yyrl4764) + yyv4780 = make([]Namespace, yyrl4780) } } else { - yyv4764 = make([]Namespace, yyrl4764) + yyv4780 = make([]Namespace, yyrl4780) } - yyc4764 = true - yyrr4764 = len(yyv4764) - if yyrg4764 { - copy(yyv4764, yyv24764) + yyc4780 = true + yyrr4780 = len(yyv4780) + if yyrg4780 { + copy(yyv4780, yyv24780) } - } else if yyl4764 != len(yyv4764) { - yyv4764 = yyv4764[:yyl4764] - yyc4764 = true + } else if yyl4780 != len(yyv4780) { + yyv4780 = yyv4780[:yyl4780] + yyc4780 = true } - yyj4764 := 0 - for ; yyj4764 < yyrr4764; yyj4764++ { - yyh4764.ElemContainerState(yyj4764) + yyj4780 := 0 + for ; yyj4780 < yyrr4780; yyj4780++ { + yyh4780.ElemContainerState(yyj4780) if r.TryDecodeAsNil() { - yyv4764[yyj4764] = Namespace{} + yyv4780[yyj4780] = Namespace{} } else { - yyv4765 := &yyv4764[yyj4764] - yyv4765.CodecDecodeSelf(d) + yyv4781 := &yyv4780[yyj4780] + yyv4781.CodecDecodeSelf(d) } } - if yyrt4764 { - for ; yyj4764 < yyl4764; yyj4764++ { - yyv4764 = append(yyv4764, Namespace{}) - yyh4764.ElemContainerState(yyj4764) + if yyrt4780 { + for ; yyj4780 < yyl4780; yyj4780++ { + yyv4780 = append(yyv4780, Namespace{}) + yyh4780.ElemContainerState(yyj4780) if r.TryDecodeAsNil() { - yyv4764[yyj4764] = Namespace{} + yyv4780[yyj4780] = Namespace{} } else { - yyv4766 := &yyv4764[yyj4764] - yyv4766.CodecDecodeSelf(d) + yyv4782 := &yyv4780[yyj4780] + yyv4782.CodecDecodeSelf(d) } } } } else { - yyj4764 := 0 - for ; !r.CheckBreak(); yyj4764++ { + yyj4780 := 0 + for ; !r.CheckBreak(); yyj4780++ { - if yyj4764 >= len(yyv4764) { - yyv4764 = append(yyv4764, Namespace{}) // var yyz4764 Namespace - yyc4764 = true + if yyj4780 >= len(yyv4780) { + yyv4780 = append(yyv4780, Namespace{}) // var yyz4780 Namespace + yyc4780 = true } - yyh4764.ElemContainerState(yyj4764) - if yyj4764 < len(yyv4764) { + yyh4780.ElemContainerState(yyj4780) + if yyj4780 < len(yyv4780) { if r.TryDecodeAsNil() { - yyv4764[yyj4764] = Namespace{} + yyv4780[yyj4780] = Namespace{} } else { - yyv4767 := &yyv4764[yyj4764] - yyv4767.CodecDecodeSelf(d) + yyv4783 := &yyv4780[yyj4780] + yyv4783.CodecDecodeSelf(d) } } else { @@ -60921,17 +61124,17 @@ func (x codecSelfer1234) decSliceNamespace(v *[]Namespace, d *codec1978.Decoder) } } - if yyj4764 < len(yyv4764) { - yyv4764 = yyv4764[:yyj4764] - yyc4764 = true - } else if yyj4764 == 0 && yyv4764 == nil { - yyv4764 = []Namespace{} - yyc4764 = true + if yyj4780 < len(yyv4780) { + yyv4780 = yyv4780[:yyj4780] + yyc4780 = true + } else if yyj4780 == 0 && yyv4780 == nil { + yyv4780 = []Namespace{} + yyc4780 = true } } - yyh4764.End() - if yyc4764 { - *v = yyv4764 + yyh4780.End() + if yyc4780 { + *v = yyv4780 } } @@ -60940,10 +61143,10 @@ func (x codecSelfer1234) encSliceEvent(v []Event, e *codec1978.Encoder) { z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4768 := range v { + for _, yyv4784 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4769 := &yyv4768 - yy4769.CodecEncodeSelf(e) + yy4785 := &yyv4784 + yy4785.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -60953,83 +61156,83 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) { z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4770 := *v - yyh4770, yyl4770 := z.DecSliceHelperStart() - var yyc4770 bool - if yyl4770 == 0 { - if yyv4770 == nil { - yyv4770 = []Event{} - yyc4770 = true - } else if len(yyv4770) != 0 { - yyv4770 = yyv4770[:0] - yyc4770 = true + yyv4786 := *v + yyh4786, yyl4786 := z.DecSliceHelperStart() + var yyc4786 bool + if yyl4786 == 0 { + if yyv4786 == nil { + yyv4786 = []Event{} + yyc4786 = true + } else if len(yyv4786) != 0 { + yyv4786 = yyv4786[:0] + yyc4786 = true } - } else if yyl4770 > 0 { - var yyrr4770, yyrl4770 int - var yyrt4770 bool - if yyl4770 > cap(yyv4770) { + } else if yyl4786 > 0 { + var yyrr4786, yyrl4786 int + var yyrt4786 bool + if yyl4786 > cap(yyv4786) { - yyrg4770 := len(yyv4770) > 0 - yyv24770 := yyv4770 - yyrl4770, yyrt4770 = z.DecInferLen(yyl4770, z.DecBasicHandle().MaxInitLen, 504) - if yyrt4770 { - if yyrl4770 <= cap(yyv4770) { - yyv4770 = yyv4770[:yyrl4770] + yyrg4786 := len(yyv4786) > 0 + yyv24786 := yyv4786 + yyrl4786, yyrt4786 = z.DecInferLen(yyl4786, z.DecBasicHandle().MaxInitLen, 504) + if yyrt4786 { + if yyrl4786 <= cap(yyv4786) { + yyv4786 = yyv4786[:yyrl4786] } else { - yyv4770 = make([]Event, yyrl4770) + yyv4786 = make([]Event, yyrl4786) } } else { - yyv4770 = make([]Event, yyrl4770) + yyv4786 = make([]Event, yyrl4786) } - yyc4770 = true - yyrr4770 = len(yyv4770) - if yyrg4770 { - copy(yyv4770, yyv24770) + yyc4786 = true + yyrr4786 = len(yyv4786) + if yyrg4786 { + copy(yyv4786, yyv24786) } - } else if yyl4770 != len(yyv4770) { - yyv4770 = yyv4770[:yyl4770] - yyc4770 = true + } else if yyl4786 != len(yyv4786) { + yyv4786 = yyv4786[:yyl4786] + yyc4786 = true } - yyj4770 := 0 - for ; yyj4770 < yyrr4770; yyj4770++ { - yyh4770.ElemContainerState(yyj4770) + yyj4786 := 0 + for ; yyj4786 < yyrr4786; yyj4786++ { + yyh4786.ElemContainerState(yyj4786) if r.TryDecodeAsNil() { - yyv4770[yyj4770] = Event{} + yyv4786[yyj4786] = Event{} } else { - yyv4771 := &yyv4770[yyj4770] - yyv4771.CodecDecodeSelf(d) + yyv4787 := &yyv4786[yyj4786] + yyv4787.CodecDecodeSelf(d) } } - if yyrt4770 { - for ; yyj4770 < yyl4770; yyj4770++ { - yyv4770 = append(yyv4770, Event{}) - yyh4770.ElemContainerState(yyj4770) + if yyrt4786 { + for ; yyj4786 < yyl4786; yyj4786++ { + yyv4786 = append(yyv4786, Event{}) + yyh4786.ElemContainerState(yyj4786) if r.TryDecodeAsNil() { - yyv4770[yyj4770] = Event{} + yyv4786[yyj4786] = Event{} } else { - yyv4772 := &yyv4770[yyj4770] - yyv4772.CodecDecodeSelf(d) + yyv4788 := &yyv4786[yyj4786] + yyv4788.CodecDecodeSelf(d) } } } } else { - yyj4770 := 0 - for ; !r.CheckBreak(); yyj4770++ { + yyj4786 := 0 + for ; !r.CheckBreak(); yyj4786++ { - if yyj4770 >= len(yyv4770) { - yyv4770 = append(yyv4770, Event{}) // var yyz4770 Event - yyc4770 = true + if yyj4786 >= len(yyv4786) { + yyv4786 = append(yyv4786, Event{}) // var yyz4786 Event + yyc4786 = true } - yyh4770.ElemContainerState(yyj4770) - if yyj4770 < len(yyv4770) { + yyh4786.ElemContainerState(yyj4786) + if yyj4786 < len(yyv4786) { if r.TryDecodeAsNil() { - yyv4770[yyj4770] = Event{} + yyv4786[yyj4786] = Event{} } else { - yyv4773 := &yyv4770[yyj4770] - yyv4773.CodecDecodeSelf(d) + yyv4789 := &yyv4786[yyj4786] + yyv4789.CodecDecodeSelf(d) } } else { @@ -61037,17 +61240,17 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) { } } - if yyj4770 < len(yyv4770) { - yyv4770 = yyv4770[:yyj4770] - yyc4770 = true - } else if yyj4770 == 0 && yyv4770 == nil { - yyv4770 = []Event{} - yyc4770 = true + if yyj4786 < len(yyv4786) { + yyv4786 = yyv4786[:yyj4786] + yyc4786 = true + } else if yyj4786 == 0 && yyv4786 == nil { + yyv4786 = []Event{} + yyc4786 = true } } - yyh4770.End() - if yyc4770 { - *v = yyv4770 + yyh4786.End() + if yyc4786 { + *v = yyv4786 } } @@ -61056,17 +61259,17 @@ func (x codecSelfer1234) encSliceruntime_Object(v []pkg7_runtime.Object, e *code z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4774 := range v { + for _, yyv4790 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyv4774 == nil { + if yyv4790 == nil { r.EncodeNil() } else { - yym4775 := z.EncBinary() - _ = yym4775 + yym4791 := z.EncBinary() + _ = yym4791 if false { - } else if z.HasExtensions() && z.EncExt(yyv4774) { + } else if z.HasExtensions() && z.EncExt(yyv4790) { } else { - z.EncFallback(yyv4774) + z.EncFallback(yyv4790) } } } @@ -61078,74 +61281,74 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg7_runtime.Object, d *cod z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4776 := *v - yyh4776, yyl4776 := z.DecSliceHelperStart() - var yyc4776 bool - if yyl4776 == 0 { - if yyv4776 == nil { - yyv4776 = []pkg7_runtime.Object{} - yyc4776 = true - } else if len(yyv4776) != 0 { - yyv4776 = yyv4776[:0] - yyc4776 = true + yyv4792 := *v + yyh4792, yyl4792 := z.DecSliceHelperStart() + var yyc4792 bool + if yyl4792 == 0 { + if yyv4792 == nil { + yyv4792 = []pkg7_runtime.Object{} + yyc4792 = true + } else if len(yyv4792) != 0 { + yyv4792 = yyv4792[:0] + yyc4792 = true } - } else if yyl4776 > 0 { - var yyrr4776, yyrl4776 int - var yyrt4776 bool - if yyl4776 > cap(yyv4776) { + } else if yyl4792 > 0 { + var yyrr4792, yyrl4792 int + var yyrt4792 bool + if yyl4792 > cap(yyv4792) { - yyrg4776 := len(yyv4776) > 0 - yyv24776 := yyv4776 - yyrl4776, yyrt4776 = z.DecInferLen(yyl4776, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4776 { - if yyrl4776 <= cap(yyv4776) { - yyv4776 = yyv4776[:yyrl4776] + yyrg4792 := len(yyv4792) > 0 + yyv24792 := yyv4792 + yyrl4792, yyrt4792 = z.DecInferLen(yyl4792, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4792 { + if yyrl4792 <= cap(yyv4792) { + yyv4792 = yyv4792[:yyrl4792] } else { - yyv4776 = make([]pkg7_runtime.Object, yyrl4776) + yyv4792 = make([]pkg7_runtime.Object, yyrl4792) } } else { - yyv4776 = make([]pkg7_runtime.Object, yyrl4776) + yyv4792 = make([]pkg7_runtime.Object, yyrl4792) } - yyc4776 = true - yyrr4776 = len(yyv4776) - if yyrg4776 { - copy(yyv4776, yyv24776) + yyc4792 = true + yyrr4792 = len(yyv4792) + if yyrg4792 { + copy(yyv4792, yyv24792) } - } else if yyl4776 != len(yyv4776) { - yyv4776 = yyv4776[:yyl4776] - yyc4776 = true + } else if yyl4792 != len(yyv4792) { + yyv4792 = yyv4792[:yyl4792] + yyc4792 = true } - yyj4776 := 0 - for ; yyj4776 < yyrr4776; yyj4776++ { - yyh4776.ElemContainerState(yyj4776) + yyj4792 := 0 + for ; yyj4792 < yyrr4792; yyj4792++ { + yyh4792.ElemContainerState(yyj4792) if r.TryDecodeAsNil() { - yyv4776[yyj4776] = nil + yyv4792[yyj4792] = nil } else { - yyv4777 := &yyv4776[yyj4776] - yym4778 := z.DecBinary() - _ = yym4778 + yyv4793 := &yyv4792[yyj4792] + yym4794 := z.DecBinary() + _ = yym4794 if false { - } else if z.HasExtensions() && z.DecExt(yyv4777) { + } else if z.HasExtensions() && z.DecExt(yyv4793) { } else { - z.DecFallback(yyv4777, true) + z.DecFallback(yyv4793, true) } } } - if yyrt4776 { - for ; yyj4776 < yyl4776; yyj4776++ { - yyv4776 = append(yyv4776, nil) - yyh4776.ElemContainerState(yyj4776) + if yyrt4792 { + for ; yyj4792 < yyl4792; yyj4792++ { + yyv4792 = append(yyv4792, nil) + yyh4792.ElemContainerState(yyj4792) if r.TryDecodeAsNil() { - yyv4776[yyj4776] = nil + yyv4792[yyj4792] = nil } else { - yyv4779 := &yyv4776[yyj4776] - yym4780 := z.DecBinary() - _ = yym4780 + yyv4795 := &yyv4792[yyj4792] + yym4796 := z.DecBinary() + _ = yym4796 if false { - } else if z.HasExtensions() && z.DecExt(yyv4779) { + } else if z.HasExtensions() && z.DecExt(yyv4795) { } else { - z.DecFallback(yyv4779, true) + z.DecFallback(yyv4795, true) } } @@ -61153,25 +61356,25 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg7_runtime.Object, d *cod } } else { - yyj4776 := 0 - for ; !r.CheckBreak(); yyj4776++ { + yyj4792 := 0 + for ; !r.CheckBreak(); yyj4792++ { - if yyj4776 >= len(yyv4776) { - yyv4776 = append(yyv4776, nil) // var yyz4776 pkg7_runtime.Object - yyc4776 = true + if yyj4792 >= len(yyv4792) { + yyv4792 = append(yyv4792, nil) // var yyz4792 pkg7_runtime.Object + yyc4792 = true } - yyh4776.ElemContainerState(yyj4776) - if yyj4776 < len(yyv4776) { + yyh4792.ElemContainerState(yyj4792) + if yyj4792 < len(yyv4792) { if r.TryDecodeAsNil() { - yyv4776[yyj4776] = nil + yyv4792[yyj4792] = nil } else { - yyv4781 := &yyv4776[yyj4776] - yym4782 := z.DecBinary() - _ = yym4782 + yyv4797 := &yyv4792[yyj4792] + yym4798 := z.DecBinary() + _ = yym4798 if false { - } else if z.HasExtensions() && z.DecExt(yyv4781) { + } else if z.HasExtensions() && z.DecExt(yyv4797) { } else { - z.DecFallback(yyv4781, true) + z.DecFallback(yyv4797, true) } } @@ -61180,17 +61383,17 @@ func (x codecSelfer1234) decSliceruntime_Object(v *[]pkg7_runtime.Object, d *cod } } - if yyj4776 < len(yyv4776) { - yyv4776 = yyv4776[:yyj4776] - yyc4776 = true - } else if yyj4776 == 0 && yyv4776 == nil { - yyv4776 = []pkg7_runtime.Object{} - yyc4776 = true + if yyj4792 < len(yyv4792) { + yyv4792 = yyv4792[:yyj4792] + yyc4792 = true + } else if yyj4792 == 0 && yyv4792 == nil { + yyv4792 = []pkg7_runtime.Object{} + yyc4792 = true } } - yyh4776.End() - if yyc4776 { - *v = yyv4776 + yyh4792.End() + if yyc4792 { + *v = yyv4792 } } @@ -61199,10 +61402,10 @@ func (x codecSelfer1234) encSliceLimitRangeItem(v []LimitRangeItem, e *codec1978 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4783 := range v { + for _, yyv4799 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4784 := &yyv4783 - yy4784.CodecEncodeSelf(e) + yy4800 := &yyv4799 + yy4800.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -61212,83 +61415,83 @@ func (x codecSelfer1234) decSliceLimitRangeItem(v *[]LimitRangeItem, d *codec197 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4785 := *v - yyh4785, yyl4785 := z.DecSliceHelperStart() - var yyc4785 bool - if yyl4785 == 0 { - if yyv4785 == nil { - yyv4785 = []LimitRangeItem{} - yyc4785 = true - } else if len(yyv4785) != 0 { - yyv4785 = yyv4785[:0] - yyc4785 = true + yyv4801 := *v + yyh4801, yyl4801 := z.DecSliceHelperStart() + var yyc4801 bool + if yyl4801 == 0 { + if yyv4801 == nil { + yyv4801 = []LimitRangeItem{} + yyc4801 = true + } else if len(yyv4801) != 0 { + yyv4801 = yyv4801[:0] + yyc4801 = true } - } else if yyl4785 > 0 { - var yyrr4785, yyrl4785 int - var yyrt4785 bool - if yyl4785 > cap(yyv4785) { + } else if yyl4801 > 0 { + var yyrr4801, yyrl4801 int + var yyrt4801 bool + if yyl4801 > cap(yyv4801) { - yyrg4785 := len(yyv4785) > 0 - yyv24785 := yyv4785 - yyrl4785, yyrt4785 = z.DecInferLen(yyl4785, z.DecBasicHandle().MaxInitLen, 56) - if yyrt4785 { - if yyrl4785 <= cap(yyv4785) { - yyv4785 = yyv4785[:yyrl4785] + yyrg4801 := len(yyv4801) > 0 + yyv24801 := yyv4801 + yyrl4801, yyrt4801 = z.DecInferLen(yyl4801, z.DecBasicHandle().MaxInitLen, 56) + if yyrt4801 { + if yyrl4801 <= cap(yyv4801) { + yyv4801 = yyv4801[:yyrl4801] } else { - yyv4785 = make([]LimitRangeItem, yyrl4785) + yyv4801 = make([]LimitRangeItem, yyrl4801) } } else { - yyv4785 = make([]LimitRangeItem, yyrl4785) + yyv4801 = make([]LimitRangeItem, yyrl4801) } - yyc4785 = true - yyrr4785 = len(yyv4785) - if yyrg4785 { - copy(yyv4785, yyv24785) + yyc4801 = true + yyrr4801 = len(yyv4801) + if yyrg4801 { + copy(yyv4801, yyv24801) } - } else if yyl4785 != len(yyv4785) { - yyv4785 = yyv4785[:yyl4785] - yyc4785 = true + } else if yyl4801 != len(yyv4801) { + yyv4801 = yyv4801[:yyl4801] + yyc4801 = true } - yyj4785 := 0 - for ; yyj4785 < yyrr4785; yyj4785++ { - yyh4785.ElemContainerState(yyj4785) + yyj4801 := 0 + for ; yyj4801 < yyrr4801; yyj4801++ { + yyh4801.ElemContainerState(yyj4801) if r.TryDecodeAsNil() { - yyv4785[yyj4785] = LimitRangeItem{} + yyv4801[yyj4801] = LimitRangeItem{} } else { - yyv4786 := &yyv4785[yyj4785] - yyv4786.CodecDecodeSelf(d) + yyv4802 := &yyv4801[yyj4801] + yyv4802.CodecDecodeSelf(d) } } - if yyrt4785 { - for ; yyj4785 < yyl4785; yyj4785++ { - yyv4785 = append(yyv4785, LimitRangeItem{}) - yyh4785.ElemContainerState(yyj4785) + if yyrt4801 { + for ; yyj4801 < yyl4801; yyj4801++ { + yyv4801 = append(yyv4801, LimitRangeItem{}) + yyh4801.ElemContainerState(yyj4801) if r.TryDecodeAsNil() { - yyv4785[yyj4785] = LimitRangeItem{} + yyv4801[yyj4801] = LimitRangeItem{} } else { - yyv4787 := &yyv4785[yyj4785] - yyv4787.CodecDecodeSelf(d) + yyv4803 := &yyv4801[yyj4801] + yyv4803.CodecDecodeSelf(d) } } } } else { - yyj4785 := 0 - for ; !r.CheckBreak(); yyj4785++ { + yyj4801 := 0 + for ; !r.CheckBreak(); yyj4801++ { - if yyj4785 >= len(yyv4785) { - yyv4785 = append(yyv4785, LimitRangeItem{}) // var yyz4785 LimitRangeItem - yyc4785 = true + if yyj4801 >= len(yyv4801) { + yyv4801 = append(yyv4801, LimitRangeItem{}) // var yyz4801 LimitRangeItem + yyc4801 = true } - yyh4785.ElemContainerState(yyj4785) - if yyj4785 < len(yyv4785) { + yyh4801.ElemContainerState(yyj4801) + if yyj4801 < len(yyv4801) { if r.TryDecodeAsNil() { - yyv4785[yyj4785] = LimitRangeItem{} + yyv4801[yyj4801] = LimitRangeItem{} } else { - yyv4788 := &yyv4785[yyj4785] - yyv4788.CodecDecodeSelf(d) + yyv4804 := &yyv4801[yyj4801] + yyv4804.CodecDecodeSelf(d) } } else { @@ -61296,17 +61499,17 @@ func (x codecSelfer1234) decSliceLimitRangeItem(v *[]LimitRangeItem, d *codec197 } } - if yyj4785 < len(yyv4785) { - yyv4785 = yyv4785[:yyj4785] - yyc4785 = true - } else if yyj4785 == 0 && yyv4785 == nil { - yyv4785 = []LimitRangeItem{} - yyc4785 = true + if yyj4801 < len(yyv4801) { + yyv4801 = yyv4801[:yyj4801] + yyc4801 = true + } else if yyj4801 == 0 && yyv4801 == nil { + yyv4801 = []LimitRangeItem{} + yyc4801 = true } } - yyh4785.End() - if yyc4785 { - *v = yyv4785 + yyh4801.End() + if yyc4801 { + *v = yyv4801 } } @@ -61315,10 +61518,10 @@ func (x codecSelfer1234) encSliceLimitRange(v []LimitRange, e *codec1978.Encoder z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4789 := range v { + for _, yyv4805 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4790 := &yyv4789 - yy4790.CodecEncodeSelf(e) + yy4806 := &yyv4805 + yy4806.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -61328,83 +61531,83 @@ func (x codecSelfer1234) decSliceLimitRange(v *[]LimitRange, d *codec1978.Decode z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4791 := *v - yyh4791, yyl4791 := z.DecSliceHelperStart() - var yyc4791 bool - if yyl4791 == 0 { - if yyv4791 == nil { - yyv4791 = []LimitRange{} - yyc4791 = true - } else if len(yyv4791) != 0 { - yyv4791 = yyv4791[:0] - yyc4791 = true + yyv4807 := *v + yyh4807, yyl4807 := z.DecSliceHelperStart() + var yyc4807 bool + if yyl4807 == 0 { + if yyv4807 == nil { + yyv4807 = []LimitRange{} + yyc4807 = true + } else if len(yyv4807) != 0 { + yyv4807 = yyv4807[:0] + yyc4807 = true } - } else if yyl4791 > 0 { - var yyrr4791, yyrl4791 int - var yyrt4791 bool - if yyl4791 > cap(yyv4791) { + } else if yyl4807 > 0 { + var yyrr4807, yyrl4807 int + var yyrt4807 bool + if yyl4807 > cap(yyv4807) { - yyrg4791 := len(yyv4791) > 0 - yyv24791 := yyv4791 - yyrl4791, yyrt4791 = z.DecInferLen(yyl4791, z.DecBasicHandle().MaxInitLen, 280) - if yyrt4791 { - if yyrl4791 <= cap(yyv4791) { - yyv4791 = yyv4791[:yyrl4791] + yyrg4807 := len(yyv4807) > 0 + yyv24807 := yyv4807 + yyrl4807, yyrt4807 = z.DecInferLen(yyl4807, z.DecBasicHandle().MaxInitLen, 280) + if yyrt4807 { + if yyrl4807 <= cap(yyv4807) { + yyv4807 = yyv4807[:yyrl4807] } else { - yyv4791 = make([]LimitRange, yyrl4791) + yyv4807 = make([]LimitRange, yyrl4807) } } else { - yyv4791 = make([]LimitRange, yyrl4791) + yyv4807 = make([]LimitRange, yyrl4807) } - yyc4791 = true - yyrr4791 = len(yyv4791) - if yyrg4791 { - copy(yyv4791, yyv24791) + yyc4807 = true + yyrr4807 = len(yyv4807) + if yyrg4807 { + copy(yyv4807, yyv24807) } - } else if yyl4791 != len(yyv4791) { - yyv4791 = yyv4791[:yyl4791] - yyc4791 = true + } else if yyl4807 != len(yyv4807) { + yyv4807 = yyv4807[:yyl4807] + yyc4807 = true } - yyj4791 := 0 - for ; yyj4791 < yyrr4791; yyj4791++ { - yyh4791.ElemContainerState(yyj4791) + yyj4807 := 0 + for ; yyj4807 < yyrr4807; yyj4807++ { + yyh4807.ElemContainerState(yyj4807) if r.TryDecodeAsNil() { - yyv4791[yyj4791] = LimitRange{} + yyv4807[yyj4807] = LimitRange{} } else { - yyv4792 := &yyv4791[yyj4791] - yyv4792.CodecDecodeSelf(d) + yyv4808 := &yyv4807[yyj4807] + yyv4808.CodecDecodeSelf(d) } } - if yyrt4791 { - for ; yyj4791 < yyl4791; yyj4791++ { - yyv4791 = append(yyv4791, LimitRange{}) - yyh4791.ElemContainerState(yyj4791) + if yyrt4807 { + for ; yyj4807 < yyl4807; yyj4807++ { + yyv4807 = append(yyv4807, LimitRange{}) + yyh4807.ElemContainerState(yyj4807) if r.TryDecodeAsNil() { - yyv4791[yyj4791] = LimitRange{} + yyv4807[yyj4807] = LimitRange{} } else { - yyv4793 := &yyv4791[yyj4791] - yyv4793.CodecDecodeSelf(d) + yyv4809 := &yyv4807[yyj4807] + yyv4809.CodecDecodeSelf(d) } } } } else { - yyj4791 := 0 - for ; !r.CheckBreak(); yyj4791++ { + yyj4807 := 0 + for ; !r.CheckBreak(); yyj4807++ { - if yyj4791 >= len(yyv4791) { - yyv4791 = append(yyv4791, LimitRange{}) // var yyz4791 LimitRange - yyc4791 = true + if yyj4807 >= len(yyv4807) { + yyv4807 = append(yyv4807, LimitRange{}) // var yyz4807 LimitRange + yyc4807 = true } - yyh4791.ElemContainerState(yyj4791) - if yyj4791 < len(yyv4791) { + yyh4807.ElemContainerState(yyj4807) + if yyj4807 < len(yyv4807) { if r.TryDecodeAsNil() { - yyv4791[yyj4791] = LimitRange{} + yyv4807[yyj4807] = LimitRange{} } else { - yyv4794 := &yyv4791[yyj4791] - yyv4794.CodecDecodeSelf(d) + yyv4810 := &yyv4807[yyj4807] + yyv4810.CodecDecodeSelf(d) } } else { @@ -61412,17 +61615,17 @@ func (x codecSelfer1234) decSliceLimitRange(v *[]LimitRange, d *codec1978.Decode } } - if yyj4791 < len(yyv4791) { - yyv4791 = yyv4791[:yyj4791] - yyc4791 = true - } else if yyj4791 == 0 && yyv4791 == nil { - yyv4791 = []LimitRange{} - yyc4791 = true + if yyj4807 < len(yyv4807) { + yyv4807 = yyv4807[:yyj4807] + yyc4807 = true + } else if yyj4807 == 0 && yyv4807 == nil { + yyv4807 = []LimitRange{} + yyc4807 = true } } - yyh4791.End() - if yyc4791 { - *v = yyv4791 + yyh4807.End() + if yyc4807 { + *v = yyv4807 } } @@ -61431,9 +61634,9 @@ func (x codecSelfer1234) encSliceResourceQuotaScope(v []ResourceQuotaScope, e *c z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4795 := range v { + for _, yyv4811 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yyv4795.CodecEncodeSelf(e) + yyv4811.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -61443,75 +61646,75 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d * z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4796 := *v - yyh4796, yyl4796 := z.DecSliceHelperStart() - var yyc4796 bool - if yyl4796 == 0 { - if yyv4796 == nil { - yyv4796 = []ResourceQuotaScope{} - yyc4796 = true - } else if len(yyv4796) != 0 { - yyv4796 = yyv4796[:0] - yyc4796 = true + yyv4812 := *v + yyh4812, yyl4812 := z.DecSliceHelperStart() + var yyc4812 bool + if yyl4812 == 0 { + if yyv4812 == nil { + yyv4812 = []ResourceQuotaScope{} + yyc4812 = true + } else if len(yyv4812) != 0 { + yyv4812 = yyv4812[:0] + yyc4812 = true } - } else if yyl4796 > 0 { - var yyrr4796, yyrl4796 int - var yyrt4796 bool - if yyl4796 > cap(yyv4796) { + } else if yyl4812 > 0 { + var yyrr4812, yyrl4812 int + var yyrt4812 bool + if yyl4812 > cap(yyv4812) { - yyrl4796, yyrt4796 = z.DecInferLen(yyl4796, z.DecBasicHandle().MaxInitLen, 16) - if yyrt4796 { - if yyrl4796 <= cap(yyv4796) { - yyv4796 = yyv4796[:yyrl4796] + yyrl4812, yyrt4812 = z.DecInferLen(yyl4812, z.DecBasicHandle().MaxInitLen, 16) + if yyrt4812 { + if yyrl4812 <= cap(yyv4812) { + yyv4812 = yyv4812[:yyrl4812] } else { - yyv4796 = make([]ResourceQuotaScope, yyrl4796) + yyv4812 = make([]ResourceQuotaScope, yyrl4812) } } else { - yyv4796 = make([]ResourceQuotaScope, yyrl4796) + yyv4812 = make([]ResourceQuotaScope, yyrl4812) } - yyc4796 = true - yyrr4796 = len(yyv4796) - } else if yyl4796 != len(yyv4796) { - yyv4796 = yyv4796[:yyl4796] - yyc4796 = true + yyc4812 = true + yyrr4812 = len(yyv4812) + } else if yyl4812 != len(yyv4812) { + yyv4812 = yyv4812[:yyl4812] + yyc4812 = true } - yyj4796 := 0 - for ; yyj4796 < yyrr4796; yyj4796++ { - yyh4796.ElemContainerState(yyj4796) + yyj4812 := 0 + for ; yyj4812 < yyrr4812; yyj4812++ { + yyh4812.ElemContainerState(yyj4812) if r.TryDecodeAsNil() { - yyv4796[yyj4796] = "" + yyv4812[yyj4812] = "" } else { - yyv4796[yyj4796] = ResourceQuotaScope(r.DecodeString()) + yyv4812[yyj4812] = ResourceQuotaScope(r.DecodeString()) } } - if yyrt4796 { - for ; yyj4796 < yyl4796; yyj4796++ { - yyv4796 = append(yyv4796, "") - yyh4796.ElemContainerState(yyj4796) + if yyrt4812 { + for ; yyj4812 < yyl4812; yyj4812++ { + yyv4812 = append(yyv4812, "") + yyh4812.ElemContainerState(yyj4812) if r.TryDecodeAsNil() { - yyv4796[yyj4796] = "" + yyv4812[yyj4812] = "" } else { - yyv4796[yyj4796] = ResourceQuotaScope(r.DecodeString()) + yyv4812[yyj4812] = ResourceQuotaScope(r.DecodeString()) } } } } else { - yyj4796 := 0 - for ; !r.CheckBreak(); yyj4796++ { + yyj4812 := 0 + for ; !r.CheckBreak(); yyj4812++ { - if yyj4796 >= len(yyv4796) { - yyv4796 = append(yyv4796, "") // var yyz4796 ResourceQuotaScope - yyc4796 = true + if yyj4812 >= len(yyv4812) { + yyv4812 = append(yyv4812, "") // var yyz4812 ResourceQuotaScope + yyc4812 = true } - yyh4796.ElemContainerState(yyj4796) - if yyj4796 < len(yyv4796) { + yyh4812.ElemContainerState(yyj4812) + if yyj4812 < len(yyv4812) { if r.TryDecodeAsNil() { - yyv4796[yyj4796] = "" + yyv4812[yyj4812] = "" } else { - yyv4796[yyj4796] = ResourceQuotaScope(r.DecodeString()) + yyv4812[yyj4812] = ResourceQuotaScope(r.DecodeString()) } } else { @@ -61519,250 +61722,21 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d * } } - if yyj4796 < len(yyv4796) { - yyv4796 = yyv4796[:yyj4796] - yyc4796 = true - } else if yyj4796 == 0 && yyv4796 == nil { - yyv4796 = []ResourceQuotaScope{} - yyc4796 = true + if yyj4812 < len(yyv4812) { + yyv4812 = yyv4812[:yyj4812] + yyc4812 = true + } else if yyj4812 == 0 && yyv4812 == nil { + yyv4812 = []ResourceQuotaScope{} + yyc4812 = true } } - yyh4796.End() - if yyc4796 { - *v = yyv4796 + yyh4812.End() + if yyc4812 { + *v = yyv4812 } } func (x codecSelfer1234) encSliceResourceQuota(v []ResourceQuota, e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - r.EncodeArrayStart(len(v)) - for _, yyv4800 := range v { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4801 := &yyv4800 - yy4801.CodecEncodeSelf(e) - } - z.EncSendContainerState(codecSelfer_containerArrayEnd1234) -} - -func (x codecSelfer1234) decSliceResourceQuota(v *[]ResourceQuota, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - - yyv4802 := *v - yyh4802, yyl4802 := z.DecSliceHelperStart() - var yyc4802 bool - if yyl4802 == 0 { - if yyv4802 == nil { - yyv4802 = []ResourceQuota{} - yyc4802 = true - } else if len(yyv4802) != 0 { - yyv4802 = yyv4802[:0] - yyc4802 = true - } - } else if yyl4802 > 0 { - var yyrr4802, yyrl4802 int - var yyrt4802 bool - if yyl4802 > cap(yyv4802) { - - yyrg4802 := len(yyv4802) > 0 - yyv24802 := yyv4802 - yyrl4802, yyrt4802 = z.DecInferLen(yyl4802, z.DecBasicHandle().MaxInitLen, 304) - if yyrt4802 { - if yyrl4802 <= cap(yyv4802) { - yyv4802 = yyv4802[:yyrl4802] - } else { - yyv4802 = make([]ResourceQuota, yyrl4802) - } - } else { - yyv4802 = make([]ResourceQuota, yyrl4802) - } - yyc4802 = true - yyrr4802 = len(yyv4802) - if yyrg4802 { - copy(yyv4802, yyv24802) - } - } else if yyl4802 != len(yyv4802) { - yyv4802 = yyv4802[:yyl4802] - yyc4802 = true - } - yyj4802 := 0 - for ; yyj4802 < yyrr4802; yyj4802++ { - yyh4802.ElemContainerState(yyj4802) - if r.TryDecodeAsNil() { - yyv4802[yyj4802] = ResourceQuota{} - } else { - yyv4803 := &yyv4802[yyj4802] - yyv4803.CodecDecodeSelf(d) - } - - } - if yyrt4802 { - for ; yyj4802 < yyl4802; yyj4802++ { - yyv4802 = append(yyv4802, ResourceQuota{}) - yyh4802.ElemContainerState(yyj4802) - if r.TryDecodeAsNil() { - yyv4802[yyj4802] = ResourceQuota{} - } else { - yyv4804 := &yyv4802[yyj4802] - yyv4804.CodecDecodeSelf(d) - } - - } - } - - } else { - yyj4802 := 0 - for ; !r.CheckBreak(); yyj4802++ { - - if yyj4802 >= len(yyv4802) { - yyv4802 = append(yyv4802, ResourceQuota{}) // var yyz4802 ResourceQuota - yyc4802 = true - } - yyh4802.ElemContainerState(yyj4802) - if yyj4802 < len(yyv4802) { - if r.TryDecodeAsNil() { - yyv4802[yyj4802] = ResourceQuota{} - } else { - yyv4805 := &yyv4802[yyj4802] - yyv4805.CodecDecodeSelf(d) - } - - } else { - z.DecSwallow() - } - - } - if yyj4802 < len(yyv4802) { - yyv4802 = yyv4802[:yyj4802] - yyc4802 = true - } else if yyj4802 == 0 && yyv4802 == nil { - yyv4802 = []ResourceQuota{} - yyc4802 = true - } - } - yyh4802.End() - if yyc4802 { - *v = yyv4802 - } -} - -func (x codecSelfer1234) encMapstringSliceuint8(v map[string][]uint8, e *codec1978.Encoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperEncoder(e) - _, _, _ = h, z, r - r.EncodeMapStart(len(v)) - for yyk4806, yyv4806 := range v { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - yym4807 := z.EncBinary() - _ = yym4807 - if false { - } else { - r.EncodeString(codecSelferC_UTF81234, string(yyk4806)) - } - z.EncSendContainerState(codecSelfer_containerMapValue1234) - if yyv4806 == nil { - r.EncodeNil() - } else { - yym4808 := z.EncBinary() - _ = yym4808 - if false { - } else { - r.EncodeStringBytes(codecSelferC_RAW1234, []byte(yyv4806)) - } - } - } - z.EncSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x codecSelfer1234) decMapstringSliceuint8(v *map[string][]uint8, d *codec1978.Decoder) { - var h codecSelfer1234 - z, r := codec1978.GenHelperDecoder(d) - _, _, _ = h, z, r - - yyv4809 := *v - yyl4809 := r.ReadMapStart() - yybh4809 := z.DecBasicHandle() - if yyv4809 == nil { - yyrl4809, _ := z.DecInferLen(yyl4809, yybh4809.MaxInitLen, 40) - yyv4809 = make(map[string][]uint8, yyrl4809) - *v = yyv4809 - } - var yymk4809 string - var yymv4809 []uint8 - var yymg4809 bool - if yybh4809.MapValueReset { - yymg4809 = true - } - if yyl4809 > 0 { - for yyj4809 := 0; yyj4809 < yyl4809; yyj4809++ { - z.DecSendContainerState(codecSelfer_containerMapKey1234) - if r.TryDecodeAsNil() { - yymk4809 = "" - } else { - yymk4809 = string(r.DecodeString()) - } - - if yymg4809 { - yymv4809 = yyv4809[yymk4809] - } else { - yymv4809 = nil - } - z.DecSendContainerState(codecSelfer_containerMapValue1234) - if r.TryDecodeAsNil() { - yymv4809 = nil - } else { - yyv4811 := &yymv4809 - yym4812 := z.DecBinary() - _ = yym4812 - if false { - } else { - *yyv4811 = r.DecodeBytes(*(*[]byte)(yyv4811), false, false) - } - } - - if yyv4809 != nil { - yyv4809[yymk4809] = yymv4809 - } - } - } else if yyl4809 < 0 { - for yyj4809 := 0; !r.CheckBreak(); yyj4809++ { - z.DecSendContainerState(codecSelfer_containerMapKey1234) - if r.TryDecodeAsNil() { - yymk4809 = "" - } else { - yymk4809 = string(r.DecodeString()) - } - - if yymg4809 { - yymv4809 = yyv4809[yymk4809] - } else { - yymv4809 = nil - } - z.DecSendContainerState(codecSelfer_containerMapValue1234) - if r.TryDecodeAsNil() { - yymv4809 = nil - } else { - yyv4814 := &yymv4809 - yym4815 := z.DecBinary() - _ = yym4815 - if false { - } else { - *yyv4814 = r.DecodeBytes(*(*[]byte)(yyv4814), false, false) - } - } - - if yyv4809 != nil { - yyv4809[yymk4809] = yymv4809 - } - } - } // else len==0: TODO: Should we clear map entries? - z.DecSendContainerState(codecSelfer_containerMapEnd1234) -} - -func (x codecSelfer1234) encSliceSecret(v []Secret, e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r @@ -61775,7 +61749,7 @@ func (x codecSelfer1234) encSliceSecret(v []Secret, e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } -func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { +func (x codecSelfer1234) decSliceResourceQuota(v *[]ResourceQuota, d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r @@ -61785,7 +61759,7 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { var yyc4818 bool if yyl4818 == 0 { if yyv4818 == nil { - yyv4818 = []Secret{} + yyv4818 = []ResourceQuota{} yyc4818 = true } else if len(yyv4818) != 0 { yyv4818 = yyv4818[:0] @@ -61798,15 +61772,15 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { yyrg4818 := len(yyv4818) > 0 yyv24818 := yyv4818 - yyrl4818, yyrt4818 = z.DecInferLen(yyl4818, z.DecBasicHandle().MaxInitLen, 280) + yyrl4818, yyrt4818 = z.DecInferLen(yyl4818, z.DecBasicHandle().MaxInitLen, 304) if yyrt4818 { if yyrl4818 <= cap(yyv4818) { yyv4818 = yyv4818[:yyrl4818] } else { - yyv4818 = make([]Secret, yyrl4818) + yyv4818 = make([]ResourceQuota, yyrl4818) } } else { - yyv4818 = make([]Secret, yyrl4818) + yyv4818 = make([]ResourceQuota, yyrl4818) } yyc4818 = true yyrr4818 = len(yyv4818) @@ -61821,7 +61795,7 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { for ; yyj4818 < yyrr4818; yyj4818++ { yyh4818.ElemContainerState(yyj4818) if r.TryDecodeAsNil() { - yyv4818[yyj4818] = Secret{} + yyv4818[yyj4818] = ResourceQuota{} } else { yyv4819 := &yyv4818[yyj4818] yyv4819.CodecDecodeSelf(d) @@ -61830,10 +61804,10 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { } if yyrt4818 { for ; yyj4818 < yyl4818; yyj4818++ { - yyv4818 = append(yyv4818, Secret{}) + yyv4818 = append(yyv4818, ResourceQuota{}) yyh4818.ElemContainerState(yyj4818) if r.TryDecodeAsNil() { - yyv4818[yyj4818] = Secret{} + yyv4818[yyj4818] = ResourceQuota{} } else { yyv4820 := &yyv4818[yyj4818] yyv4820.CodecDecodeSelf(d) @@ -61847,13 +61821,13 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { for ; !r.CheckBreak(); yyj4818++ { if yyj4818 >= len(yyv4818) { - yyv4818 = append(yyv4818, Secret{}) // var yyz4818 Secret + yyv4818 = append(yyv4818, ResourceQuota{}) // var yyz4818 ResourceQuota yyc4818 = true } yyh4818.ElemContainerState(yyj4818) if yyj4818 < len(yyv4818) { if r.TryDecodeAsNil() { - yyv4818[yyj4818] = Secret{} + yyv4818[yyj4818] = ResourceQuota{} } else { yyv4821 := &yyv4818[yyj4818] yyv4821.CodecDecodeSelf(d) @@ -61868,7 +61842,7 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { yyv4818 = yyv4818[:yyj4818] yyc4818 = true } else if yyj4818 == 0 && yyv4818 == nil { - yyv4818 = []Secret{} + yyv4818 = []ResourceQuota{} yyc4818 = true } } @@ -61878,15 +61852,244 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { } } +func (x codecSelfer1234) encMapstringSliceuint8(v map[string][]uint8, e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeMapStart(len(v)) + for yyk4822, yyv4822 := range v { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + yym4823 := z.EncBinary() + _ = yym4823 + if false { + } else { + r.EncodeString(codecSelferC_UTF81234, string(yyk4822)) + } + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if yyv4822 == nil { + r.EncodeNil() + } else { + yym4824 := z.EncBinary() + _ = yym4824 + if false { + } else { + r.EncodeStringBytes(codecSelferC_RAW1234, []byte(yyv4822)) + } + } + } + z.EncSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x codecSelfer1234) decMapstringSliceuint8(v *map[string][]uint8, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv4825 := *v + yyl4825 := r.ReadMapStart() + yybh4825 := z.DecBasicHandle() + if yyv4825 == nil { + yyrl4825, _ := z.DecInferLen(yyl4825, yybh4825.MaxInitLen, 40) + yyv4825 = make(map[string][]uint8, yyrl4825) + *v = yyv4825 + } + var yymk4825 string + var yymv4825 []uint8 + var yymg4825 bool + if yybh4825.MapValueReset { + yymg4825 = true + } + if yyl4825 > 0 { + for yyj4825 := 0; yyj4825 < yyl4825; yyj4825++ { + z.DecSendContainerState(codecSelfer_containerMapKey1234) + if r.TryDecodeAsNil() { + yymk4825 = "" + } else { + yymk4825 = string(r.DecodeString()) + } + + if yymg4825 { + yymv4825 = yyv4825[yymk4825] + } else { + yymv4825 = nil + } + z.DecSendContainerState(codecSelfer_containerMapValue1234) + if r.TryDecodeAsNil() { + yymv4825 = nil + } else { + yyv4827 := &yymv4825 + yym4828 := z.DecBinary() + _ = yym4828 + if false { + } else { + *yyv4827 = r.DecodeBytes(*(*[]byte)(yyv4827), false, false) + } + } + + if yyv4825 != nil { + yyv4825[yymk4825] = yymv4825 + } + } + } else if yyl4825 < 0 { + for yyj4825 := 0; !r.CheckBreak(); yyj4825++ { + z.DecSendContainerState(codecSelfer_containerMapKey1234) + if r.TryDecodeAsNil() { + yymk4825 = "" + } else { + yymk4825 = string(r.DecodeString()) + } + + if yymg4825 { + yymv4825 = yyv4825[yymk4825] + } else { + yymv4825 = nil + } + z.DecSendContainerState(codecSelfer_containerMapValue1234) + if r.TryDecodeAsNil() { + yymv4825 = nil + } else { + yyv4830 := &yymv4825 + yym4831 := z.DecBinary() + _ = yym4831 + if false { + } else { + *yyv4830 = r.DecodeBytes(*(*[]byte)(yyv4830), false, false) + } + } + + if yyv4825 != nil { + yyv4825[yymk4825] = yymv4825 + } + } + } // else len==0: TODO: Should we clear map entries? + z.DecSendContainerState(codecSelfer_containerMapEnd1234) +} + +func (x codecSelfer1234) encSliceSecret(v []Secret, e *codec1978.Encoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv4832 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy4833 := &yyv4832 + yy4833.CodecEncodeSelf(e) + } + z.EncSendContainerState(codecSelfer_containerArrayEnd1234) +} + +func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) { + var h codecSelfer1234 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv4834 := *v + yyh4834, yyl4834 := z.DecSliceHelperStart() + var yyc4834 bool + if yyl4834 == 0 { + if yyv4834 == nil { + yyv4834 = []Secret{} + yyc4834 = true + } else if len(yyv4834) != 0 { + yyv4834 = yyv4834[:0] + yyc4834 = true + } + } else if yyl4834 > 0 { + var yyrr4834, yyrl4834 int + var yyrt4834 bool + if yyl4834 > cap(yyv4834) { + + yyrg4834 := len(yyv4834) > 0 + yyv24834 := yyv4834 + yyrl4834, yyrt4834 = z.DecInferLen(yyl4834, z.DecBasicHandle().MaxInitLen, 280) + if yyrt4834 { + if yyrl4834 <= cap(yyv4834) { + yyv4834 = yyv4834[:yyrl4834] + } else { + yyv4834 = make([]Secret, yyrl4834) + } + } else { + yyv4834 = make([]Secret, yyrl4834) + } + yyc4834 = true + yyrr4834 = len(yyv4834) + if yyrg4834 { + copy(yyv4834, yyv24834) + } + } else if yyl4834 != len(yyv4834) { + yyv4834 = yyv4834[:yyl4834] + yyc4834 = true + } + yyj4834 := 0 + for ; yyj4834 < yyrr4834; yyj4834++ { + yyh4834.ElemContainerState(yyj4834) + if r.TryDecodeAsNil() { + yyv4834[yyj4834] = Secret{} + } else { + yyv4835 := &yyv4834[yyj4834] + yyv4835.CodecDecodeSelf(d) + } + + } + if yyrt4834 { + for ; yyj4834 < yyl4834; yyj4834++ { + yyv4834 = append(yyv4834, Secret{}) + yyh4834.ElemContainerState(yyj4834) + if r.TryDecodeAsNil() { + yyv4834[yyj4834] = Secret{} + } else { + yyv4836 := &yyv4834[yyj4834] + yyv4836.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj4834 := 0 + for ; !r.CheckBreak(); yyj4834++ { + + if yyj4834 >= len(yyv4834) { + yyv4834 = append(yyv4834, Secret{}) // var yyz4834 Secret + yyc4834 = true + } + yyh4834.ElemContainerState(yyj4834) + if yyj4834 < len(yyv4834) { + if r.TryDecodeAsNil() { + yyv4834[yyj4834] = Secret{} + } else { + yyv4837 := &yyv4834[yyj4834] + yyv4837.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj4834 < len(yyv4834) { + yyv4834 = yyv4834[:yyj4834] + yyc4834 = true + } else if yyj4834 == 0 && yyv4834 == nil { + yyv4834 = []Secret{} + yyc4834 = true + } + } + yyh4834.End() + if yyc4834 { + *v = yyv4834 + } +} + func (x codecSelfer1234) encSliceConfigMap(v []ConfigMap, e *codec1978.Encoder) { var h codecSelfer1234 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4822 := range v { + for _, yyv4838 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4823 := &yyv4822 - yy4823.CodecEncodeSelf(e) + yy4839 := &yyv4838 + yy4839.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -61896,83 +62099,83 @@ func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder) z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4824 := *v - yyh4824, yyl4824 := z.DecSliceHelperStart() - var yyc4824 bool - if yyl4824 == 0 { - if yyv4824 == nil { - yyv4824 = []ConfigMap{} - yyc4824 = true - } else if len(yyv4824) != 0 { - yyv4824 = yyv4824[:0] - yyc4824 = true + yyv4840 := *v + yyh4840, yyl4840 := z.DecSliceHelperStart() + var yyc4840 bool + if yyl4840 == 0 { + if yyv4840 == nil { + yyv4840 = []ConfigMap{} + yyc4840 = true + } else if len(yyv4840) != 0 { + yyv4840 = yyv4840[:0] + yyc4840 = true } - } else if yyl4824 > 0 { - var yyrr4824, yyrl4824 int - var yyrt4824 bool - if yyl4824 > cap(yyv4824) { + } else if yyl4840 > 0 { + var yyrr4840, yyrl4840 int + var yyrt4840 bool + if yyl4840 > cap(yyv4840) { - yyrg4824 := len(yyv4824) > 0 - yyv24824 := yyv4824 - yyrl4824, yyrt4824 = z.DecInferLen(yyl4824, z.DecBasicHandle().MaxInitLen, 264) - if yyrt4824 { - if yyrl4824 <= cap(yyv4824) { - yyv4824 = yyv4824[:yyrl4824] + yyrg4840 := len(yyv4840) > 0 + yyv24840 := yyv4840 + yyrl4840, yyrt4840 = z.DecInferLen(yyl4840, z.DecBasicHandle().MaxInitLen, 264) + if yyrt4840 { + if yyrl4840 <= cap(yyv4840) { + yyv4840 = yyv4840[:yyrl4840] } else { - yyv4824 = make([]ConfigMap, yyrl4824) + yyv4840 = make([]ConfigMap, yyrl4840) } } else { - yyv4824 = make([]ConfigMap, yyrl4824) + yyv4840 = make([]ConfigMap, yyrl4840) } - yyc4824 = true - yyrr4824 = len(yyv4824) - if yyrg4824 { - copy(yyv4824, yyv24824) + yyc4840 = true + yyrr4840 = len(yyv4840) + if yyrg4840 { + copy(yyv4840, yyv24840) } - } else if yyl4824 != len(yyv4824) { - yyv4824 = yyv4824[:yyl4824] - yyc4824 = true + } else if yyl4840 != len(yyv4840) { + yyv4840 = yyv4840[:yyl4840] + yyc4840 = true } - yyj4824 := 0 - for ; yyj4824 < yyrr4824; yyj4824++ { - yyh4824.ElemContainerState(yyj4824) + yyj4840 := 0 + for ; yyj4840 < yyrr4840; yyj4840++ { + yyh4840.ElemContainerState(yyj4840) if r.TryDecodeAsNil() { - yyv4824[yyj4824] = ConfigMap{} + yyv4840[yyj4840] = ConfigMap{} } else { - yyv4825 := &yyv4824[yyj4824] - yyv4825.CodecDecodeSelf(d) + yyv4841 := &yyv4840[yyj4840] + yyv4841.CodecDecodeSelf(d) } } - if yyrt4824 { - for ; yyj4824 < yyl4824; yyj4824++ { - yyv4824 = append(yyv4824, ConfigMap{}) - yyh4824.ElemContainerState(yyj4824) + if yyrt4840 { + for ; yyj4840 < yyl4840; yyj4840++ { + yyv4840 = append(yyv4840, ConfigMap{}) + yyh4840.ElemContainerState(yyj4840) if r.TryDecodeAsNil() { - yyv4824[yyj4824] = ConfigMap{} + yyv4840[yyj4840] = ConfigMap{} } else { - yyv4826 := &yyv4824[yyj4824] - yyv4826.CodecDecodeSelf(d) + yyv4842 := &yyv4840[yyj4840] + yyv4842.CodecDecodeSelf(d) } } } } else { - yyj4824 := 0 - for ; !r.CheckBreak(); yyj4824++ { + yyj4840 := 0 + for ; !r.CheckBreak(); yyj4840++ { - if yyj4824 >= len(yyv4824) { - yyv4824 = append(yyv4824, ConfigMap{}) // var yyz4824 ConfigMap - yyc4824 = true + if yyj4840 >= len(yyv4840) { + yyv4840 = append(yyv4840, ConfigMap{}) // var yyz4840 ConfigMap + yyc4840 = true } - yyh4824.ElemContainerState(yyj4824) - if yyj4824 < len(yyv4824) { + yyh4840.ElemContainerState(yyj4840) + if yyj4840 < len(yyv4840) { if r.TryDecodeAsNil() { - yyv4824[yyj4824] = ConfigMap{} + yyv4840[yyj4840] = ConfigMap{} } else { - yyv4827 := &yyv4824[yyj4824] - yyv4827.CodecDecodeSelf(d) + yyv4843 := &yyv4840[yyj4840] + yyv4843.CodecDecodeSelf(d) } } else { @@ -61980,17 +62183,17 @@ func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder) } } - if yyj4824 < len(yyv4824) { - yyv4824 = yyv4824[:yyj4824] - yyc4824 = true - } else if yyj4824 == 0 && yyv4824 == nil { - yyv4824 = []ConfigMap{} - yyc4824 = true + if yyj4840 < len(yyv4840) { + yyv4840 = yyv4840[:yyj4840] + yyc4840 = true + } else if yyj4840 == 0 && yyv4840 == nil { + yyv4840 = []ConfigMap{} + yyc4840 = true } } - yyh4824.End() - if yyc4824 { - *v = yyv4824 + yyh4840.End() + if yyc4840 { + *v = yyv4840 } } @@ -61999,10 +62202,10 @@ func (x codecSelfer1234) encSliceComponentCondition(v []ComponentCondition, e *c z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4828 := range v { + for _, yyv4844 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4829 := &yyv4828 - yy4829.CodecEncodeSelf(e) + yy4845 := &yyv4844 + yy4845.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -62012,83 +62215,83 @@ func (x codecSelfer1234) decSliceComponentCondition(v *[]ComponentCondition, d * z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4830 := *v - yyh4830, yyl4830 := z.DecSliceHelperStart() - var yyc4830 bool - if yyl4830 == 0 { - if yyv4830 == nil { - yyv4830 = []ComponentCondition{} - yyc4830 = true - } else if len(yyv4830) != 0 { - yyv4830 = yyv4830[:0] - yyc4830 = true + yyv4846 := *v + yyh4846, yyl4846 := z.DecSliceHelperStart() + var yyc4846 bool + if yyl4846 == 0 { + if yyv4846 == nil { + yyv4846 = []ComponentCondition{} + yyc4846 = true + } else if len(yyv4846) != 0 { + yyv4846 = yyv4846[:0] + yyc4846 = true } - } else if yyl4830 > 0 { - var yyrr4830, yyrl4830 int - var yyrt4830 bool - if yyl4830 > cap(yyv4830) { + } else if yyl4846 > 0 { + var yyrr4846, yyrl4846 int + var yyrt4846 bool + if yyl4846 > cap(yyv4846) { - yyrg4830 := len(yyv4830) > 0 - yyv24830 := yyv4830 - yyrl4830, yyrt4830 = z.DecInferLen(yyl4830, z.DecBasicHandle().MaxInitLen, 64) - if yyrt4830 { - if yyrl4830 <= cap(yyv4830) { - yyv4830 = yyv4830[:yyrl4830] + yyrg4846 := len(yyv4846) > 0 + yyv24846 := yyv4846 + yyrl4846, yyrt4846 = z.DecInferLen(yyl4846, z.DecBasicHandle().MaxInitLen, 64) + if yyrt4846 { + if yyrl4846 <= cap(yyv4846) { + yyv4846 = yyv4846[:yyrl4846] } else { - yyv4830 = make([]ComponentCondition, yyrl4830) + yyv4846 = make([]ComponentCondition, yyrl4846) } } else { - yyv4830 = make([]ComponentCondition, yyrl4830) + yyv4846 = make([]ComponentCondition, yyrl4846) } - yyc4830 = true - yyrr4830 = len(yyv4830) - if yyrg4830 { - copy(yyv4830, yyv24830) + yyc4846 = true + yyrr4846 = len(yyv4846) + if yyrg4846 { + copy(yyv4846, yyv24846) } - } else if yyl4830 != len(yyv4830) { - yyv4830 = yyv4830[:yyl4830] - yyc4830 = true + } else if yyl4846 != len(yyv4846) { + yyv4846 = yyv4846[:yyl4846] + yyc4846 = true } - yyj4830 := 0 - for ; yyj4830 < yyrr4830; yyj4830++ { - yyh4830.ElemContainerState(yyj4830) + yyj4846 := 0 + for ; yyj4846 < yyrr4846; yyj4846++ { + yyh4846.ElemContainerState(yyj4846) if r.TryDecodeAsNil() { - yyv4830[yyj4830] = ComponentCondition{} + yyv4846[yyj4846] = ComponentCondition{} } else { - yyv4831 := &yyv4830[yyj4830] - yyv4831.CodecDecodeSelf(d) + yyv4847 := &yyv4846[yyj4846] + yyv4847.CodecDecodeSelf(d) } } - if yyrt4830 { - for ; yyj4830 < yyl4830; yyj4830++ { - yyv4830 = append(yyv4830, ComponentCondition{}) - yyh4830.ElemContainerState(yyj4830) + if yyrt4846 { + for ; yyj4846 < yyl4846; yyj4846++ { + yyv4846 = append(yyv4846, ComponentCondition{}) + yyh4846.ElemContainerState(yyj4846) if r.TryDecodeAsNil() { - yyv4830[yyj4830] = ComponentCondition{} + yyv4846[yyj4846] = ComponentCondition{} } else { - yyv4832 := &yyv4830[yyj4830] - yyv4832.CodecDecodeSelf(d) + yyv4848 := &yyv4846[yyj4846] + yyv4848.CodecDecodeSelf(d) } } } } else { - yyj4830 := 0 - for ; !r.CheckBreak(); yyj4830++ { + yyj4846 := 0 + for ; !r.CheckBreak(); yyj4846++ { - if yyj4830 >= len(yyv4830) { - yyv4830 = append(yyv4830, ComponentCondition{}) // var yyz4830 ComponentCondition - yyc4830 = true + if yyj4846 >= len(yyv4846) { + yyv4846 = append(yyv4846, ComponentCondition{}) // var yyz4846 ComponentCondition + yyc4846 = true } - yyh4830.ElemContainerState(yyj4830) - if yyj4830 < len(yyv4830) { + yyh4846.ElemContainerState(yyj4846) + if yyj4846 < len(yyv4846) { if r.TryDecodeAsNil() { - yyv4830[yyj4830] = ComponentCondition{} + yyv4846[yyj4846] = ComponentCondition{} } else { - yyv4833 := &yyv4830[yyj4830] - yyv4833.CodecDecodeSelf(d) + yyv4849 := &yyv4846[yyj4846] + yyv4849.CodecDecodeSelf(d) } } else { @@ -62096,17 +62299,17 @@ func (x codecSelfer1234) decSliceComponentCondition(v *[]ComponentCondition, d * } } - if yyj4830 < len(yyv4830) { - yyv4830 = yyv4830[:yyj4830] - yyc4830 = true - } else if yyj4830 == 0 && yyv4830 == nil { - yyv4830 = []ComponentCondition{} - yyc4830 = true + if yyj4846 < len(yyv4846) { + yyv4846 = yyv4846[:yyj4846] + yyc4846 = true + } else if yyj4846 == 0 && yyv4846 == nil { + yyv4846 = []ComponentCondition{} + yyc4846 = true } } - yyh4830.End() - if yyc4830 { - *v = yyv4830 + yyh4846.End() + if yyc4846 { + *v = yyv4846 } } @@ -62115,10 +62318,10 @@ func (x codecSelfer1234) encSliceComponentStatus(v []ComponentStatus, e *codec19 z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeArrayStart(len(v)) - for _, yyv4834 := range v { + for _, yyv4850 := range v { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy4835 := &yyv4834 - yy4835.CodecEncodeSelf(e) + yy4851 := &yyv4850 + yy4851.CodecEncodeSelf(e) } z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -62128,83 +62331,83 @@ func (x codecSelfer1234) decSliceComponentStatus(v *[]ComponentStatus, d *codec1 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv4836 := *v - yyh4836, yyl4836 := z.DecSliceHelperStart() - var yyc4836 bool - if yyl4836 == 0 { - if yyv4836 == nil { - yyv4836 = []ComponentStatus{} - yyc4836 = true - } else if len(yyv4836) != 0 { - yyv4836 = yyv4836[:0] - yyc4836 = true + yyv4852 := *v + yyh4852, yyl4852 := z.DecSliceHelperStart() + var yyc4852 bool + if yyl4852 == 0 { + if yyv4852 == nil { + yyv4852 = []ComponentStatus{} + yyc4852 = true + } else if len(yyv4852) != 0 { + yyv4852 = yyv4852[:0] + yyc4852 = true } - } else if yyl4836 > 0 { - var yyrr4836, yyrl4836 int - var yyrt4836 bool - if yyl4836 > cap(yyv4836) { + } else if yyl4852 > 0 { + var yyrr4852, yyrl4852 int + var yyrt4852 bool + if yyl4852 > cap(yyv4852) { - yyrg4836 := len(yyv4836) > 0 - yyv24836 := yyv4836 - yyrl4836, yyrt4836 = z.DecInferLen(yyl4836, z.DecBasicHandle().MaxInitLen, 280) - if yyrt4836 { - if yyrl4836 <= cap(yyv4836) { - yyv4836 = yyv4836[:yyrl4836] + yyrg4852 := len(yyv4852) > 0 + yyv24852 := yyv4852 + yyrl4852, yyrt4852 = z.DecInferLen(yyl4852, z.DecBasicHandle().MaxInitLen, 280) + if yyrt4852 { + if yyrl4852 <= cap(yyv4852) { + yyv4852 = yyv4852[:yyrl4852] } else { - yyv4836 = make([]ComponentStatus, yyrl4836) + yyv4852 = make([]ComponentStatus, yyrl4852) } } else { - yyv4836 = make([]ComponentStatus, yyrl4836) + yyv4852 = make([]ComponentStatus, yyrl4852) } - yyc4836 = true - yyrr4836 = len(yyv4836) - if yyrg4836 { - copy(yyv4836, yyv24836) + yyc4852 = true + yyrr4852 = len(yyv4852) + if yyrg4852 { + copy(yyv4852, yyv24852) } - } else if yyl4836 != len(yyv4836) { - yyv4836 = yyv4836[:yyl4836] - yyc4836 = true + } else if yyl4852 != len(yyv4852) { + yyv4852 = yyv4852[:yyl4852] + yyc4852 = true } - yyj4836 := 0 - for ; yyj4836 < yyrr4836; yyj4836++ { - yyh4836.ElemContainerState(yyj4836) + yyj4852 := 0 + for ; yyj4852 < yyrr4852; yyj4852++ { + yyh4852.ElemContainerState(yyj4852) if r.TryDecodeAsNil() { - yyv4836[yyj4836] = ComponentStatus{} + yyv4852[yyj4852] = ComponentStatus{} } else { - yyv4837 := &yyv4836[yyj4836] - yyv4837.CodecDecodeSelf(d) + yyv4853 := &yyv4852[yyj4852] + yyv4853.CodecDecodeSelf(d) } } - if yyrt4836 { - for ; yyj4836 < yyl4836; yyj4836++ { - yyv4836 = append(yyv4836, ComponentStatus{}) - yyh4836.ElemContainerState(yyj4836) + if yyrt4852 { + for ; yyj4852 < yyl4852; yyj4852++ { + yyv4852 = append(yyv4852, ComponentStatus{}) + yyh4852.ElemContainerState(yyj4852) if r.TryDecodeAsNil() { - yyv4836[yyj4836] = ComponentStatus{} + yyv4852[yyj4852] = ComponentStatus{} } else { - yyv4838 := &yyv4836[yyj4836] - yyv4838.CodecDecodeSelf(d) + yyv4854 := &yyv4852[yyj4852] + yyv4854.CodecDecodeSelf(d) } } } } else { - yyj4836 := 0 - for ; !r.CheckBreak(); yyj4836++ { + yyj4852 := 0 + for ; !r.CheckBreak(); yyj4852++ { - if yyj4836 >= len(yyv4836) { - yyv4836 = append(yyv4836, ComponentStatus{}) // var yyz4836 ComponentStatus - yyc4836 = true + if yyj4852 >= len(yyv4852) { + yyv4852 = append(yyv4852, ComponentStatus{}) // var yyz4852 ComponentStatus + yyc4852 = true } - yyh4836.ElemContainerState(yyj4836) - if yyj4836 < len(yyv4836) { + yyh4852.ElemContainerState(yyj4852) + if yyj4852 < len(yyv4852) { if r.TryDecodeAsNil() { - yyv4836[yyj4836] = ComponentStatus{} + yyv4852[yyj4852] = ComponentStatus{} } else { - yyv4839 := &yyv4836[yyj4836] - yyv4839.CodecDecodeSelf(d) + yyv4855 := &yyv4852[yyj4852] + yyv4855.CodecDecodeSelf(d) } } else { @@ -62212,16 +62415,16 @@ func (x codecSelfer1234) decSliceComponentStatus(v *[]ComponentStatus, d *codec1 } } - if yyj4836 < len(yyv4836) { - yyv4836 = yyv4836[:yyj4836] - yyc4836 = true - } else if yyj4836 == 0 && yyv4836 == nil { - yyv4836 = []ComponentStatus{} - yyc4836 = true + if yyj4852 < len(yyv4852) { + yyv4852 = yyv4852[:yyj4852] + yyc4852 = true + } else if yyj4852 == 0 && yyv4852 == nil { + yyv4852 = []ComponentStatus{} + yyc4852 = true } } - yyh4836.End() - if yyc4836 { - *v = yyv4836 + yyh4852.End() + if yyc4852 { + *v = yyv4852 } } diff --git a/pkg/api/zz_generated.deepcopy.go b/pkg/api/zz_generated.deepcopy.go index c104415670e..b4d69f1b2f5 100644 --- a/pkg/api/zz_generated.deepcopy.go +++ b/pkg/api/zz_generated.deepcopy.go @@ -186,6 +186,7 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error { conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceProxyOptions, InType: reflect.TypeOf(&ServiceProxyOptions{})}, conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceSpec, InType: reflect.TypeOf(&ServiceSpec{})}, conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceStatus, InType: reflect.TypeOf(&ServiceStatus{})}, + conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Sysctl, InType: reflect.TypeOf(&Sysctl{})}, conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_TCPSocketAction, InType: reflect.TypeOf(&TCPSocketAction{})}, conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Taint, InType: reflect.TypeOf(&Taint{})}, conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Toleration, InType: reflect.TypeOf(&Toleration{})}, @@ -3481,6 +3482,16 @@ func DeepCopy_api_ServiceStatus(in interface{}, out interface{}, c *conversion.C } } +func DeepCopy_api_Sysctl(in interface{}, out interface{}, c *conversion.Cloner) error { + { + in := in.(*Sysctl) + out := out.(*Sysctl) + out.Name = in.Name + out.Value = in.Value + return nil + } +} + func DeepCopy_api_TCPSocketAction(in interface{}, out interface{}, c *conversion.Cloner) error { { in := in.(*TCPSocketAction) diff --git a/pkg/apis/componentconfig/types.generated.go b/pkg/apis/componentconfig/types.generated.go index c08d35ca484..093ad58b4b2 100644 --- a/pkg/apis/componentconfig/types.generated.go +++ b/pkg/apis/componentconfig/types.generated.go @@ -1218,7 +1218,7 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { } else { yysep130 := !z.EncBinary() yy2arr130 := z.EncBasicHandle().StructToArray - var yyq130 [104]bool + var yyq130 [105]bool _, _, _ = yysep130, yyq130, yy2arr130 const yyr130 bool = false yyq130[0] = x.Kind != "" @@ -1242,9 +1242,10 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { yyq130[93] = true yyq130[94] = x.EvictionMaxPodGracePeriod != 0 yyq130[95] = x.EvictionMinimumReclaim != "" + yyq130[104] = len(x.AllowedUnsafeSysctls) != 0 var yynn130 int if yyr130 || yy2arr130 { - r.EncodeArrayStart(104) + r.EncodeArrayStart(105) } else { yynn130 = 83 for _, b := range yyq130 { @@ -3497,6 +3498,39 @@ func (x *KubeletConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeInt(int64(x.IPTablesDropBit)) } } + if yyr130 || yy2arr130 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + if yyq130[104] { + if x.AllowedUnsafeSysctls == nil { + r.EncodeNil() + } else { + yym466 := z.EncBinary() + _ = yym466 + if false { + } else { + z.F.EncSliceStringV(x.AllowedUnsafeSysctls, false, e) + } + } + } else { + r.EncodeNil() + } + } else { + if yyq130[104] { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("experimentalAllowedUnsafeSysctls")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + if x.AllowedUnsafeSysctls == nil { + r.EncodeNil() + } else { + yym467 := z.EncBinary() + _ = yym467 + if false { + } else { + z.F.EncSliceStringV(x.AllowedUnsafeSysctls, false, e) + } + } + } + } if yyr130 || yy2arr130 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { @@ -3510,25 +3544,25 @@ func (x *KubeletConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym465 := z.DecBinary() - _ = yym465 + yym468 := z.DecBinary() + _ = yym468 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct466 := r.ContainerType() - if yyct466 == codecSelferValueTypeMap1234 { - yyl466 := r.ReadMapStart() - if yyl466 == 0 { + yyct469 := r.ContainerType() + if yyct469 == codecSelferValueTypeMap1234 { + yyl469 := r.ReadMapStart() + if yyl469 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl466, d) + x.codecDecodeSelfFromMap(yyl469, d) } - } else if yyct466 == codecSelferValueTypeArray1234 { - yyl466 := r.ReadArrayStart() - if yyl466 == 0 { + } else if yyct469 == codecSelferValueTypeArray1234 { + yyl469 := r.ReadArrayStart() + if yyl469 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl466, d) + x.codecDecodeSelfFromArray(yyl469, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -3540,12 +3574,12 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys467Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys467Slc - var yyhl467 bool = l >= 0 - for yyj467 := 0; ; yyj467++ { - if yyhl467 { - if yyj467 >= l { + var yys470Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys470Slc + var yyhl470 bool = l >= 0 + for yyj470 := 0; ; yyj470++ { + if yyhl470 { + if yyj470 >= l { break } } else { @@ -3554,10 +3588,10 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys467Slc = r.DecodeBytes(yys467Slc, true, true) - yys467 := string(yys467Slc) + yys470Slc = r.DecodeBytes(yys470Slc, true, true) + yys470 := string(yys470Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys467 { + switch yys470 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -3580,45 +3614,45 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.SyncFrequency = pkg1_unversioned.Duration{} } else { - yyv471 := &x.SyncFrequency - yym472 := z.DecBinary() - _ = yym472 + yyv474 := &x.SyncFrequency + yym475 := z.DecBinary() + _ = yym475 if false { - } else if z.HasExtensions() && z.DecExt(yyv471) { - } else if !yym472 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv471) + } else if z.HasExtensions() && z.DecExt(yyv474) { + } else if !yym475 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv474) } else { - z.DecFallback(yyv471, false) + z.DecFallback(yyv474, false) } } case "fileCheckFrequency": if r.TryDecodeAsNil() { x.FileCheckFrequency = pkg1_unversioned.Duration{} } else { - yyv473 := &x.FileCheckFrequency - yym474 := z.DecBinary() - _ = yym474 + yyv476 := &x.FileCheckFrequency + yym477 := z.DecBinary() + _ = yym477 if false { - } else if z.HasExtensions() && z.DecExt(yyv473) { - } else if !yym474 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv473) + } else if z.HasExtensions() && z.DecExt(yyv476) { + } else if !yym477 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv476) } else { - z.DecFallback(yyv473, false) + z.DecFallback(yyv476, false) } } case "httpCheckFrequency": if r.TryDecodeAsNil() { x.HTTPCheckFrequency = pkg1_unversioned.Duration{} } else { - yyv475 := &x.HTTPCheckFrequency - yym476 := z.DecBinary() - _ = yym476 + yyv478 := &x.HTTPCheckFrequency + yym479 := z.DecBinary() + _ = yym479 if false { - } else if z.HasExtensions() && z.DecExt(yyv475) { - } else if !yym476 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv475) + } else if z.HasExtensions() && z.DecExt(yyv478) { + } else if !yym479 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv478) } else { - z.DecFallback(yyv475, false) + z.DecFallback(yyv478, false) } } case "manifestURL": @@ -3715,36 +3749,36 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.HostNetworkSources = nil } else { - yyv492 := &x.HostNetworkSources - yym493 := z.DecBinary() - _ = yym493 + yyv495 := &x.HostNetworkSources + yym496 := z.DecBinary() + _ = yym496 if false { } else { - z.F.DecSliceStringX(yyv492, false, d) + z.F.DecSliceStringX(yyv495, false, d) } } case "hostPIDSources": if r.TryDecodeAsNil() { x.HostPIDSources = nil } else { - yyv494 := &x.HostPIDSources - yym495 := z.DecBinary() - _ = yym495 + yyv497 := &x.HostPIDSources + yym498 := z.DecBinary() + _ = yym498 if false { } else { - z.F.DecSliceStringX(yyv494, false, d) + z.F.DecSliceStringX(yyv497, false, d) } } case "hostIPCSources": if r.TryDecodeAsNil() { x.HostIPCSources = nil } else { - yyv496 := &x.HostIPCSources - yym497 := z.DecBinary() - _ = yym497 + yyv499 := &x.HostIPCSources + yym500 := z.DecBinary() + _ = yym500 if false { } else { - z.F.DecSliceStringX(yyv496, false, d) + z.F.DecSliceStringX(yyv499, false, d) } } case "registryPullQPS": @@ -3781,15 +3815,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.MinimumGCAge = pkg1_unversioned.Duration{} } else { - yyv503 := &x.MinimumGCAge - yym504 := z.DecBinary() - _ = yym504 + yyv506 := &x.MinimumGCAge + yym507 := z.DecBinary() + _ = yym507 if false { - } else if z.HasExtensions() && z.DecExt(yyv503) { - } else if !yym504 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv503) + } else if z.HasExtensions() && z.DecExt(yyv506) { + } else if !yym507 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv506) } else { - z.DecFallback(yyv503, false) + z.DecFallback(yyv506, false) } } case "maxPerPodContainerCount": @@ -3856,45 +3890,45 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.StreamingConnectionIdleTimeout = pkg1_unversioned.Duration{} } else { - yyv515 := &x.StreamingConnectionIdleTimeout - yym516 := z.DecBinary() - _ = yym516 + yyv518 := &x.StreamingConnectionIdleTimeout + yym519 := z.DecBinary() + _ = yym519 if false { - } else if z.HasExtensions() && z.DecExt(yyv515) { - } else if !yym516 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv515) + } else if z.HasExtensions() && z.DecExt(yyv518) { + } else if !yym519 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv518) } else { - z.DecFallback(yyv515, false) + z.DecFallback(yyv518, false) } } case "nodeStatusUpdateFrequency": if r.TryDecodeAsNil() { x.NodeStatusUpdateFrequency = pkg1_unversioned.Duration{} } else { - yyv517 := &x.NodeStatusUpdateFrequency - yym518 := z.DecBinary() - _ = yym518 + yyv520 := &x.NodeStatusUpdateFrequency + yym521 := z.DecBinary() + _ = yym521 if false { - } else if z.HasExtensions() && z.DecExt(yyv517) { - } else if !yym518 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv517) + } else if z.HasExtensions() && z.DecExt(yyv520) { + } else if !yym521 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv520) } else { - z.DecFallback(yyv517, false) + z.DecFallback(yyv520, false) } } case "imageMinimumGCAge": if r.TryDecodeAsNil() { x.ImageMinimumGCAge = pkg1_unversioned.Duration{} } else { - yyv519 := &x.ImageMinimumGCAge - yym520 := z.DecBinary() - _ = yym520 + yyv522 := &x.ImageMinimumGCAge + yym523 := z.DecBinary() + _ = yym523 if false { - } else if z.HasExtensions() && z.DecExt(yyv519) { - } else if !yym520 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv519) + } else if z.HasExtensions() && z.DecExt(yyv522) { + } else if !yym523 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv522) } else { - z.DecFallback(yyv519, false) + z.DecFallback(yyv522, false) } } case "imageGCHighThresholdPercent": @@ -3919,15 +3953,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{} } else { - yyv524 := &x.VolumeStatsAggPeriod - yym525 := z.DecBinary() - _ = yym525 + yyv527 := &x.VolumeStatsAggPeriod + yym528 := z.DecBinary() + _ = yym528 if false { - } else if z.HasExtensions() && z.DecExt(yyv524) { - } else if !yym525 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv524) + } else if z.HasExtensions() && z.DecExt(yyv527) { + } else if !yym528 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv527) } else { - z.DecFallback(yyv524, false) + z.DecFallback(yyv527, false) } } case "networkPluginName": @@ -4018,15 +4052,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.RuntimeRequestTimeout = pkg1_unversioned.Duration{} } else { - yyv540 := &x.RuntimeRequestTimeout - yym541 := z.DecBinary() - _ = yym541 + yyv543 := &x.RuntimeRequestTimeout + yym544 := z.DecBinary() + _ = yym544 if false { - } else if z.HasExtensions() && z.DecExt(yyv540) { - } else if !yym541 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv540) + } else if z.HasExtensions() && z.DecExt(yyv543) { + } else if !yym544 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv543) } else { - z.DecFallback(yyv540, false) + z.DecFallback(yyv543, false) } } case "rktPath": @@ -4171,15 +4205,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.OutOfDiskTransitionFrequency = pkg1_unversioned.Duration{} } else { - yyv565 := &x.OutOfDiskTransitionFrequency - yym566 := z.DecBinary() - _ = yym566 + yyv568 := &x.OutOfDiskTransitionFrequency + yym569 := z.DecBinary() + _ = yym569 if false { - } else if z.HasExtensions() && z.DecExt(yyv565) { - } else if !yym566 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv565) + } else if z.HasExtensions() && z.DecExt(yyv568) { + } else if !yym569 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv568) } else { - z.DecFallback(yyv565, false) + z.DecFallback(yyv568, false) } } case "nodeIP": @@ -4192,12 +4226,12 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.NodeLabels = nil } else { - yyv568 := &x.NodeLabels - yym569 := z.DecBinary() - _ = yym569 + yyv571 := &x.NodeLabels + yym572 := z.DecBinary() + _ = yym572 if false { } else { - z.F.DecMapStringStringX(yyv568, false, d) + z.F.DecMapStringStringX(yyv571, false, d) } } case "nonMasqueradeCIDR": @@ -4234,15 +4268,15 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.EvictionPressureTransitionPeriod = pkg1_unversioned.Duration{} } else { - yyv575 := &x.EvictionPressureTransitionPeriod - yym576 := z.DecBinary() - _ = yym576 + yyv578 := &x.EvictionPressureTransitionPeriod + yym579 := z.DecBinary() + _ = yym579 if false { - } else if z.HasExtensions() && z.DecExt(yyv575) { - } else if !yym576 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv575) + } else if z.HasExtensions() && z.DecExt(yyv578) { + } else if !yym579 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv578) } else { - z.DecFallback(yyv575, false) + z.DecFallback(yyv578, false) } } case "evictionMaxPodGracePeriod": @@ -4273,26 +4307,26 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode if r.TryDecodeAsNil() { x.SystemReserved = nil } else { - yyv581 := &x.SystemReserved - yym582 := z.DecBinary() - _ = yym582 + yyv584 := &x.SystemReserved + yym585 := z.DecBinary() + _ = yym585 if false { - } else if z.HasExtensions() && z.DecExt(yyv581) { + } else if z.HasExtensions() && z.DecExt(yyv584) { } else { - h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv581), d) + h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv584), d) } } case "kubeReserved": if r.TryDecodeAsNil() { x.KubeReserved = nil } else { - yyv583 := &x.KubeReserved - yym584 := z.DecBinary() - _ = yym584 + yyv586 := &x.KubeReserved + yym587 := z.DecBinary() + _ = yym587 if false { - } else if z.HasExtensions() && z.DecExt(yyv583) { + } else if z.HasExtensions() && z.DecExt(yyv586) { } else { - h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv583), d) + h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv586), d) } } case "protectKernelDefaults": @@ -4319,10 +4353,22 @@ func (x *KubeletConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decode } else { x.IPTablesDropBit = int32(r.DecodeInt(32)) } + case "experimentalAllowedUnsafeSysctls": + if r.TryDecodeAsNil() { + x.AllowedUnsafeSysctls = nil + } else { + yyv592 := &x.AllowedUnsafeSysctls + yym593 := z.DecBinary() + _ = yym593 + if false { + } else { + z.F.DecSliceStringX(yyv592, false, d) + } + } default: - z.DecStructFieldNotFound(-1, yys467) - } // end switch yys467 - } // end for yyj467 + z.DecStructFieldNotFound(-1, yys470) + } // end switch yys470 + } // end for yyj470 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -4330,16 +4376,16 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj589 int - var yyb589 bool - var yyhl589 bool = l >= 0 - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + var yyj594 int + var yyb594 bool + var yyhl594 bool = l >= 0 + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4349,13 +4395,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.Kind = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4365,13 +4411,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.APIVersion = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4381,13 +4427,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.PodManifestPath = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4395,24 +4441,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.SyncFrequency = pkg1_unversioned.Duration{} } else { - yyv593 := &x.SyncFrequency - yym594 := z.DecBinary() - _ = yym594 + yyv598 := &x.SyncFrequency + yym599 := z.DecBinary() + _ = yym599 if false { - } else if z.HasExtensions() && z.DecExt(yyv593) { - } else if !yym594 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv593) + } else if z.HasExtensions() && z.DecExt(yyv598) { + } else if !yym599 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv598) } else { - z.DecFallback(yyv593, false) + z.DecFallback(yyv598, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4420,24 +4466,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.FileCheckFrequency = pkg1_unversioned.Duration{} } else { - yyv595 := &x.FileCheckFrequency - yym596 := z.DecBinary() - _ = yym596 + yyv600 := &x.FileCheckFrequency + yym601 := z.DecBinary() + _ = yym601 if false { - } else if z.HasExtensions() && z.DecExt(yyv595) { - } else if !yym596 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv595) + } else if z.HasExtensions() && z.DecExt(yyv600) { + } else if !yym601 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv600) } else { - z.DecFallback(yyv595, false) + z.DecFallback(yyv600, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4445,24 +4491,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.HTTPCheckFrequency = pkg1_unversioned.Duration{} } else { - yyv597 := &x.HTTPCheckFrequency - yym598 := z.DecBinary() - _ = yym598 + yyv602 := &x.HTTPCheckFrequency + yym603 := z.DecBinary() + _ = yym603 if false { - } else if z.HasExtensions() && z.DecExt(yyv597) { - } else if !yym598 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv597) + } else if z.HasExtensions() && z.DecExt(yyv602) { + } else if !yym603 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv602) } else { - z.DecFallback(yyv597, false) + z.DecFallback(yyv602, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4472,13 +4518,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ManifestURL = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4488,13 +4534,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ManifestURLHeader = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4504,13 +4550,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EnableServer = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4520,13 +4566,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.Address = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4536,13 +4582,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.Port = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4552,13 +4598,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ReadOnlyPort = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4568,13 +4614,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.TLSCertFile = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4584,13 +4630,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.TLSPrivateKeyFile = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4600,13 +4646,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CertDirectory = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4616,13 +4662,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.HostnameOverride = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4632,13 +4678,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.PodInfraContainerImage = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4648,13 +4694,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.DockerEndpoint = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4664,13 +4710,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RootDirectory = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4680,13 +4726,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.SeccompProfileRoot = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4696,13 +4742,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.AllowPrivileged = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4710,21 +4756,21 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.HostNetworkSources = nil } else { - yyv614 := &x.HostNetworkSources - yym615 := z.DecBinary() - _ = yym615 + yyv619 := &x.HostNetworkSources + yym620 := z.DecBinary() + _ = yym620 if false { } else { - z.F.DecSliceStringX(yyv614, false, d) + z.F.DecSliceStringX(yyv619, false, d) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4732,21 +4778,21 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.HostPIDSources = nil } else { - yyv616 := &x.HostPIDSources - yym617 := z.DecBinary() - _ = yym617 + yyv621 := &x.HostPIDSources + yym622 := z.DecBinary() + _ = yym622 if false { } else { - z.F.DecSliceStringX(yyv616, false, d) + z.F.DecSliceStringX(yyv621, false, d) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4754,21 +4800,21 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.HostIPCSources = nil } else { - yyv618 := &x.HostIPCSources - yym619 := z.DecBinary() - _ = yym619 + yyv623 := &x.HostIPCSources + yym624 := z.DecBinary() + _ = yym624 if false { } else { - z.F.DecSliceStringX(yyv618, false, d) + z.F.DecSliceStringX(yyv623, false, d) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4778,13 +4824,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RegistryPullQPS = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4794,13 +4840,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RegistryBurst = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4810,13 +4856,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EventRecordQPS = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4826,13 +4872,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EventBurst = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4842,13 +4888,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EnableDebuggingHandlers = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4856,24 +4902,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.MinimumGCAge = pkg1_unversioned.Duration{} } else { - yyv625 := &x.MinimumGCAge - yym626 := z.DecBinary() - _ = yym626 + yyv630 := &x.MinimumGCAge + yym631 := z.DecBinary() + _ = yym631 if false { - } else if z.HasExtensions() && z.DecExt(yyv625) { - } else if !yym626 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv625) + } else if z.HasExtensions() && z.DecExt(yyv630) { + } else if !yym631 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv630) } else { - z.DecFallback(yyv625, false) + z.DecFallback(yyv630, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4883,13 +4929,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.MaxPerPodContainerCount = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4899,13 +4945,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.MaxContainerCount = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4915,13 +4961,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CAdvisorPort = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4931,13 +4977,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.HealthzPort = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4947,13 +4993,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.HealthzBindAddress = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4963,13 +5009,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.OOMScoreAdj = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4979,13 +5025,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RegisterNode = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -4995,13 +5041,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ClusterDomain = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5011,13 +5057,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.MasterServiceNamespace = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5027,13 +5073,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ClusterDNS = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5041,24 +5087,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.StreamingConnectionIdleTimeout = pkg1_unversioned.Duration{} } else { - yyv637 := &x.StreamingConnectionIdleTimeout - yym638 := z.DecBinary() - _ = yym638 + yyv642 := &x.StreamingConnectionIdleTimeout + yym643 := z.DecBinary() + _ = yym643 if false { - } else if z.HasExtensions() && z.DecExt(yyv637) { - } else if !yym638 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv637) + } else if z.HasExtensions() && z.DecExt(yyv642) { + } else if !yym643 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv642) } else { - z.DecFallback(yyv637, false) + z.DecFallback(yyv642, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5066,24 +5112,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.NodeStatusUpdateFrequency = pkg1_unversioned.Duration{} } else { - yyv639 := &x.NodeStatusUpdateFrequency - yym640 := z.DecBinary() - _ = yym640 + yyv644 := &x.NodeStatusUpdateFrequency + yym645 := z.DecBinary() + _ = yym645 if false { - } else if z.HasExtensions() && z.DecExt(yyv639) { - } else if !yym640 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv639) + } else if z.HasExtensions() && z.DecExt(yyv644) { + } else if !yym645 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv644) } else { - z.DecFallback(yyv639, false) + z.DecFallback(yyv644, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5091,80 +5137,7 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.ImageMinimumGCAge = pkg1_unversioned.Duration{} } else { - yyv641 := &x.ImageMinimumGCAge - yym642 := z.DecBinary() - _ = yym642 - if false { - } else if z.HasExtensions() && z.DecExt(yyv641) { - } else if !yym642 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv641) - } else { - z.DecFallback(yyv641, false) - } - } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l - } else { - yyb589 = r.CheckBreak() - } - if yyb589 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.ImageGCHighThresholdPercent = 0 - } else { - x.ImageGCHighThresholdPercent = int32(r.DecodeInt(32)) - } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l - } else { - yyb589 = r.CheckBreak() - } - if yyb589 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.ImageGCLowThresholdPercent = 0 - } else { - x.ImageGCLowThresholdPercent = int32(r.DecodeInt(32)) - } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l - } else { - yyb589 = r.CheckBreak() - } - if yyb589 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.LowDiskSpaceThresholdMB = 0 - } else { - x.LowDiskSpaceThresholdMB = int32(r.DecodeInt(32)) - } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l - } else { - yyb589 = r.CheckBreak() - } - if yyb589 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{} - } else { - yyv646 := &x.VolumeStatsAggPeriod + yyv646 := &x.ImageMinimumGCAge yym647 := z.DecBinary() _ = yym647 if false { @@ -5175,13 +5148,86 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco z.DecFallback(yyv646, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ImageGCHighThresholdPercent = 0 + } else { + x.ImageGCHighThresholdPercent = int32(r.DecodeInt(32)) + } + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l + } else { + yyb594 = r.CheckBreak() + } + if yyb594 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.ImageGCLowThresholdPercent = 0 + } else { + x.ImageGCLowThresholdPercent = int32(r.DecodeInt(32)) + } + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l + } else { + yyb594 = r.CheckBreak() + } + if yyb594 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.LowDiskSpaceThresholdMB = 0 + } else { + x.LowDiskSpaceThresholdMB = int32(r.DecodeInt(32)) + } + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l + } else { + yyb594 = r.CheckBreak() + } + if yyb594 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.VolumeStatsAggPeriod = pkg1_unversioned.Duration{} + } else { + yyv651 := &x.VolumeStatsAggPeriod + yym652 := z.DecBinary() + _ = yym652 + if false { + } else if z.HasExtensions() && z.DecExt(yyv651) { + } else if !yym652 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv651) + } else { + z.DecFallback(yyv651, false) + } + } + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l + } else { + yyb594 = r.CheckBreak() + } + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5191,13 +5237,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.NetworkPluginName = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5207,13 +5253,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.NetworkPluginMTU = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5223,13 +5269,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.NetworkPluginDir = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5239,13 +5285,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.VolumePluginDir = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5255,13 +5301,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CloudProvider = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5271,13 +5317,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CloudConfigFile = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5287,13 +5333,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.KubeletCgroups = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5303,13 +5349,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CgroupsPerQOS = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5319,13 +5365,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RuntimeCgroups = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5335,13 +5381,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.SystemCgroups = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5351,13 +5397,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CgroupRoot = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5367,13 +5413,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ContainerRuntime = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5383,13 +5429,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RemoteRuntimeEndpoint = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5399,13 +5445,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RemoteImageEndpoint = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5413,24 +5459,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.RuntimeRequestTimeout = pkg1_unversioned.Duration{} } else { - yyv662 := &x.RuntimeRequestTimeout - yym663 := z.DecBinary() - _ = yym663 + yyv667 := &x.RuntimeRequestTimeout + yym668 := z.DecBinary() + _ = yym668 if false { - } else if z.HasExtensions() && z.DecExt(yyv662) { - } else if !yym663 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv662) + } else if z.HasExtensions() && z.DecExt(yyv667) { + } else if !yym668 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv667) } else { - z.DecFallback(yyv662, false) + z.DecFallback(yyv667, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5440,13 +5486,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RktPath = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5456,13 +5502,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RktAPIEndpoint = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5472,13 +5518,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RktStage1Image = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5488,13 +5534,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.LockFilePath = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5504,13 +5550,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ExitOnLockContention = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5520,13 +5566,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ConfigureCBR0 = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5536,13 +5582,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.HairpinMode = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5552,13 +5598,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.BabysitDaemons = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5568,13 +5614,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.MaxPods = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5584,13 +5630,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.NvidiaGPUs = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5600,13 +5646,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.DockerExecHandlerName = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5616,13 +5662,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.PodCIDR = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5632,13 +5678,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ResolverConfig = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5648,13 +5694,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.CPUCFSQuota = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5664,13 +5710,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.Containerized = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5680,13 +5726,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.MaxOpenFiles = int64(r.DecodeInt(64)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5696,13 +5742,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ReconcileCIDR = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5712,13 +5758,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.RegisterSchedulable = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5728,13 +5774,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ContentType = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5744,13 +5790,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.KubeAPIQPS = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5760,13 +5806,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.KubeAPIBurst = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5776,13 +5822,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.SerializeImagePulls = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5792,13 +5838,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ExperimentalFlannelOverlay = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5806,24 +5852,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.OutOfDiskTransitionFrequency = pkg1_unversioned.Duration{} } else { - yyv687 := &x.OutOfDiskTransitionFrequency - yym688 := z.DecBinary() - _ = yym688 + yyv692 := &x.OutOfDiskTransitionFrequency + yym693 := z.DecBinary() + _ = yym693 if false { - } else if z.HasExtensions() && z.DecExt(yyv687) { - } else if !yym688 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv687) + } else if z.HasExtensions() && z.DecExt(yyv692) { + } else if !yym693 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv692) } else { - z.DecFallback(yyv687, false) + z.DecFallback(yyv692, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5833,13 +5879,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.NodeIP = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5847,21 +5893,21 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.NodeLabels = nil } else { - yyv690 := &x.NodeLabels - yym691 := z.DecBinary() - _ = yym691 + yyv695 := &x.NodeLabels + yym696 := z.DecBinary() + _ = yym696 if false { } else { - z.F.DecMapStringStringX(yyv690, false, d) + z.F.DecMapStringStringX(yyv695, false, d) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5871,13 +5917,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.NonMasqueradeCIDR = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5887,13 +5933,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EnableCustomMetrics = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5903,13 +5949,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EvictionHard = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5919,13 +5965,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EvictionSoft = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5935,13 +5981,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EvictionSoftGracePeriod = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5949,24 +5995,24 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.EvictionPressureTransitionPeriod = pkg1_unversioned.Duration{} } else { - yyv697 := &x.EvictionPressureTransitionPeriod - yym698 := z.DecBinary() - _ = yym698 + yyv702 := &x.EvictionPressureTransitionPeriod + yym703 := z.DecBinary() + _ = yym703 if false { - } else if z.HasExtensions() && z.DecExt(yyv697) { - } else if !yym698 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv697) + } else if z.HasExtensions() && z.DecExt(yyv702) { + } else if !yym703 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv702) } else { - z.DecFallback(yyv697, false) + z.DecFallback(yyv702, false) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5976,13 +6022,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EvictionMaxPodGracePeriod = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -5992,13 +6038,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EvictionMinimumReclaim = string(r.DecodeString()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6008,13 +6054,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.PodsPerCore = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6024,13 +6070,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.EnableControllerAttachDetach = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6038,22 +6084,22 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.SystemReserved = nil } else { - yyv703 := &x.SystemReserved - yym704 := z.DecBinary() - _ = yym704 + yyv708 := &x.SystemReserved + yym709 := z.DecBinary() + _ = yym709 if false { - } else if z.HasExtensions() && z.DecExt(yyv703) { + } else if z.HasExtensions() && z.DecExt(yyv708) { } else { - h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv703), d) + h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv708), d) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6061,22 +6107,22 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco if r.TryDecodeAsNil() { x.KubeReserved = nil } else { - yyv705 := &x.KubeReserved - yym706 := z.DecBinary() - _ = yym706 + yyv710 := &x.KubeReserved + yym711 := z.DecBinary() + _ = yym711 if false { - } else if z.HasExtensions() && z.DecExt(yyv705) { + } else if z.HasExtensions() && z.DecExt(yyv710) { } else { - h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv705), d) + h.decconfig_ConfigurationMap((*pkg2_config.ConfigurationMap)(yyv710), d) } } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6086,13 +6132,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.ProtectKernelDefaults = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6102,13 +6148,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.MakeIPTablesUtilChains = bool(r.DecodeBool()) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6118,13 +6164,13 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.IPTablesMasqueradeBit = int32(r.DecodeInt(32)) } - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l } else { - yyb589 = r.CheckBreak() + yyb594 = r.CheckBreak() } - if yyb589 { + if yyb594 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6134,18 +6180,40 @@ func (x *KubeletConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Deco } else { x.IPTablesDropBit = int32(r.DecodeInt(32)) } - for { - yyj589++ - if yyhl589 { - yyb589 = yyj589 > l + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l + } else { + yyb594 = r.CheckBreak() + } + if yyb594 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.AllowedUnsafeSysctls = nil + } else { + yyv716 := &x.AllowedUnsafeSysctls + yym717 := z.DecBinary() + _ = yym717 + if false { } else { - yyb589 = r.CheckBreak() + z.F.DecSliceStringX(yyv716, false, d) } - if yyb589 { + } + for { + yyj594++ + if yyhl594 { + yyb594 = yyj594 > l + } else { + yyb594 = r.CheckBreak() + } + if yyb594 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj589-1, "") + z.DecStructFieldNotFound(yyj594-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -6157,36 +6225,36 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym711 := z.EncBinary() - _ = yym711 + yym718 := z.EncBinary() + _ = yym718 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep712 := !z.EncBinary() - yy2arr712 := z.EncBasicHandle().StructToArray - var yyq712 [14]bool - _, _, _ = yysep712, yyq712, yy2arr712 - const yyr712 bool = false - yyq712[0] = x.Kind != "" - yyq712[1] = x.APIVersion != "" - var yynn712 int - if yyr712 || yy2arr712 { + yysep719 := !z.EncBinary() + yy2arr719 := z.EncBasicHandle().StructToArray + var yyq719 [14]bool + _, _, _ = yysep719, yyq719, yy2arr719 + const yyr719 bool = false + yyq719[0] = x.Kind != "" + yyq719[1] = x.APIVersion != "" + var yynn719 int + if yyr719 || yy2arr719 { r.EncodeArrayStart(14) } else { - yynn712 = 12 - for _, b := range yyq712 { + yynn719 = 12 + for _, b := range yyq719 { if b { - yynn712++ + yynn719++ } } - r.EncodeMapStart(yynn712) - yynn712 = 0 + r.EncodeMapStart(yynn719) + yynn719 = 0 } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq712[0] { - yym714 := z.EncBinary() - _ = yym714 + if yyq719[0] { + yym721 := z.EncBinary() + _ = yym721 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -6195,23 +6263,23 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq712[0] { + if yyq719[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym715 := z.EncBinary() - _ = yym715 + yym722 := z.EncBinary() + _ = yym722 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq712[1] { - yym717 := z.EncBinary() - _ = yym717 + if yyq719[1] { + yym724 := z.EncBinary() + _ = yym724 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -6220,22 +6288,22 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq712[1] { + if yyq719[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym718 := z.EncBinary() - _ = yym718 + yym725 := z.EncBinary() + _ = yym725 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym720 := z.EncBinary() - _ = yym720 + yym727 := z.EncBinary() + _ = yym727 if false { } else { r.EncodeInt(int64(x.Port)) @@ -6244,17 +6312,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("port")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym721 := z.EncBinary() - _ = yym721 + yym728 := z.EncBinary() + _ = yym728 if false { } else { r.EncodeInt(int64(x.Port)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym723 := z.EncBinary() - _ = yym723 + yym730 := z.EncBinary() + _ = yym730 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Address)) @@ -6263,17 +6331,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("address")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym724 := z.EncBinary() - _ = yym724 + yym731 := z.EncBinary() + _ = yym731 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Address)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym726 := z.EncBinary() - _ = yym726 + yym733 := z.EncBinary() + _ = yym733 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.AlgorithmProvider)) @@ -6282,17 +6350,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("algorithmProvider")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym727 := z.EncBinary() - _ = yym727 + yym734 := z.EncBinary() + _ = yym734 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.AlgorithmProvider)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym729 := z.EncBinary() - _ = yym729 + yym736 := z.EncBinary() + _ = yym736 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PolicyConfigFile)) @@ -6301,17 +6369,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("policyConfigFile")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym730 := z.EncBinary() - _ = yym730 + yym737 := z.EncBinary() + _ = yym737 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PolicyConfigFile)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym732 := z.EncBinary() - _ = yym732 + yym739 := z.EncBinary() + _ = yym739 if false { } else { r.EncodeBool(bool(x.EnableProfiling)) @@ -6320,17 +6388,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("enableProfiling")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym733 := z.EncBinary() - _ = yym733 + yym740 := z.EncBinary() + _ = yym740 if false { } else { r.EncodeBool(bool(x.EnableProfiling)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym735 := z.EncBinary() - _ = yym735 + yym742 := z.EncBinary() + _ = yym742 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ContentType)) @@ -6339,17 +6407,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("contentType")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym736 := z.EncBinary() - _ = yym736 + yym743 := z.EncBinary() + _ = yym743 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ContentType)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym738 := z.EncBinary() - _ = yym738 + yym745 := z.EncBinary() + _ = yym745 if false { } else { r.EncodeFloat32(float32(x.KubeAPIQPS)) @@ -6358,17 +6426,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym739 := z.EncBinary() - _ = yym739 + yym746 := z.EncBinary() + _ = yym746 if false { } else { r.EncodeFloat32(float32(x.KubeAPIQPS)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym741 := z.EncBinary() - _ = yym741 + yym748 := z.EncBinary() + _ = yym748 if false { } else { r.EncodeInt(int64(x.KubeAPIBurst)) @@ -6377,17 +6445,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym742 := z.EncBinary() - _ = yym742 + yym749 := z.EncBinary() + _ = yym749 if false { } else { r.EncodeInt(int64(x.KubeAPIBurst)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym744 := z.EncBinary() - _ = yym744 + yym751 := z.EncBinary() + _ = yym751 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName)) @@ -6396,17 +6464,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("schedulerName")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym745 := z.EncBinary() - _ = yym745 + yym752 := z.EncBinary() + _ = yym752 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.SchedulerName)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym747 := z.EncBinary() - _ = yym747 + yym754 := z.EncBinary() + _ = yym754 if false { } else { r.EncodeInt(int64(x.HardPodAffinitySymmetricWeight)) @@ -6415,17 +6483,17 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("hardPodAffinitySymmetricWeight")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym748 := z.EncBinary() - _ = yym748 + yym755 := z.EncBinary() + _ = yym755 if false { } else { r.EncodeInt(int64(x.HardPodAffinitySymmetricWeight)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym750 := z.EncBinary() - _ = yym750 + yym757 := z.EncBinary() + _ = yym757 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.FailureDomains)) @@ -6434,25 +6502,25 @@ func (x *KubeSchedulerConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("failureDomains")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym751 := z.EncBinary() - _ = yym751 + yym758 := z.EncBinary() + _ = yym758 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.FailureDomains)) } } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy753 := &x.LeaderElection - yy753.CodecEncodeSelf(e) + yy760 := &x.LeaderElection + yy760.CodecEncodeSelf(e) } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("leaderElection")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy754 := &x.LeaderElection - yy754.CodecEncodeSelf(e) + yy761 := &x.LeaderElection + yy761.CodecEncodeSelf(e) } - if yyr712 || yy2arr712 { + if yyr719 || yy2arr719 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -6465,25 +6533,25 @@ func (x *KubeSchedulerConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym755 := z.DecBinary() - _ = yym755 + yym762 := z.DecBinary() + _ = yym762 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct756 := r.ContainerType() - if yyct756 == codecSelferValueTypeMap1234 { - yyl756 := r.ReadMapStart() - if yyl756 == 0 { + yyct763 := r.ContainerType() + if yyct763 == codecSelferValueTypeMap1234 { + yyl763 := r.ReadMapStart() + if yyl763 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl756, d) + x.codecDecodeSelfFromMap(yyl763, d) } - } else if yyct756 == codecSelferValueTypeArray1234 { - yyl756 := r.ReadArrayStart() - if yyl756 == 0 { + } else if yyct763 == codecSelferValueTypeArray1234 { + yyl763 := r.ReadArrayStart() + if yyl763 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl756, d) + x.codecDecodeSelfFromArray(yyl763, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -6495,12 +6563,12 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978. var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys757Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys757Slc - var yyhl757 bool = l >= 0 - for yyj757 := 0; ; yyj757++ { - if yyhl757 { - if yyj757 >= l { + var yys764Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys764Slc + var yyhl764 bool = l >= 0 + for yyj764 := 0; ; yyj764++ { + if yyhl764 { + if yyj764 >= l { break } } else { @@ -6509,10 +6577,10 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978. } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys757Slc = r.DecodeBytes(yys757Slc, true, true) - yys757 := string(yys757Slc) + yys764Slc = r.DecodeBytes(yys764Slc, true, true) + yys764 := string(yys764Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys757 { + switch yys764 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -6595,13 +6663,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromMap(l int, d *codec1978. if r.TryDecodeAsNil() { x.LeaderElection = LeaderElectionConfiguration{} } else { - yyv771 := &x.LeaderElection - yyv771.CodecDecodeSelf(d) + yyv778 := &x.LeaderElection + yyv778.CodecDecodeSelf(d) } default: - z.DecStructFieldNotFound(-1, yys757) - } // end switch yys757 - } // end for yyj757 + z.DecStructFieldNotFound(-1, yys764) + } // end switch yys764 + } // end for yyj764 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -6609,16 +6677,16 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj772 int - var yyb772 bool - var yyhl772 bool = l >= 0 - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + var yyj779 int + var yyb779 bool + var yyhl779 bool = l >= 0 + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6628,13 +6696,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.Kind = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6644,13 +6712,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.APIVersion = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6660,13 +6728,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.Port = int32(r.DecodeInt(32)) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6676,13 +6744,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.Address = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6692,13 +6760,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.AlgorithmProvider = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6708,13 +6776,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.PolicyConfigFile = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6724,13 +6792,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.EnableProfiling = bool(r.DecodeBool()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6740,13 +6808,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.ContentType = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6756,13 +6824,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.KubeAPIQPS = float32(r.DecodeFloat(true)) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6772,13 +6840,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.KubeAPIBurst = int32(r.DecodeInt(32)) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6788,13 +6856,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.SchedulerName = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6804,13 +6872,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.HardPodAffinitySymmetricWeight = int(r.DecodeInt(codecSelferBitsize1234)) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6820,13 +6888,13 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 } else { x.FailureDomains = string(r.DecodeString()) } - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -6834,21 +6902,21 @@ func (x *KubeSchedulerConfiguration) codecDecodeSelfFromArray(l int, d *codec197 if r.TryDecodeAsNil() { x.LeaderElection = LeaderElectionConfiguration{} } else { - yyv786 := &x.LeaderElection - yyv786.CodecDecodeSelf(d) + yyv793 := &x.LeaderElection + yyv793.CodecDecodeSelf(d) } for { - yyj772++ - if yyhl772 { - yyb772 = yyj772 > l + yyj779++ + if yyhl779 { + yyb779 = yyj779 > l } else { - yyb772 = r.CheckBreak() + yyb779 = r.CheckBreak() } - if yyb772 { + if yyb779 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj772-1, "") + z.DecStructFieldNotFound(yyj779-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -6860,33 +6928,33 @@ func (x *LeaderElectionConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym787 := z.EncBinary() - _ = yym787 + yym794 := z.EncBinary() + _ = yym794 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep788 := !z.EncBinary() - yy2arr788 := z.EncBasicHandle().StructToArray - var yyq788 [4]bool - _, _, _ = yysep788, yyq788, yy2arr788 - const yyr788 bool = false - var yynn788 int - if yyr788 || yy2arr788 { + yysep795 := !z.EncBinary() + yy2arr795 := z.EncBasicHandle().StructToArray + var yyq795 [4]bool + _, _, _ = yysep795, yyq795, yy2arr795 + const yyr795 bool = false + var yynn795 int + if yyr795 || yy2arr795 { r.EncodeArrayStart(4) } else { - yynn788 = 4 - for _, b := range yyq788 { + yynn795 = 4 + for _, b := range yyq795 { if b { - yynn788++ + yynn795++ } } - r.EncodeMapStart(yynn788) - yynn788 = 0 + r.EncodeMapStart(yynn795) + yynn795 = 0 } - if yyr788 || yy2arr788 { + if yyr795 || yy2arr795 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym790 := z.EncBinary() - _ = yym790 + yym797 := z.EncBinary() + _ = yym797 if false { } else { r.EncodeBool(bool(x.LeaderElect)) @@ -6895,57 +6963,16 @@ func (x *LeaderElectionConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("leaderElect")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym791 := z.EncBinary() - _ = yym791 + yym798 := z.EncBinary() + _ = yym798 if false { } else { r.EncodeBool(bool(x.LeaderElect)) } } - if yyr788 || yy2arr788 { + if yyr795 || yy2arr795 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy793 := &x.LeaseDuration - yym794 := z.EncBinary() - _ = yym794 - if false { - } else if z.HasExtensions() && z.EncExt(yy793) { - } else if !yym794 && z.IsJSONHandle() { - z.EncJSONMarshal(yy793) - } else { - z.EncFallback(yy793) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("leaseDuration")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy795 := &x.LeaseDuration - yym796 := z.EncBinary() - _ = yym796 - if false { - } else if z.HasExtensions() && z.EncExt(yy795) { - } else if !yym796 && z.IsJSONHandle() { - z.EncJSONMarshal(yy795) - } else { - z.EncFallback(yy795) - } - } - if yyr788 || yy2arr788 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy798 := &x.RenewDeadline - yym799 := z.EncBinary() - _ = yym799 - if false { - } else if z.HasExtensions() && z.EncExt(yy798) { - } else if !yym799 && z.IsJSONHandle() { - z.EncJSONMarshal(yy798) - } else { - z.EncFallback(yy798) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("renewDeadline")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy800 := &x.RenewDeadline + yy800 := &x.LeaseDuration yym801 := z.EncBinary() _ = yym801 if false { @@ -6955,24 +6982,24 @@ func (x *LeaderElectionConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { } else { z.EncFallback(yy800) } - } - if yyr788 || yy2arr788 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy803 := &x.RetryPeriod - yym804 := z.EncBinary() - _ = yym804 - if false { - } else if z.HasExtensions() && z.EncExt(yy803) { - } else if !yym804 && z.IsJSONHandle() { - z.EncJSONMarshal(yy803) - } else { - z.EncFallback(yy803) - } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("retryPeriod")) + r.EncodeString(codecSelferC_UTF81234, string("leaseDuration")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy805 := &x.RetryPeriod + yy802 := &x.LeaseDuration + yym803 := z.EncBinary() + _ = yym803 + if false { + } else if z.HasExtensions() && z.EncExt(yy802) { + } else if !yym803 && z.IsJSONHandle() { + z.EncJSONMarshal(yy802) + } else { + z.EncFallback(yy802) + } + } + if yyr795 || yy2arr795 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy805 := &x.RenewDeadline yym806 := z.EncBinary() _ = yym806 if false { @@ -6982,8 +7009,49 @@ func (x *LeaderElectionConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { } else { z.EncFallback(yy805) } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("renewDeadline")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy807 := &x.RenewDeadline + yym808 := z.EncBinary() + _ = yym808 + if false { + } else if z.HasExtensions() && z.EncExt(yy807) { + } else if !yym808 && z.IsJSONHandle() { + z.EncJSONMarshal(yy807) + } else { + z.EncFallback(yy807) + } } - if yyr788 || yy2arr788 { + if yyr795 || yy2arr795 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy810 := &x.RetryPeriod + yym811 := z.EncBinary() + _ = yym811 + if false { + } else if z.HasExtensions() && z.EncExt(yy810) { + } else if !yym811 && z.IsJSONHandle() { + z.EncJSONMarshal(yy810) + } else { + z.EncFallback(yy810) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("retryPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy812 := &x.RetryPeriod + yym813 := z.EncBinary() + _ = yym813 + if false { + } else if z.HasExtensions() && z.EncExt(yy812) { + } else if !yym813 && z.IsJSONHandle() { + z.EncJSONMarshal(yy812) + } else { + z.EncFallback(yy812) + } + } + if yyr795 || yy2arr795 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -6996,25 +7064,25 @@ func (x *LeaderElectionConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym807 := z.DecBinary() - _ = yym807 + yym814 := z.DecBinary() + _ = yym814 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct808 := r.ContainerType() - if yyct808 == codecSelferValueTypeMap1234 { - yyl808 := r.ReadMapStart() - if yyl808 == 0 { + yyct815 := r.ContainerType() + if yyct815 == codecSelferValueTypeMap1234 { + yyl815 := r.ReadMapStart() + if yyl815 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl808, d) + x.codecDecodeSelfFromMap(yyl815, d) } - } else if yyct808 == codecSelferValueTypeArray1234 { - yyl808 := r.ReadArrayStart() - if yyl808 == 0 { + } else if yyct815 == codecSelferValueTypeArray1234 { + yyl815 := r.ReadArrayStart() + if yyl815 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl808, d) + x.codecDecodeSelfFromArray(yyl815, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -7026,12 +7094,12 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromMap(l int, d *codec1978 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys809Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys809Slc - var yyhl809 bool = l >= 0 - for yyj809 := 0; ; yyj809++ { - if yyhl809 { - if yyj809 >= l { + var yys816Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys816Slc + var yyhl816 bool = l >= 0 + for yyj816 := 0; ; yyj816++ { + if yyhl816 { + if yyj816 >= l { break } } else { @@ -7040,10 +7108,10 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromMap(l int, d *codec1978 } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys809Slc = r.DecodeBytes(yys809Slc, true, true) - yys809 := string(yys809Slc) + yys816Slc = r.DecodeBytes(yys816Slc, true, true) + yys816 := string(yys816Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys809 { + switch yys816 { case "leaderElect": if r.TryDecodeAsNil() { x.LeaderElect = false @@ -7054,51 +7122,51 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromMap(l int, d *codec1978 if r.TryDecodeAsNil() { x.LeaseDuration = pkg1_unversioned.Duration{} } else { - yyv811 := &x.LeaseDuration - yym812 := z.DecBinary() - _ = yym812 + yyv818 := &x.LeaseDuration + yym819 := z.DecBinary() + _ = yym819 if false { - } else if z.HasExtensions() && z.DecExt(yyv811) { - } else if !yym812 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv811) + } else if z.HasExtensions() && z.DecExt(yyv818) { + } else if !yym819 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv818) } else { - z.DecFallback(yyv811, false) + z.DecFallback(yyv818, false) } } case "renewDeadline": if r.TryDecodeAsNil() { x.RenewDeadline = pkg1_unversioned.Duration{} } else { - yyv813 := &x.RenewDeadline - yym814 := z.DecBinary() - _ = yym814 + yyv820 := &x.RenewDeadline + yym821 := z.DecBinary() + _ = yym821 if false { - } else if z.HasExtensions() && z.DecExt(yyv813) { - } else if !yym814 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv813) + } else if z.HasExtensions() && z.DecExt(yyv820) { + } else if !yym821 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv820) } else { - z.DecFallback(yyv813, false) + z.DecFallback(yyv820, false) } } case "retryPeriod": if r.TryDecodeAsNil() { x.RetryPeriod = pkg1_unversioned.Duration{} } else { - yyv815 := &x.RetryPeriod - yym816 := z.DecBinary() - _ = yym816 + yyv822 := &x.RetryPeriod + yym823 := z.DecBinary() + _ = yym823 if false { - } else if z.HasExtensions() && z.DecExt(yyv815) { - } else if !yym816 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv815) + } else if z.HasExtensions() && z.DecExt(yyv822) { + } else if !yym823 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv822) } else { - z.DecFallback(yyv815, false) + z.DecFallback(yyv822, false) } } default: - z.DecStructFieldNotFound(-1, yys809) - } // end switch yys809 - } // end for yyj809 + z.DecStructFieldNotFound(-1, yys816) + } // end switch yys816 + } // end for yyj816 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -7106,16 +7174,16 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromArray(l int, d *codec19 var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj817 int - var yyb817 bool - var yyhl817 bool = l >= 0 - yyj817++ - if yyhl817 { - yyb817 = yyj817 > l + var yyj824 int + var yyb824 bool + var yyhl824 bool = l >= 0 + yyj824++ + if yyhl824 { + yyb824 = yyj824 > l } else { - yyb817 = r.CheckBreak() + yyb824 = r.CheckBreak() } - if yyb817 { + if yyb824 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -7125,13 +7193,13 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromArray(l int, d *codec19 } else { x.LeaderElect = bool(r.DecodeBool()) } - yyj817++ - if yyhl817 { - yyb817 = yyj817 > l + yyj824++ + if yyhl824 { + yyb824 = yyj824 > l } else { - yyb817 = r.CheckBreak() + yyb824 = r.CheckBreak() } - if yyb817 { + if yyb824 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -7139,24 +7207,24 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromArray(l int, d *codec19 if r.TryDecodeAsNil() { x.LeaseDuration = pkg1_unversioned.Duration{} } else { - yyv819 := &x.LeaseDuration - yym820 := z.DecBinary() - _ = yym820 + yyv826 := &x.LeaseDuration + yym827 := z.DecBinary() + _ = yym827 if false { - } else if z.HasExtensions() && z.DecExt(yyv819) { - } else if !yym820 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv819) + } else if z.HasExtensions() && z.DecExt(yyv826) { + } else if !yym827 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv826) } else { - z.DecFallback(yyv819, false) + z.DecFallback(yyv826, false) } } - yyj817++ - if yyhl817 { - yyb817 = yyj817 > l + yyj824++ + if yyhl824 { + yyb824 = yyj824 > l } else { - yyb817 = r.CheckBreak() + yyb824 = r.CheckBreak() } - if yyb817 { + if yyb824 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -7164,24 +7232,24 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromArray(l int, d *codec19 if r.TryDecodeAsNil() { x.RenewDeadline = pkg1_unversioned.Duration{} } else { - yyv821 := &x.RenewDeadline - yym822 := z.DecBinary() - _ = yym822 + yyv828 := &x.RenewDeadline + yym829 := z.DecBinary() + _ = yym829 if false { - } else if z.HasExtensions() && z.DecExt(yyv821) { - } else if !yym822 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv821) + } else if z.HasExtensions() && z.DecExt(yyv828) { + } else if !yym829 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv828) } else { - z.DecFallback(yyv821, false) + z.DecFallback(yyv828, false) } } - yyj817++ - if yyhl817 { - yyb817 = yyj817 > l + yyj824++ + if yyhl824 { + yyb824 = yyj824 > l } else { - yyb817 = r.CheckBreak() + yyb824 = r.CheckBreak() } - if yyb817 { + if yyb824 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -7189,29 +7257,29 @@ func (x *LeaderElectionConfiguration) codecDecodeSelfFromArray(l int, d *codec19 if r.TryDecodeAsNil() { x.RetryPeriod = pkg1_unversioned.Duration{} } else { - yyv823 := &x.RetryPeriod - yym824 := z.DecBinary() - _ = yym824 + yyv830 := &x.RetryPeriod + yym831 := z.DecBinary() + _ = yym831 if false { - } else if z.HasExtensions() && z.DecExt(yyv823) { - } else if !yym824 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv823) + } else if z.HasExtensions() && z.DecExt(yyv830) { + } else if !yym831 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv830) } else { - z.DecFallback(yyv823, false) + z.DecFallback(yyv830, false) } } for { - yyj817++ - if yyhl817 { - yyb817 = yyj817 > l + yyj824++ + if yyhl824 { + yyb824 = yyj824 > l } else { - yyb817 = r.CheckBreak() + yyb824 = r.CheckBreak() } - if yyb817 { + if yyb824 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj817-1, "") + z.DecStructFieldNotFound(yyj824-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -7223,36 +7291,36 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode if x == nil { r.EncodeNil() } else { - yym825 := z.EncBinary() - _ = yym825 + yym832 := z.EncBinary() + _ = yym832 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep826 := !z.EncBinary() - yy2arr826 := z.EncBasicHandle().StructToArray - var yyq826 [59]bool - _, _, _ = yysep826, yyq826, yy2arr826 - const yyr826 bool = false - yyq826[0] = x.Kind != "" - yyq826[1] = x.APIVersion != "" - var yynn826 int - if yyr826 || yy2arr826 { + yysep833 := !z.EncBinary() + yy2arr833 := z.EncBasicHandle().StructToArray + var yyq833 [59]bool + _, _, _ = yysep833, yyq833, yy2arr833 + const yyr833 bool = false + yyq833[0] = x.Kind != "" + yyq833[1] = x.APIVersion != "" + var yynn833 int + if yyr833 || yy2arr833 { r.EncodeArrayStart(59) } else { - yynn826 = 57 - for _, b := range yyq826 { + yynn833 = 57 + for _, b := range yyq833 { if b { - yynn826++ + yynn833++ } } - r.EncodeMapStart(yynn826) - yynn826 = 0 + r.EncodeMapStart(yynn833) + yynn833 = 0 } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq826[0] { - yym828 := z.EncBinary() - _ = yym828 + if yyq833[0] { + yym835 := z.EncBinary() + _ = yym835 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) @@ -7261,23 +7329,23 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq826[0] { + if yyq833[0] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kind")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym829 := z.EncBinary() - _ = yym829 + yym836 := z.EncBinary() + _ = yym836 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Kind)) } } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - if yyq826[1] { - yym831 := z.EncBinary() - _ = yym831 + if yyq833[1] { + yym838 := z.EncBinary() + _ = yym838 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) @@ -7286,22 +7354,22 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode r.EncodeString(codecSelferC_UTF81234, "") } } else { - if yyq826[1] { + if yyq833[1] { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("apiVersion")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym832 := z.EncBinary() - _ = yym832 + yym839 := z.EncBinary() + _ = yym839 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion)) } } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym834 := z.EncBinary() - _ = yym834 + yym841 := z.EncBinary() + _ = yym841 if false { } else { r.EncodeInt(int64(x.Port)) @@ -7310,17 +7378,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("port")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym835 := z.EncBinary() - _ = yym835 + yym842 := z.EncBinary() + _ = yym842 if false { } else { r.EncodeInt(int64(x.Port)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym837 := z.EncBinary() - _ = yym837 + yym844 := z.EncBinary() + _ = yym844 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Address)) @@ -7329,17 +7397,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("address")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym838 := z.EncBinary() - _ = yym838 + yym845 := z.EncBinary() + _ = yym845 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.Address)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym840 := z.EncBinary() - _ = yym840 + yym847 := z.EncBinary() + _ = yym847 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider)) @@ -7348,17 +7416,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("cloudProvider")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym841 := z.EncBinary() - _ = yym841 + yym848 := z.EncBinary() + _ = yym848 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.CloudProvider)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym843 := z.EncBinary() - _ = yym843 + yym850 := z.EncBinary() + _ = yym850 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile)) @@ -7367,17 +7435,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("cloudConfigFile")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym844 := z.EncBinary() - _ = yym844 + yym851 := z.EncBinary() + _ = yym851 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.CloudConfigFile)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym846 := z.EncBinary() - _ = yym846 + yym853 := z.EncBinary() + _ = yym853 if false { } else { r.EncodeInt(int64(x.ConcurrentEndpointSyncs)) @@ -7386,17 +7454,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentEndpointSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym847 := z.EncBinary() - _ = yym847 + yym854 := z.EncBinary() + _ = yym854 if false { } else { r.EncodeInt(int64(x.ConcurrentEndpointSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym849 := z.EncBinary() - _ = yym849 + yym856 := z.EncBinary() + _ = yym856 if false { } else { r.EncodeInt(int64(x.ConcurrentRSSyncs)) @@ -7405,17 +7473,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentRSSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym850 := z.EncBinary() - _ = yym850 + yym857 := z.EncBinary() + _ = yym857 if false { } else { r.EncodeInt(int64(x.ConcurrentRSSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym852 := z.EncBinary() - _ = yym852 + yym859 := z.EncBinary() + _ = yym859 if false { } else { r.EncodeInt(int64(x.ConcurrentRCSyncs)) @@ -7424,17 +7492,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentRCSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym853 := z.EncBinary() - _ = yym853 + yym860 := z.EncBinary() + _ = yym860 if false { } else { r.EncodeInt(int64(x.ConcurrentRCSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym855 := z.EncBinary() - _ = yym855 + yym862 := z.EncBinary() + _ = yym862 if false { } else { r.EncodeInt(int64(x.ConcurrentServiceSyncs)) @@ -7443,17 +7511,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentServiceSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym856 := z.EncBinary() - _ = yym856 + yym863 := z.EncBinary() + _ = yym863 if false { } else { r.EncodeInt(int64(x.ConcurrentServiceSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym858 := z.EncBinary() - _ = yym858 + yym865 := z.EncBinary() + _ = yym865 if false { } else { r.EncodeInt(int64(x.ConcurrentResourceQuotaSyncs)) @@ -7462,17 +7530,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentResourceQuotaSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym859 := z.EncBinary() - _ = yym859 + yym866 := z.EncBinary() + _ = yym866 if false { } else { r.EncodeInt(int64(x.ConcurrentResourceQuotaSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym861 := z.EncBinary() - _ = yym861 + yym868 := z.EncBinary() + _ = yym868 if false { } else { r.EncodeInt(int64(x.ConcurrentDeploymentSyncs)) @@ -7481,17 +7549,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentDeploymentSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym862 := z.EncBinary() - _ = yym862 + yym869 := z.EncBinary() + _ = yym869 if false { } else { r.EncodeInt(int64(x.ConcurrentDeploymentSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym864 := z.EncBinary() - _ = yym864 + yym871 := z.EncBinary() + _ = yym871 if false { } else { r.EncodeInt(int64(x.ConcurrentDaemonSetSyncs)) @@ -7500,17 +7568,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentDaemonSetSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym865 := z.EncBinary() - _ = yym865 + yym872 := z.EncBinary() + _ = yym872 if false { } else { r.EncodeInt(int64(x.ConcurrentDaemonSetSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym867 := z.EncBinary() - _ = yym867 + yym874 := z.EncBinary() + _ = yym874 if false { } else { r.EncodeInt(int64(x.ConcurrentJobSyncs)) @@ -7519,17 +7587,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentJobSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym868 := z.EncBinary() - _ = yym868 + yym875 := z.EncBinary() + _ = yym875 if false { } else { r.EncodeInt(int64(x.ConcurrentJobSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym870 := z.EncBinary() - _ = yym870 + yym877 := z.EncBinary() + _ = yym877 if false { } else { r.EncodeInt(int64(x.ConcurrentNamespaceSyncs)) @@ -7538,17 +7606,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentNamespaceSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym871 := z.EncBinary() - _ = yym871 + yym878 := z.EncBinary() + _ = yym878 if false { } else { r.EncodeInt(int64(x.ConcurrentNamespaceSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym873 := z.EncBinary() - _ = yym873 + yym880 := z.EncBinary() + _ = yym880 if false { } else { r.EncodeInt(int64(x.ConcurrentSATokenSyncs)) @@ -7557,17 +7625,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentSATokenSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym874 := z.EncBinary() - _ = yym874 + yym881 := z.EncBinary() + _ = yym881 if false { } else { r.EncodeInt(int64(x.ConcurrentSATokenSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym876 := z.EncBinary() - _ = yym876 + yym883 := z.EncBinary() + _ = yym883 if false { } else { r.EncodeInt(int64(x.LookupCacheSizeForRC)) @@ -7576,17 +7644,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("lookupCacheSizeForRC")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym877 := z.EncBinary() - _ = yym877 + yym884 := z.EncBinary() + _ = yym884 if false { } else { r.EncodeInt(int64(x.LookupCacheSizeForRC)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym879 := z.EncBinary() - _ = yym879 + yym886 := z.EncBinary() + _ = yym886 if false { } else { r.EncodeInt(int64(x.LookupCacheSizeForRS)) @@ -7595,17 +7663,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("lookupCacheSizeForRS")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym880 := z.EncBinary() - _ = yym880 + yym887 := z.EncBinary() + _ = yym887 if false { } else { r.EncodeInt(int64(x.LookupCacheSizeForRS)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym882 := z.EncBinary() - _ = yym882 + yym889 := z.EncBinary() + _ = yym889 if false { } else { r.EncodeInt(int64(x.LookupCacheSizeForDaemonSet)) @@ -7614,57 +7682,16 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("lookupCacheSizeForDaemonSet")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym883 := z.EncBinary() - _ = yym883 + yym890 := z.EncBinary() + _ = yym890 if false { } else { r.EncodeInt(int64(x.LookupCacheSizeForDaemonSet)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy885 := &x.ServiceSyncPeriod - yym886 := z.EncBinary() - _ = yym886 - if false { - } else if z.HasExtensions() && z.EncExt(yy885) { - } else if !yym886 && z.IsJSONHandle() { - z.EncJSONMarshal(yy885) - } else { - z.EncFallback(yy885) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("serviceSyncPeriod")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy887 := &x.ServiceSyncPeriod - yym888 := z.EncBinary() - _ = yym888 - if false { - } else if z.HasExtensions() && z.EncExt(yy887) { - } else if !yym888 && z.IsJSONHandle() { - z.EncJSONMarshal(yy887) - } else { - z.EncFallback(yy887) - } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy890 := &x.NodeSyncPeriod - yym891 := z.EncBinary() - _ = yym891 - if false { - } else if z.HasExtensions() && z.EncExt(yy890) { - } else if !yym891 && z.IsJSONHandle() { - z.EncJSONMarshal(yy890) - } else { - z.EncFallback(yy890) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("nodeSyncPeriod")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy892 := &x.NodeSyncPeriod + yy892 := &x.ServiceSyncPeriod yym893 := z.EncBinary() _ = yym893 if false { @@ -7674,24 +7701,24 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy892) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy895 := &x.ResourceQuotaSyncPeriod - yym896 := z.EncBinary() - _ = yym896 - if false { - } else if z.HasExtensions() && z.EncExt(yy895) { - } else if !yym896 && z.IsJSONHandle() { - z.EncJSONMarshal(yy895) - } else { - z.EncFallback(yy895) - } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("resourceQuotaSyncPeriod")) + r.EncodeString(codecSelferC_UTF81234, string("serviceSyncPeriod")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy897 := &x.ResourceQuotaSyncPeriod + yy894 := &x.ServiceSyncPeriod + yym895 := z.EncBinary() + _ = yym895 + if false { + } else if z.HasExtensions() && z.EncExt(yy894) { + } else if !yym895 && z.IsJSONHandle() { + z.EncJSONMarshal(yy894) + } else { + z.EncFallback(yy894) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy897 := &x.NodeSyncPeriod yym898 := z.EncBinary() _ = yym898 if false { @@ -7701,24 +7728,24 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy897) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy900 := &x.NamespaceSyncPeriod - yym901 := z.EncBinary() - _ = yym901 - if false { - } else if z.HasExtensions() && z.EncExt(yy900) { - } else if !yym901 && z.IsJSONHandle() { - z.EncJSONMarshal(yy900) - } else { - z.EncFallback(yy900) - } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("namespaceSyncPeriod")) + r.EncodeString(codecSelferC_UTF81234, string("nodeSyncPeriod")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy902 := &x.NamespaceSyncPeriod + yy899 := &x.NodeSyncPeriod + yym900 := z.EncBinary() + _ = yym900 + if false { + } else if z.HasExtensions() && z.EncExt(yy899) { + } else if !yym900 && z.IsJSONHandle() { + z.EncJSONMarshal(yy899) + } else { + z.EncFallback(yy899) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy902 := &x.ResourceQuotaSyncPeriod yym903 := z.EncBinary() _ = yym903 if false { @@ -7728,24 +7755,24 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy902) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy905 := &x.PVClaimBinderSyncPeriod - yym906 := z.EncBinary() - _ = yym906 - if false { - } else if z.HasExtensions() && z.EncExt(yy905) { - } else if !yym906 && z.IsJSONHandle() { - z.EncJSONMarshal(yy905) - } else { - z.EncFallback(yy905) - } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("pvClaimBinderSyncPeriod")) + r.EncodeString(codecSelferC_UTF81234, string("resourceQuotaSyncPeriod")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy907 := &x.PVClaimBinderSyncPeriod + yy904 := &x.ResourceQuotaSyncPeriod + yym905 := z.EncBinary() + _ = yym905 + if false { + } else if z.HasExtensions() && z.EncExt(yy904) { + } else if !yym905 && z.IsJSONHandle() { + z.EncJSONMarshal(yy904) + } else { + z.EncFallback(yy904) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy907 := &x.NamespaceSyncPeriod yym908 := z.EncBinary() _ = yym908 if false { @@ -7755,24 +7782,24 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy907) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy910 := &x.MinResyncPeriod - yym911 := z.EncBinary() - _ = yym911 - if false { - } else if z.HasExtensions() && z.EncExt(yy910) { - } else if !yym911 && z.IsJSONHandle() { - z.EncJSONMarshal(yy910) - } else { - z.EncFallback(yy910) - } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("minResyncPeriod")) + r.EncodeString(codecSelferC_UTF81234, string("namespaceSyncPeriod")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy912 := &x.MinResyncPeriod + yy909 := &x.NamespaceSyncPeriod + yym910 := z.EncBinary() + _ = yym910 + if false { + } else if z.HasExtensions() && z.EncExt(yy909) { + } else if !yym910 && z.IsJSONHandle() { + z.EncJSONMarshal(yy909) + } else { + z.EncFallback(yy909) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy912 := &x.PVClaimBinderSyncPeriod yym913 := z.EncBinary() _ = yym913 if false { @@ -7782,12 +7809,53 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy912) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("pvClaimBinderSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy914 := &x.PVClaimBinderSyncPeriod yym915 := z.EncBinary() _ = yym915 if false { + } else if z.HasExtensions() && z.EncExt(yy914) { + } else if !yym915 && z.IsJSONHandle() { + z.EncJSONMarshal(yy914) + } else { + z.EncFallback(yy914) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy917 := &x.MinResyncPeriod + yym918 := z.EncBinary() + _ = yym918 + if false { + } else if z.HasExtensions() && z.EncExt(yy917) { + } else if !yym918 && z.IsJSONHandle() { + z.EncJSONMarshal(yy917) + } else { + z.EncFallback(yy917) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("minResyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy919 := &x.MinResyncPeriod + yym920 := z.EncBinary() + _ = yym920 + if false { + } else if z.HasExtensions() && z.EncExt(yy919) { + } else if !yym920 && z.IsJSONHandle() { + z.EncJSONMarshal(yy919) + } else { + z.EncFallback(yy919) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym922 := z.EncBinary() + _ = yym922 + if false { } else { r.EncodeInt(int64(x.TerminatedPodGCThreshold)) } @@ -7795,57 +7863,16 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("terminatedPodGCThreshold")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym916 := z.EncBinary() - _ = yym916 + yym923 := z.EncBinary() + _ = yym923 if false { } else { r.EncodeInt(int64(x.TerminatedPodGCThreshold)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy918 := &x.HorizontalPodAutoscalerSyncPeriod - yym919 := z.EncBinary() - _ = yym919 - if false { - } else if z.HasExtensions() && z.EncExt(yy918) { - } else if !yym919 && z.IsJSONHandle() { - z.EncJSONMarshal(yy918) - } else { - z.EncFallback(yy918) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("horizontalPodAutoscalerSyncPeriod")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy920 := &x.HorizontalPodAutoscalerSyncPeriod - yym921 := z.EncBinary() - _ = yym921 - if false { - } else if z.HasExtensions() && z.EncExt(yy920) { - } else if !yym921 && z.IsJSONHandle() { - z.EncJSONMarshal(yy920) - } else { - z.EncFallback(yy920) - } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy923 := &x.DeploymentControllerSyncPeriod - yym924 := z.EncBinary() - _ = yym924 - if false { - } else if z.HasExtensions() && z.EncExt(yy923) { - } else if !yym924 && z.IsJSONHandle() { - z.EncJSONMarshal(yy923) - } else { - z.EncFallback(yy923) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("deploymentControllerSyncPeriod")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy925 := &x.DeploymentControllerSyncPeriod + yy925 := &x.HorizontalPodAutoscalerSyncPeriod yym926 := z.EncBinary() _ = yym926 if false { @@ -7855,24 +7882,24 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy925) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy928 := &x.PodEvictionTimeout - yym929 := z.EncBinary() - _ = yym929 - if false { - } else if z.HasExtensions() && z.EncExt(yy928) { - } else if !yym929 && z.IsJSONHandle() { - z.EncJSONMarshal(yy928) - } else { - z.EncFallback(yy928) - } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("podEvictionTimeout")) + r.EncodeString(codecSelferC_UTF81234, string("horizontalPodAutoscalerSyncPeriod")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy930 := &x.PodEvictionTimeout + yy927 := &x.HorizontalPodAutoscalerSyncPeriod + yym928 := z.EncBinary() + _ = yym928 + if false { + } else if z.HasExtensions() && z.EncExt(yy927) { + } else if !yym928 && z.IsJSONHandle() { + z.EncJSONMarshal(yy927) + } else { + z.EncFallback(yy927) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy930 := &x.DeploymentControllerSyncPeriod yym931 := z.EncBinary() _ = yym931 if false { @@ -7882,12 +7909,53 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy930) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("deploymentControllerSyncPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy932 := &x.DeploymentControllerSyncPeriod yym933 := z.EncBinary() _ = yym933 if false { + } else if z.HasExtensions() && z.EncExt(yy932) { + } else if !yym933 && z.IsJSONHandle() { + z.EncJSONMarshal(yy932) + } else { + z.EncFallback(yy932) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy935 := &x.PodEvictionTimeout + yym936 := z.EncBinary() + _ = yym936 + if false { + } else if z.HasExtensions() && z.EncExt(yy935) { + } else if !yym936 && z.IsJSONHandle() { + z.EncJSONMarshal(yy935) + } else { + z.EncFallback(yy935) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("podEvictionTimeout")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy937 := &x.PodEvictionTimeout + yym938 := z.EncBinary() + _ = yym938 + if false { + } else if z.HasExtensions() && z.EncExt(yy937) { + } else if !yym938 && z.IsJSONHandle() { + z.EncJSONMarshal(yy937) + } else { + z.EncFallback(yy937) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym940 := z.EncBinary() + _ = yym940 + if false { } else { r.EncodeFloat32(float32(x.DeletingPodsQps)) } @@ -7895,17 +7963,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("deletingPodsQps")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym934 := z.EncBinary() - _ = yym934 + yym941 := z.EncBinary() + _ = yym941 if false { } else { r.EncodeFloat32(float32(x.DeletingPodsQps)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym936 := z.EncBinary() - _ = yym936 + yym943 := z.EncBinary() + _ = yym943 if false { } else { r.EncodeInt(int64(x.DeletingPodsBurst)) @@ -7914,44 +7982,44 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("deletingPodsBurst")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym937 := z.EncBinary() - _ = yym937 + yym944 := z.EncBinary() + _ = yym944 if false { } else { r.EncodeInt(int64(x.DeletingPodsBurst)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy939 := &x.NodeMonitorGracePeriod - yym940 := z.EncBinary() - _ = yym940 + yy946 := &x.NodeMonitorGracePeriod + yym947 := z.EncBinary() + _ = yym947 if false { - } else if z.HasExtensions() && z.EncExt(yy939) { - } else if !yym940 && z.IsJSONHandle() { - z.EncJSONMarshal(yy939) + } else if z.HasExtensions() && z.EncExt(yy946) { + } else if !yym947 && z.IsJSONHandle() { + z.EncJSONMarshal(yy946) } else { - z.EncFallback(yy939) + z.EncFallback(yy946) } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("nodeMonitorGracePeriod")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy941 := &x.NodeMonitorGracePeriod - yym942 := z.EncBinary() - _ = yym942 + yy948 := &x.NodeMonitorGracePeriod + yym949 := z.EncBinary() + _ = yym949 if false { - } else if z.HasExtensions() && z.EncExt(yy941) { - } else if !yym942 && z.IsJSONHandle() { - z.EncJSONMarshal(yy941) + } else if z.HasExtensions() && z.EncExt(yy948) { + } else if !yym949 && z.IsJSONHandle() { + z.EncJSONMarshal(yy948) } else { - z.EncFallback(yy941) + z.EncFallback(yy948) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym944 := z.EncBinary() - _ = yym944 + yym951 := z.EncBinary() + _ = yym951 if false { } else { r.EncodeInt(int64(x.RegisterRetryCount)) @@ -7960,57 +8028,16 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("registerRetryCount")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym945 := z.EncBinary() - _ = yym945 + yym952 := z.EncBinary() + _ = yym952 if false { } else { r.EncodeInt(int64(x.RegisterRetryCount)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy947 := &x.NodeStartupGracePeriod - yym948 := z.EncBinary() - _ = yym948 - if false { - } else if z.HasExtensions() && z.EncExt(yy947) { - } else if !yym948 && z.IsJSONHandle() { - z.EncJSONMarshal(yy947) - } else { - z.EncFallback(yy947) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("nodeStartupGracePeriod")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy949 := &x.NodeStartupGracePeriod - yym950 := z.EncBinary() - _ = yym950 - if false { - } else if z.HasExtensions() && z.EncExt(yy949) { - } else if !yym950 && z.IsJSONHandle() { - z.EncJSONMarshal(yy949) - } else { - z.EncFallback(yy949) - } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy952 := &x.NodeMonitorPeriod - yym953 := z.EncBinary() - _ = yym953 - if false { - } else if z.HasExtensions() && z.EncExt(yy952) { - } else if !yym953 && z.IsJSONHandle() { - z.EncJSONMarshal(yy952) - } else { - z.EncFallback(yy952) - } - } else { - z.EncSendContainerState(codecSelfer_containerMapKey1234) - r.EncodeString(codecSelferC_UTF81234, string("nodeMonitorPeriod")) - z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy954 := &x.NodeMonitorPeriod + yy954 := &x.NodeStartupGracePeriod yym955 := z.EncBinary() _ = yym955 if false { @@ -8020,12 +8047,53 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode } else { z.EncFallback(yy954) } - } - if yyr826 || yy2arr826 { - z.EncSendContainerState(codecSelfer_containerArrayElem1234) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeStartupGracePeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy956 := &x.NodeStartupGracePeriod yym957 := z.EncBinary() _ = yym957 if false { + } else if z.HasExtensions() && z.EncExt(yy956) { + } else if !yym957 && z.IsJSONHandle() { + z.EncJSONMarshal(yy956) + } else { + z.EncFallback(yy956) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yy959 := &x.NodeMonitorPeriod + yym960 := z.EncBinary() + _ = yym960 + if false { + } else if z.HasExtensions() && z.EncExt(yy959) { + } else if !yym960 && z.IsJSONHandle() { + z.EncJSONMarshal(yy959) + } else { + z.EncFallback(yy959) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey1234) + r.EncodeString(codecSelferC_UTF81234, string("nodeMonitorPeriod")) + z.EncSendContainerState(codecSelfer_containerMapValue1234) + yy961 := &x.NodeMonitorPeriod + yym962 := z.EncBinary() + _ = yym962 + if false { + } else if z.HasExtensions() && z.EncExt(yy961) { + } else if !yym962 && z.IsJSONHandle() { + z.EncJSONMarshal(yy961) + } else { + z.EncFallback(yy961) + } + } + if yyr833 || yy2arr833 { + z.EncSendContainerState(codecSelfer_containerArrayElem1234) + yym964 := z.EncBinary() + _ = yym964 + if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ServiceAccountKeyFile)) } @@ -8033,17 +8101,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("serviceAccountKeyFile")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym958 := z.EncBinary() - _ = yym958 + yym965 := z.EncBinary() + _ = yym965 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ServiceAccountKeyFile)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym960 := z.EncBinary() - _ = yym960 + yym967 := z.EncBinary() + _ = yym967 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterSigningCertFile)) @@ -8052,17 +8120,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("clusterSigningCertFile")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym961 := z.EncBinary() - _ = yym961 + yym968 := z.EncBinary() + _ = yym968 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterSigningCertFile)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym963 := z.EncBinary() - _ = yym963 + yym970 := z.EncBinary() + _ = yym970 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterSigningKeyFile)) @@ -8071,17 +8139,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("clusterSigningKeyFile")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym964 := z.EncBinary() - _ = yym964 + yym971 := z.EncBinary() + _ = yym971 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterSigningKeyFile)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym966 := z.EncBinary() - _ = yym966 + yym973 := z.EncBinary() + _ = yym973 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ApproveAllKubeletCSRsForGroup)) @@ -8090,17 +8158,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("approveAllKubeletCSRsForGroup")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym967 := z.EncBinary() - _ = yym967 + yym974 := z.EncBinary() + _ = yym974 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ApproveAllKubeletCSRsForGroup)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym969 := z.EncBinary() - _ = yym969 + yym976 := z.EncBinary() + _ = yym976 if false { } else { r.EncodeBool(bool(x.EnableProfiling)) @@ -8109,17 +8177,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("enableProfiling")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym970 := z.EncBinary() - _ = yym970 + yym977 := z.EncBinary() + _ = yym977 if false { } else { r.EncodeBool(bool(x.EnableProfiling)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym972 := z.EncBinary() - _ = yym972 + yym979 := z.EncBinary() + _ = yym979 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterName)) @@ -8128,17 +8196,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("clusterName")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym973 := z.EncBinary() - _ = yym973 + yym980 := z.EncBinary() + _ = yym980 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterName)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym975 := z.EncBinary() - _ = yym975 + yym982 := z.EncBinary() + _ = yym982 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterCIDR)) @@ -8147,17 +8215,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("clusterCIDR")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym976 := z.EncBinary() - _ = yym976 + yym983 := z.EncBinary() + _ = yym983 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ClusterCIDR)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym978 := z.EncBinary() - _ = yym978 + yym985 := z.EncBinary() + _ = yym985 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ServiceCIDR)) @@ -8166,17 +8234,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("serviceCIDR")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym979 := z.EncBinary() - _ = yym979 + yym986 := z.EncBinary() + _ = yym986 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ServiceCIDR)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym981 := z.EncBinary() - _ = yym981 + yym988 := z.EncBinary() + _ = yym988 if false { } else { r.EncodeInt(int64(x.NodeCIDRMaskSize)) @@ -8185,17 +8253,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("nodeCIDRMaskSize")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym982 := z.EncBinary() - _ = yym982 + yym989 := z.EncBinary() + _ = yym989 if false { } else { r.EncodeInt(int64(x.NodeCIDRMaskSize)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym984 := z.EncBinary() - _ = yym984 + yym991 := z.EncBinary() + _ = yym991 if false { } else { r.EncodeBool(bool(x.AllocateNodeCIDRs)) @@ -8204,17 +8272,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("allocateNodeCIDRs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym985 := z.EncBinary() - _ = yym985 + yym992 := z.EncBinary() + _ = yym992 if false { } else { r.EncodeBool(bool(x.AllocateNodeCIDRs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym987 := z.EncBinary() - _ = yym987 + yym994 := z.EncBinary() + _ = yym994 if false { } else { r.EncodeBool(bool(x.ConfigureCloudRoutes)) @@ -8223,17 +8291,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("configureCloudRoutes")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym988 := z.EncBinary() - _ = yym988 + yym995 := z.EncBinary() + _ = yym995 if false { } else { r.EncodeBool(bool(x.ConfigureCloudRoutes)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym990 := z.EncBinary() - _ = yym990 + yym997 := z.EncBinary() + _ = yym997 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile)) @@ -8242,17 +8310,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("rootCAFile")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym991 := z.EncBinary() - _ = yym991 + yym998 := z.EncBinary() + _ = yym998 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.RootCAFile)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym993 := z.EncBinary() - _ = yym993 + yym1000 := z.EncBinary() + _ = yym1000 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ContentType)) @@ -8261,17 +8329,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("contentType")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym994 := z.EncBinary() - _ = yym994 + yym1001 := z.EncBinary() + _ = yym1001 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.ContentType)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym996 := z.EncBinary() - _ = yym996 + yym1003 := z.EncBinary() + _ = yym1003 if false { } else { r.EncodeFloat32(float32(x.KubeAPIQPS)) @@ -8280,17 +8348,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeAPIQPS")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym997 := z.EncBinary() - _ = yym997 + yym1004 := z.EncBinary() + _ = yym1004 if false { } else { r.EncodeFloat32(float32(x.KubeAPIQPS)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym999 := z.EncBinary() - _ = yym999 + yym1006 := z.EncBinary() + _ = yym1006 if false { } else { r.EncodeInt(int64(x.KubeAPIBurst)) @@ -8299,66 +8367,66 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("kubeAPIBurst")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1000 := z.EncBinary() - _ = yym1000 + yym1007 := z.EncBinary() + _ = yym1007 if false { } else { r.EncodeInt(int64(x.KubeAPIBurst)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy1002 := &x.LeaderElection - yy1002.CodecEncodeSelf(e) + yy1009 := &x.LeaderElection + yy1009.CodecEncodeSelf(e) } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("leaderElection")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy1003 := &x.LeaderElection - yy1003.CodecEncodeSelf(e) + yy1010 := &x.LeaderElection + yy1010.CodecEncodeSelf(e) } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy1005 := &x.VolumeConfiguration - yy1005.CodecEncodeSelf(e) + yy1012 := &x.VolumeConfiguration + yy1012.CodecEncodeSelf(e) } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("volumeConfiguration")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy1006 := &x.VolumeConfiguration - yy1006.CodecEncodeSelf(e) + yy1013 := &x.VolumeConfiguration + yy1013.CodecEncodeSelf(e) } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy1008 := &x.ControllerStartInterval - yym1009 := z.EncBinary() - _ = yym1009 + yy1015 := &x.ControllerStartInterval + yym1016 := z.EncBinary() + _ = yym1016 if false { - } else if z.HasExtensions() && z.EncExt(yy1008) { - } else if !yym1009 && z.IsJSONHandle() { - z.EncJSONMarshal(yy1008) + } else if z.HasExtensions() && z.EncExt(yy1015) { + } else if !yym1016 && z.IsJSONHandle() { + z.EncJSONMarshal(yy1015) } else { - z.EncFallback(yy1008) + z.EncFallback(yy1015) } } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("controllerStartInterval")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy1010 := &x.ControllerStartInterval - yym1011 := z.EncBinary() - _ = yym1011 + yy1017 := &x.ControllerStartInterval + yym1018 := z.EncBinary() + _ = yym1018 if false { - } else if z.HasExtensions() && z.EncExt(yy1010) { - } else if !yym1011 && z.IsJSONHandle() { - z.EncJSONMarshal(yy1010) + } else if z.HasExtensions() && z.EncExt(yy1017) { + } else if !yym1018 && z.IsJSONHandle() { + z.EncJSONMarshal(yy1017) } else { - z.EncFallback(yy1010) + z.EncFallback(yy1017) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1013 := z.EncBinary() - _ = yym1013 + yym1020 := z.EncBinary() + _ = yym1020 if false { } else { r.EncodeBool(bool(x.EnableGarbageCollector)) @@ -8367,17 +8435,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("enableGarbageCollector")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1014 := z.EncBinary() - _ = yym1014 + yym1021 := z.EncBinary() + _ = yym1021 if false { } else { r.EncodeBool(bool(x.EnableGarbageCollector)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1016 := z.EncBinary() - _ = yym1016 + yym1023 := z.EncBinary() + _ = yym1023 if false { } else { r.EncodeInt(int64(x.ConcurrentGCSyncs)) @@ -8386,17 +8454,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("concurrentGCSyncs")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1017 := z.EncBinary() - _ = yym1017 + yym1024 := z.EncBinary() + _ = yym1024 if false { } else { r.EncodeInt(int64(x.ConcurrentGCSyncs)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1019 := z.EncBinary() - _ = yym1019 + yym1026 := z.EncBinary() + _ = yym1026 if false { } else { r.EncodeFloat32(float32(x.NodeEvictionRate)) @@ -8405,17 +8473,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("nodeEvictionRate")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1020 := z.EncBinary() - _ = yym1020 + yym1027 := z.EncBinary() + _ = yym1027 if false { } else { r.EncodeFloat32(float32(x.NodeEvictionRate)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1022 := z.EncBinary() - _ = yym1022 + yym1029 := z.EncBinary() + _ = yym1029 if false { } else { r.EncodeFloat32(float32(x.SecondaryNodeEvictionRate)) @@ -8424,17 +8492,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("secondaryNodeEvictionRate")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1023 := z.EncBinary() - _ = yym1023 + yym1030 := z.EncBinary() + _ = yym1030 if false { } else { r.EncodeFloat32(float32(x.SecondaryNodeEvictionRate)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1025 := z.EncBinary() - _ = yym1025 + yym1032 := z.EncBinary() + _ = yym1032 if false { } else { r.EncodeInt(int64(x.LargeClusterSizeThreshold)) @@ -8443,17 +8511,17 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("largeClusterSizeThreshold")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1026 := z.EncBinary() - _ = yym1026 + yym1033 := z.EncBinary() + _ = yym1033 if false { } else { r.EncodeInt(int64(x.LargeClusterSizeThreshold)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1028 := z.EncBinary() - _ = yym1028 + yym1035 := z.EncBinary() + _ = yym1035 if false { } else { r.EncodeFloat32(float32(x.UnhealthyZoneThreshold)) @@ -8462,14 +8530,14 @@ func (x *KubeControllerManagerConfiguration) CodecEncodeSelf(e *codec1978.Encode z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("unhealthyZoneThreshold")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1029 := z.EncBinary() - _ = yym1029 + yym1036 := z.EncBinary() + _ = yym1036 if false { } else { r.EncodeFloat32(float32(x.UnhealthyZoneThreshold)) } } - if yyr826 || yy2arr826 { + if yyr833 || yy2arr833 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -8482,25 +8550,25 @@ func (x *KubeControllerManagerConfiguration) CodecDecodeSelf(d *codec1978.Decode var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym1030 := z.DecBinary() - _ = yym1030 + yym1037 := z.DecBinary() + _ = yym1037 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct1031 := r.ContainerType() - if yyct1031 == codecSelferValueTypeMap1234 { - yyl1031 := r.ReadMapStart() - if yyl1031 == 0 { + yyct1038 := r.ContainerType() + if yyct1038 == codecSelferValueTypeMap1234 { + yyl1038 := r.ReadMapStart() + if yyl1038 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl1031, d) + x.codecDecodeSelfFromMap(yyl1038, d) } - } else if yyct1031 == codecSelferValueTypeArray1234 { - yyl1031 := r.ReadArrayStart() - if yyl1031 == 0 { + } else if yyct1038 == codecSelferValueTypeArray1234 { + yyl1038 := r.ReadArrayStart() + if yyl1038 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl1031, d) + x.codecDecodeSelfFromArray(yyl1038, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -8512,12 +8580,12 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys1032Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys1032Slc - var yyhl1032 bool = l >= 0 - for yyj1032 := 0; ; yyj1032++ { - if yyhl1032 { - if yyj1032 >= l { + var yys1039Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys1039Slc + var yyhl1039 bool = l >= 0 + for yyj1039 := 0; ; yyj1039++ { + if yyhl1039 { + if yyj1039 >= l { break } } else { @@ -8526,10 +8594,10 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys1032Slc = r.DecodeBytes(yys1032Slc, true, true) - yys1032 := string(yys1032Slc) + yys1039Slc = r.DecodeBytes(yys1039Slc, true, true) + yys1039 := string(yys1039Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys1032 { + switch yys1039 { case "kind": if r.TryDecodeAsNil() { x.Kind = "" @@ -8648,90 +8716,90 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co if r.TryDecodeAsNil() { x.ServiceSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1052 := &x.ServiceSyncPeriod - yym1053 := z.DecBinary() - _ = yym1053 + yyv1059 := &x.ServiceSyncPeriod + yym1060 := z.DecBinary() + _ = yym1060 if false { - } else if z.HasExtensions() && z.DecExt(yyv1052) { - } else if !yym1053 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1052) + } else if z.HasExtensions() && z.DecExt(yyv1059) { + } else if !yym1060 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1059) } else { - z.DecFallback(yyv1052, false) + z.DecFallback(yyv1059, false) } } case "nodeSyncPeriod": if r.TryDecodeAsNil() { x.NodeSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1054 := &x.NodeSyncPeriod - yym1055 := z.DecBinary() - _ = yym1055 + yyv1061 := &x.NodeSyncPeriod + yym1062 := z.DecBinary() + _ = yym1062 if false { - } else if z.HasExtensions() && z.DecExt(yyv1054) { - } else if !yym1055 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1054) + } else if z.HasExtensions() && z.DecExt(yyv1061) { + } else if !yym1062 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1061) } else { - z.DecFallback(yyv1054, false) + z.DecFallback(yyv1061, false) } } case "resourceQuotaSyncPeriod": if r.TryDecodeAsNil() { x.ResourceQuotaSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1056 := &x.ResourceQuotaSyncPeriod - yym1057 := z.DecBinary() - _ = yym1057 + yyv1063 := &x.ResourceQuotaSyncPeriod + yym1064 := z.DecBinary() + _ = yym1064 if false { - } else if z.HasExtensions() && z.DecExt(yyv1056) { - } else if !yym1057 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1056) + } else if z.HasExtensions() && z.DecExt(yyv1063) { + } else if !yym1064 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1063) } else { - z.DecFallback(yyv1056, false) + z.DecFallback(yyv1063, false) } } case "namespaceSyncPeriod": if r.TryDecodeAsNil() { x.NamespaceSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1058 := &x.NamespaceSyncPeriod - yym1059 := z.DecBinary() - _ = yym1059 + yyv1065 := &x.NamespaceSyncPeriod + yym1066 := z.DecBinary() + _ = yym1066 if false { - } else if z.HasExtensions() && z.DecExt(yyv1058) { - } else if !yym1059 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1058) + } else if z.HasExtensions() && z.DecExt(yyv1065) { + } else if !yym1066 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1065) } else { - z.DecFallback(yyv1058, false) + z.DecFallback(yyv1065, false) } } case "pvClaimBinderSyncPeriod": if r.TryDecodeAsNil() { x.PVClaimBinderSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1060 := &x.PVClaimBinderSyncPeriod - yym1061 := z.DecBinary() - _ = yym1061 + yyv1067 := &x.PVClaimBinderSyncPeriod + yym1068 := z.DecBinary() + _ = yym1068 if false { - } else if z.HasExtensions() && z.DecExt(yyv1060) { - } else if !yym1061 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1060) + } else if z.HasExtensions() && z.DecExt(yyv1067) { + } else if !yym1068 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1067) } else { - z.DecFallback(yyv1060, false) + z.DecFallback(yyv1067, false) } } case "minResyncPeriod": if r.TryDecodeAsNil() { x.MinResyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1062 := &x.MinResyncPeriod - yym1063 := z.DecBinary() - _ = yym1063 + yyv1069 := &x.MinResyncPeriod + yym1070 := z.DecBinary() + _ = yym1070 if false { - } else if z.HasExtensions() && z.DecExt(yyv1062) { - } else if !yym1063 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1062) + } else if z.HasExtensions() && z.DecExt(yyv1069) { + } else if !yym1070 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1069) } else { - z.DecFallback(yyv1062, false) + z.DecFallback(yyv1069, false) } } case "terminatedPodGCThreshold": @@ -8744,45 +8812,45 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co if r.TryDecodeAsNil() { x.HorizontalPodAutoscalerSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1065 := &x.HorizontalPodAutoscalerSyncPeriod - yym1066 := z.DecBinary() - _ = yym1066 + yyv1072 := &x.HorizontalPodAutoscalerSyncPeriod + yym1073 := z.DecBinary() + _ = yym1073 if false { - } else if z.HasExtensions() && z.DecExt(yyv1065) { - } else if !yym1066 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1065) + } else if z.HasExtensions() && z.DecExt(yyv1072) { + } else if !yym1073 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1072) } else { - z.DecFallback(yyv1065, false) + z.DecFallback(yyv1072, false) } } case "deploymentControllerSyncPeriod": if r.TryDecodeAsNil() { x.DeploymentControllerSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1067 := &x.DeploymentControllerSyncPeriod - yym1068 := z.DecBinary() - _ = yym1068 + yyv1074 := &x.DeploymentControllerSyncPeriod + yym1075 := z.DecBinary() + _ = yym1075 if false { - } else if z.HasExtensions() && z.DecExt(yyv1067) { - } else if !yym1068 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1067) + } else if z.HasExtensions() && z.DecExt(yyv1074) { + } else if !yym1075 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1074) } else { - z.DecFallback(yyv1067, false) + z.DecFallback(yyv1074, false) } } case "podEvictionTimeout": if r.TryDecodeAsNil() { x.PodEvictionTimeout = pkg1_unversioned.Duration{} } else { - yyv1069 := &x.PodEvictionTimeout - yym1070 := z.DecBinary() - _ = yym1070 + yyv1076 := &x.PodEvictionTimeout + yym1077 := z.DecBinary() + _ = yym1077 if false { - } else if z.HasExtensions() && z.DecExt(yyv1069) { - } else if !yym1070 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1069) + } else if z.HasExtensions() && z.DecExt(yyv1076) { + } else if !yym1077 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1076) } else { - z.DecFallback(yyv1069, false) + z.DecFallback(yyv1076, false) } } case "deletingPodsQps": @@ -8801,15 +8869,15 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co if r.TryDecodeAsNil() { x.NodeMonitorGracePeriod = pkg1_unversioned.Duration{} } else { - yyv1073 := &x.NodeMonitorGracePeriod - yym1074 := z.DecBinary() - _ = yym1074 + yyv1080 := &x.NodeMonitorGracePeriod + yym1081 := z.DecBinary() + _ = yym1081 if false { - } else if z.HasExtensions() && z.DecExt(yyv1073) { - } else if !yym1074 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1073) + } else if z.HasExtensions() && z.DecExt(yyv1080) { + } else if !yym1081 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1080) } else { - z.DecFallback(yyv1073, false) + z.DecFallback(yyv1080, false) } } case "registerRetryCount": @@ -8822,30 +8890,30 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co if r.TryDecodeAsNil() { x.NodeStartupGracePeriod = pkg1_unversioned.Duration{} } else { - yyv1076 := &x.NodeStartupGracePeriod - yym1077 := z.DecBinary() - _ = yym1077 + yyv1083 := &x.NodeStartupGracePeriod + yym1084 := z.DecBinary() + _ = yym1084 if false { - } else if z.HasExtensions() && z.DecExt(yyv1076) { - } else if !yym1077 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1076) + } else if z.HasExtensions() && z.DecExt(yyv1083) { + } else if !yym1084 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1083) } else { - z.DecFallback(yyv1076, false) + z.DecFallback(yyv1083, false) } } case "nodeMonitorPeriod": if r.TryDecodeAsNil() { x.NodeMonitorPeriod = pkg1_unversioned.Duration{} } else { - yyv1078 := &x.NodeMonitorPeriod - yym1079 := z.DecBinary() - _ = yym1079 + yyv1085 := &x.NodeMonitorPeriod + yym1086 := z.DecBinary() + _ = yym1086 if false { - } else if z.HasExtensions() && z.DecExt(yyv1078) { - } else if !yym1079 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1078) + } else if z.HasExtensions() && z.DecExt(yyv1085) { + } else if !yym1086 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1085) } else { - z.DecFallback(yyv1078, false) + z.DecFallback(yyv1085, false) } } case "serviceAccountKeyFile": @@ -8942,29 +9010,29 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co if r.TryDecodeAsNil() { x.LeaderElection = LeaderElectionConfiguration{} } else { - yyv1095 := &x.LeaderElection - yyv1095.CodecDecodeSelf(d) + yyv1102 := &x.LeaderElection + yyv1102.CodecDecodeSelf(d) } case "volumeConfiguration": if r.TryDecodeAsNil() { x.VolumeConfiguration = VolumeConfiguration{} } else { - yyv1096 := &x.VolumeConfiguration - yyv1096.CodecDecodeSelf(d) + yyv1103 := &x.VolumeConfiguration + yyv1103.CodecDecodeSelf(d) } case "controllerStartInterval": if r.TryDecodeAsNil() { x.ControllerStartInterval = pkg1_unversioned.Duration{} } else { - yyv1097 := &x.ControllerStartInterval - yym1098 := z.DecBinary() - _ = yym1098 + yyv1104 := &x.ControllerStartInterval + yym1105 := z.DecBinary() + _ = yym1105 if false { - } else if z.HasExtensions() && z.DecExt(yyv1097) { - } else if !yym1098 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1097) + } else if z.HasExtensions() && z.DecExt(yyv1104) { + } else if !yym1105 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1104) } else { - z.DecFallback(yyv1097, false) + z.DecFallback(yyv1104, false) } } case "enableGarbageCollector": @@ -9004,9 +9072,9 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromMap(l int, d *co x.UnhealthyZoneThreshold = float32(r.DecodeFloat(true)) } default: - z.DecStructFieldNotFound(-1, yys1032) - } // end switch yys1032 - } // end for yyj1032 + z.DecStructFieldNotFound(-1, yys1039) + } // end switch yys1039 + } // end for yyj1039 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -9014,16 +9082,16 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj1105 int - var yyb1105 bool - var yyhl1105 bool = l >= 0 - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + var yyj1112 int + var yyb1112 bool + var yyhl1112 bool = l >= 0 + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9033,13 +9101,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.Kind = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9049,13 +9117,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.APIVersion = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9065,13 +9133,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.Port = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9081,13 +9149,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.Address = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9097,13 +9165,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.CloudProvider = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9113,13 +9181,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.CloudConfigFile = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9129,13 +9197,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentEndpointSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9145,13 +9213,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentRSSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9161,13 +9229,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentRCSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9177,13 +9245,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentServiceSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9193,13 +9261,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentResourceQuotaSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9209,13 +9277,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentDeploymentSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9225,13 +9293,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentDaemonSetSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9241,13 +9309,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentJobSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9257,13 +9325,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentNamespaceSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9273,13 +9341,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentSATokenSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9289,13 +9357,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.LookupCacheSizeForRC = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9305,13 +9373,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.LookupCacheSizeForRS = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9321,13 +9389,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.LookupCacheSizeForDaemonSet = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9335,24 +9403,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.ServiceSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1125 := &x.ServiceSyncPeriod - yym1126 := z.DecBinary() - _ = yym1126 + yyv1132 := &x.ServiceSyncPeriod + yym1133 := z.DecBinary() + _ = yym1133 if false { - } else if z.HasExtensions() && z.DecExt(yyv1125) { - } else if !yym1126 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1125) + } else if z.HasExtensions() && z.DecExt(yyv1132) { + } else if !yym1133 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1132) } else { - z.DecFallback(yyv1125, false) + z.DecFallback(yyv1132, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9360,24 +9428,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.NodeSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1127 := &x.NodeSyncPeriod - yym1128 := z.DecBinary() - _ = yym1128 + yyv1134 := &x.NodeSyncPeriod + yym1135 := z.DecBinary() + _ = yym1135 if false { - } else if z.HasExtensions() && z.DecExt(yyv1127) { - } else if !yym1128 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1127) + } else if z.HasExtensions() && z.DecExt(yyv1134) { + } else if !yym1135 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1134) } else { - z.DecFallback(yyv1127, false) + z.DecFallback(yyv1134, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9385,24 +9453,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.ResourceQuotaSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1129 := &x.ResourceQuotaSyncPeriod - yym1130 := z.DecBinary() - _ = yym1130 + yyv1136 := &x.ResourceQuotaSyncPeriod + yym1137 := z.DecBinary() + _ = yym1137 if false { - } else if z.HasExtensions() && z.DecExt(yyv1129) { - } else if !yym1130 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1129) + } else if z.HasExtensions() && z.DecExt(yyv1136) { + } else if !yym1137 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1136) } else { - z.DecFallback(yyv1129, false) + z.DecFallback(yyv1136, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9410,98 +9478,7 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.NamespaceSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1131 := &x.NamespaceSyncPeriod - yym1132 := z.DecBinary() - _ = yym1132 - if false { - } else if z.HasExtensions() && z.DecExt(yyv1131) { - } else if !yym1132 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1131) - } else { - z.DecFallback(yyv1131, false) - } - } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l - } else { - yyb1105 = r.CheckBreak() - } - if yyb1105 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.PVClaimBinderSyncPeriod = pkg1_unversioned.Duration{} - } else { - yyv1133 := &x.PVClaimBinderSyncPeriod - yym1134 := z.DecBinary() - _ = yym1134 - if false { - } else if z.HasExtensions() && z.DecExt(yyv1133) { - } else if !yym1134 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1133) - } else { - z.DecFallback(yyv1133, false) - } - } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l - } else { - yyb1105 = r.CheckBreak() - } - if yyb1105 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.MinResyncPeriod = pkg1_unversioned.Duration{} - } else { - yyv1135 := &x.MinResyncPeriod - yym1136 := z.DecBinary() - _ = yym1136 - if false { - } else if z.HasExtensions() && z.DecExt(yyv1135) { - } else if !yym1136 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1135) - } else { - z.DecFallback(yyv1135, false) - } - } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l - } else { - yyb1105 = r.CheckBreak() - } - if yyb1105 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.TerminatedPodGCThreshold = 0 - } else { - x.TerminatedPodGCThreshold = int32(r.DecodeInt(32)) - } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l - } else { - yyb1105 = r.CheckBreak() - } - if yyb1105 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.HorizontalPodAutoscalerSyncPeriod = pkg1_unversioned.Duration{} - } else { - yyv1138 := &x.HorizontalPodAutoscalerSyncPeriod + yyv1138 := &x.NamespaceSyncPeriod yym1139 := z.DecBinary() _ = yym1139 if false { @@ -9512,21 +9489,21 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * z.DecFallback(yyv1138, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.DeploymentControllerSyncPeriod = pkg1_unversioned.Duration{} + x.PVClaimBinderSyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1140 := &x.DeploymentControllerSyncPeriod + yyv1140 := &x.PVClaimBinderSyncPeriod yym1141 := z.DecBinary() _ = yym1141 if false { @@ -9537,21 +9514,21 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * z.DecFallback(yyv1140, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.PodEvictionTimeout = pkg1_unversioned.Duration{} + x.MinResyncPeriod = pkg1_unversioned.Duration{} } else { - yyv1142 := &x.PodEvictionTimeout + yyv1142 := &x.MinResyncPeriod yym1143 := z.DecBinary() _ = yym1143 if false { @@ -9562,94 +9539,87 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * z.DecFallback(yyv1142, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.DeletingPodsQps = 0 + x.TerminatedPodGCThreshold = 0 } else { - x.DeletingPodsQps = float32(r.DecodeFloat(true)) + x.TerminatedPodGCThreshold = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.DeletingPodsBurst = 0 + x.HorizontalPodAutoscalerSyncPeriod = pkg1_unversioned.Duration{} } else { - x.DeletingPodsBurst = int32(r.DecodeInt(32)) - } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l - } else { - yyb1105 = r.CheckBreak() - } - if yyb1105 { - z.DecSendContainerState(codecSelfer_containerArrayEnd1234) - return - } - z.DecSendContainerState(codecSelfer_containerArrayElem1234) - if r.TryDecodeAsNil() { - x.NodeMonitorGracePeriod = pkg1_unversioned.Duration{} - } else { - yyv1146 := &x.NodeMonitorGracePeriod - yym1147 := z.DecBinary() - _ = yym1147 + yyv1145 := &x.HorizontalPodAutoscalerSyncPeriod + yym1146 := z.DecBinary() + _ = yym1146 if false { - } else if z.HasExtensions() && z.DecExt(yyv1146) { - } else if !yym1147 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1146) + } else if z.HasExtensions() && z.DecExt(yyv1145) { + } else if !yym1146 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1145) } else { - z.DecFallback(yyv1146, false) + z.DecFallback(yyv1145, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.RegisterRetryCount = 0 + x.DeploymentControllerSyncPeriod = pkg1_unversioned.Duration{} } else { - x.RegisterRetryCount = int32(r.DecodeInt(32)) + yyv1147 := &x.DeploymentControllerSyncPeriod + yym1148 := z.DecBinary() + _ = yym1148 + if false { + } else if z.HasExtensions() && z.DecExt(yyv1147) { + } else if !yym1148 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1147) + } else { + z.DecFallback(yyv1147, false) + } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } z.DecSendContainerState(codecSelfer_containerArrayElem1234) if r.TryDecodeAsNil() { - x.NodeStartupGracePeriod = pkg1_unversioned.Duration{} + x.PodEvictionTimeout = pkg1_unversioned.Duration{} } else { - yyv1149 := &x.NodeStartupGracePeriod + yyv1149 := &x.PodEvictionTimeout yym1150 := z.DecBinary() _ = yym1150 if false { @@ -9660,13 +9630,111 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * z.DecFallback(yyv1149, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DeletingPodsQps = 0 + } else { + x.DeletingPodsQps = float32(r.DecodeFloat(true)) + } + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l + } else { + yyb1112 = r.CheckBreak() + } + if yyb1112 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.DeletingPodsBurst = 0 + } else { + x.DeletingPodsBurst = int32(r.DecodeInt(32)) + } + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l + } else { + yyb1112 = r.CheckBreak() + } + if yyb1112 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeMonitorGracePeriod = pkg1_unversioned.Duration{} + } else { + yyv1153 := &x.NodeMonitorGracePeriod + yym1154 := z.DecBinary() + _ = yym1154 + if false { + } else if z.HasExtensions() && z.DecExt(yyv1153) { + } else if !yym1154 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1153) + } else { + z.DecFallback(yyv1153, false) + } + } + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l + } else { + yyb1112 = r.CheckBreak() + } + if yyb1112 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.RegisterRetryCount = 0 + } else { + x.RegisterRetryCount = int32(r.DecodeInt(32)) + } + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l + } else { + yyb1112 = r.CheckBreak() + } + if yyb1112 { + z.DecSendContainerState(codecSelfer_containerArrayEnd1234) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem1234) + if r.TryDecodeAsNil() { + x.NodeStartupGracePeriod = pkg1_unversioned.Duration{} + } else { + yyv1156 := &x.NodeStartupGracePeriod + yym1157 := z.DecBinary() + _ = yym1157 + if false { + } else if z.HasExtensions() && z.DecExt(yyv1156) { + } else if !yym1157 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1156) + } else { + z.DecFallback(yyv1156, false) + } + } + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l + } else { + yyb1112 = r.CheckBreak() + } + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9674,24 +9742,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.NodeMonitorPeriod = pkg1_unversioned.Duration{} } else { - yyv1151 := &x.NodeMonitorPeriod - yym1152 := z.DecBinary() - _ = yym1152 + yyv1158 := &x.NodeMonitorPeriod + yym1159 := z.DecBinary() + _ = yym1159 if false { - } else if z.HasExtensions() && z.DecExt(yyv1151) { - } else if !yym1152 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1151) + } else if z.HasExtensions() && z.DecExt(yyv1158) { + } else if !yym1159 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1158) } else { - z.DecFallback(yyv1151, false) + z.DecFallback(yyv1158, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9701,13 +9769,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ServiceAccountKeyFile = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9717,13 +9785,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ClusterSigningCertFile = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9733,13 +9801,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ClusterSigningKeyFile = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9749,13 +9817,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ApproveAllKubeletCSRsForGroup = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9765,13 +9833,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.EnableProfiling = bool(r.DecodeBool()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9781,13 +9849,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ClusterName = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9797,13 +9865,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ClusterCIDR = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9813,13 +9881,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ServiceCIDR = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9829,13 +9897,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.NodeCIDRMaskSize = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9845,13 +9913,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.AllocateNodeCIDRs = bool(r.DecodeBool()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9861,13 +9929,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConfigureCloudRoutes = bool(r.DecodeBool()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9877,13 +9945,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.RootCAFile = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9893,13 +9961,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ContentType = string(r.DecodeString()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9909,13 +9977,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.KubeAPIQPS = float32(r.DecodeFloat(true)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9925,13 +9993,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.KubeAPIBurst = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9939,16 +10007,16 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.LeaderElection = LeaderElectionConfiguration{} } else { - yyv1168 := &x.LeaderElection - yyv1168.CodecDecodeSelf(d) + yyv1175 := &x.LeaderElection + yyv1175.CodecDecodeSelf(d) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9956,16 +10024,16 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.VolumeConfiguration = VolumeConfiguration{} } else { - yyv1169 := &x.VolumeConfiguration - yyv1169.CodecDecodeSelf(d) + yyv1176 := &x.VolumeConfiguration + yyv1176.CodecDecodeSelf(d) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -9973,24 +10041,24 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * if r.TryDecodeAsNil() { x.ControllerStartInterval = pkg1_unversioned.Duration{} } else { - yyv1170 := &x.ControllerStartInterval - yym1171 := z.DecBinary() - _ = yym1171 + yyv1177 := &x.ControllerStartInterval + yym1178 := z.DecBinary() + _ = yym1178 if false { - } else if z.HasExtensions() && z.DecExt(yyv1170) { - } else if !yym1171 && z.IsJSONHandle() { - z.DecJSONUnmarshal(yyv1170) + } else if z.HasExtensions() && z.DecExt(yyv1177) { + } else if !yym1178 && z.IsJSONHandle() { + z.DecJSONUnmarshal(yyv1177) } else { - z.DecFallback(yyv1170, false) + z.DecFallback(yyv1177, false) } } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10000,13 +10068,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.EnableGarbageCollector = bool(r.DecodeBool()) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10016,13 +10084,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.ConcurrentGCSyncs = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10032,13 +10100,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.NodeEvictionRate = float32(r.DecodeFloat(true)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10048,13 +10116,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.SecondaryNodeEvictionRate = float32(r.DecodeFloat(true)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10064,13 +10132,13 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * } else { x.LargeClusterSizeThreshold = int32(r.DecodeInt(32)) } - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10081,17 +10149,17 @@ func (x *KubeControllerManagerConfiguration) codecDecodeSelfFromArray(l int, d * x.UnhealthyZoneThreshold = float32(r.DecodeFloat(true)) } for { - yyj1105++ - if yyhl1105 { - yyb1105 = yyj1105 > l + yyj1112++ + if yyhl1112 { + yyb1112 = yyj1112 > l } else { - yyb1105 = r.CheckBreak() + yyb1112 = r.CheckBreak() } - if yyb1105 { + if yyb1112 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj1105-1, "") + z.DecStructFieldNotFound(yyj1112-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -10103,33 +10171,33 @@ func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { if x == nil { r.EncodeNil() } else { - yym1178 := z.EncBinary() - _ = yym1178 + yym1185 := z.EncBinary() + _ = yym1185 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep1179 := !z.EncBinary() - yy2arr1179 := z.EncBasicHandle().StructToArray - var yyq1179 [4]bool - _, _, _ = yysep1179, yyq1179, yy2arr1179 - const yyr1179 bool = false - var yynn1179 int - if yyr1179 || yy2arr1179 { + yysep1186 := !z.EncBinary() + yy2arr1186 := z.EncBasicHandle().StructToArray + var yyq1186 [4]bool + _, _, _ = yysep1186, yyq1186, yy2arr1186 + const yyr1186 bool = false + var yynn1186 int + if yyr1186 || yy2arr1186 { r.EncodeArrayStart(4) } else { - yynn1179 = 4 - for _, b := range yyq1179 { + yynn1186 = 4 + for _, b := range yyq1186 { if b { - yynn1179++ + yynn1186++ } } - r.EncodeMapStart(yynn1179) - yynn1179 = 0 + r.EncodeMapStart(yynn1186) + yynn1186 = 0 } - if yyr1179 || yy2arr1179 { + if yyr1186 || yy2arr1186 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1181 := z.EncBinary() - _ = yym1181 + yym1188 := z.EncBinary() + _ = yym1188 if false { } else { r.EncodeBool(bool(x.EnableHostPathProvisioning)) @@ -10138,17 +10206,17 @@ func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("enableHostPathProvisioning")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1182 := z.EncBinary() - _ = yym1182 + yym1189 := z.EncBinary() + _ = yym1189 if false { } else { r.EncodeBool(bool(x.EnableHostPathProvisioning)) } } - if yyr1179 || yy2arr1179 { + if yyr1186 || yy2arr1186 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1184 := z.EncBinary() - _ = yym1184 + yym1191 := z.EncBinary() + _ = yym1191 if false { } else { r.EncodeBool(bool(x.EnableDynamicProvisioning)) @@ -10157,28 +10225,28 @@ func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("enableDynamicProvisioning")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1185 := z.EncBinary() - _ = yym1185 + yym1192 := z.EncBinary() + _ = yym1192 if false { } else { r.EncodeBool(bool(x.EnableDynamicProvisioning)) } } - if yyr1179 || yy2arr1179 { + if yyr1186 || yy2arr1186 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yy1187 := &x.PersistentVolumeRecyclerConfiguration - yy1187.CodecEncodeSelf(e) + yy1194 := &x.PersistentVolumeRecyclerConfiguration + yy1194.CodecEncodeSelf(e) } else { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("persitentVolumeRecyclerConfiguration")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yy1188 := &x.PersistentVolumeRecyclerConfiguration - yy1188.CodecEncodeSelf(e) + yy1195 := &x.PersistentVolumeRecyclerConfiguration + yy1195.CodecEncodeSelf(e) } - if yyr1179 || yy2arr1179 { + if yyr1186 || yy2arr1186 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1190 := z.EncBinary() - _ = yym1190 + yym1197 := z.EncBinary() + _ = yym1197 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.FlexVolumePluginDir)) @@ -10187,14 +10255,14 @@ func (x *VolumeConfiguration) CodecEncodeSelf(e *codec1978.Encoder) { z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("flexVolumePluginDir")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1191 := z.EncBinary() - _ = yym1191 + yym1198 := z.EncBinary() + _ = yym1198 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.FlexVolumePluginDir)) } } - if yyr1179 || yy2arr1179 { + if yyr1186 || yy2arr1186 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -10207,25 +10275,25 @@ func (x *VolumeConfiguration) CodecDecodeSelf(d *codec1978.Decoder) { var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym1192 := z.DecBinary() - _ = yym1192 + yym1199 := z.DecBinary() + _ = yym1199 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct1193 := r.ContainerType() - if yyct1193 == codecSelferValueTypeMap1234 { - yyl1193 := r.ReadMapStart() - if yyl1193 == 0 { + yyct1200 := r.ContainerType() + if yyct1200 == codecSelferValueTypeMap1234 { + yyl1200 := r.ReadMapStart() + if yyl1200 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl1193, d) + x.codecDecodeSelfFromMap(yyl1200, d) } - } else if yyct1193 == codecSelferValueTypeArray1234 { - yyl1193 := r.ReadArrayStart() - if yyl1193 == 0 { + } else if yyct1200 == codecSelferValueTypeArray1234 { + yyl1200 := r.ReadArrayStart() + if yyl1200 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl1193, d) + x.codecDecodeSelfFromArray(yyl1200, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -10237,12 +10305,12 @@ func (x *VolumeConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys1194Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys1194Slc - var yyhl1194 bool = l >= 0 - for yyj1194 := 0; ; yyj1194++ { - if yyhl1194 { - if yyj1194 >= l { + var yys1201Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys1201Slc + var yyhl1201 bool = l >= 0 + for yyj1201 := 0; ; yyj1201++ { + if yyhl1201 { + if yyj1201 >= l { break } } else { @@ -10251,10 +10319,10 @@ func (x *VolumeConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys1194Slc = r.DecodeBytes(yys1194Slc, true, true) - yys1194 := string(yys1194Slc) + yys1201Slc = r.DecodeBytes(yys1201Slc, true, true) + yys1201 := string(yys1201Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys1194 { + switch yys1201 { case "enableHostPathProvisioning": if r.TryDecodeAsNil() { x.EnableHostPathProvisioning = false @@ -10271,8 +10339,8 @@ func (x *VolumeConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder if r.TryDecodeAsNil() { x.PersistentVolumeRecyclerConfiguration = PersistentVolumeRecyclerConfiguration{} } else { - yyv1197 := &x.PersistentVolumeRecyclerConfiguration - yyv1197.CodecDecodeSelf(d) + yyv1204 := &x.PersistentVolumeRecyclerConfiguration + yyv1204.CodecDecodeSelf(d) } case "flexVolumePluginDir": if r.TryDecodeAsNil() { @@ -10281,9 +10349,9 @@ func (x *VolumeConfiguration) codecDecodeSelfFromMap(l int, d *codec1978.Decoder x.FlexVolumePluginDir = string(r.DecodeString()) } default: - z.DecStructFieldNotFound(-1, yys1194) - } // end switch yys1194 - } // end for yyj1194 + z.DecStructFieldNotFound(-1, yys1201) + } // end switch yys1201 + } // end for yyj1201 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -10291,16 +10359,16 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj1199 int - var yyb1199 bool - var yyhl1199 bool = l >= 0 - yyj1199++ - if yyhl1199 { - yyb1199 = yyj1199 > l + var yyj1206 int + var yyb1206 bool + var yyhl1206 bool = l >= 0 + yyj1206++ + if yyhl1206 { + yyb1206 = yyj1206 > l } else { - yyb1199 = r.CheckBreak() + yyb1206 = r.CheckBreak() } - if yyb1199 { + if yyb1206 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10310,13 +10378,13 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.EnableHostPathProvisioning = bool(r.DecodeBool()) } - yyj1199++ - if yyhl1199 { - yyb1199 = yyj1199 > l + yyj1206++ + if yyhl1206 { + yyb1206 = yyj1206 > l } else { - yyb1199 = r.CheckBreak() + yyb1206 = r.CheckBreak() } - if yyb1199 { + if yyb1206 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10326,13 +10394,13 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod } else { x.EnableDynamicProvisioning = bool(r.DecodeBool()) } - yyj1199++ - if yyhl1199 { - yyb1199 = yyj1199 > l + yyj1206++ + if yyhl1206 { + yyb1206 = yyj1206 > l } else { - yyb1199 = r.CheckBreak() + yyb1206 = r.CheckBreak() } - if yyb1199 { + if yyb1206 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10340,16 +10408,16 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod if r.TryDecodeAsNil() { x.PersistentVolumeRecyclerConfiguration = PersistentVolumeRecyclerConfiguration{} } else { - yyv1202 := &x.PersistentVolumeRecyclerConfiguration - yyv1202.CodecDecodeSelf(d) + yyv1209 := &x.PersistentVolumeRecyclerConfiguration + yyv1209.CodecDecodeSelf(d) } - yyj1199++ - if yyhl1199 { - yyb1199 = yyj1199 > l + yyj1206++ + if yyhl1206 { + yyb1206 = yyj1206 > l } else { - yyb1199 = r.CheckBreak() + yyb1206 = r.CheckBreak() } - if yyb1199 { + if yyb1206 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10360,17 +10428,17 @@ func (x *VolumeConfiguration) codecDecodeSelfFromArray(l int, d *codec1978.Decod x.FlexVolumePluginDir = string(r.DecodeString()) } for { - yyj1199++ - if yyhl1199 { - yyb1199 = yyj1199 > l + yyj1206++ + if yyhl1206 { + yyb1206 = yyj1206 > l } else { - yyb1199 = r.CheckBreak() + yyb1206 = r.CheckBreak() } - if yyb1199 { + if yyb1206 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj1199-1, "") + z.DecStructFieldNotFound(yyj1206-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -10382,33 +10450,33 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc if x == nil { r.EncodeNil() } else { - yym1204 := z.EncBinary() - _ = yym1204 + yym1211 := z.EncBinary() + _ = yym1211 if false { } else if z.HasExtensions() && z.EncExt(x) { } else { - yysep1205 := !z.EncBinary() - yy2arr1205 := z.EncBasicHandle().StructToArray - var yyq1205 [7]bool - _, _, _ = yysep1205, yyq1205, yy2arr1205 - const yyr1205 bool = false - var yynn1205 int - if yyr1205 || yy2arr1205 { + yysep1212 := !z.EncBinary() + yy2arr1212 := z.EncBasicHandle().StructToArray + var yyq1212 [7]bool + _, _, _ = yysep1212, yyq1212, yy2arr1212 + const yyr1212 bool = false + var yynn1212 int + if yyr1212 || yy2arr1212 { r.EncodeArrayStart(7) } else { - yynn1205 = 7 - for _, b := range yyq1205 { + yynn1212 = 7 + for _, b := range yyq1212 { if b { - yynn1205++ + yynn1212++ } } - r.EncodeMapStart(yynn1205) - yynn1205 = 0 + r.EncodeMapStart(yynn1212) + yynn1212 = 0 } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1207 := z.EncBinary() - _ = yym1207 + yym1214 := z.EncBinary() + _ = yym1214 if false { } else { r.EncodeInt(int64(x.MaximumRetry)) @@ -10417,17 +10485,17 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("maximumRetry")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1208 := z.EncBinary() - _ = yym1208 + yym1215 := z.EncBinary() + _ = yym1215 if false { } else { r.EncodeInt(int64(x.MaximumRetry)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1210 := z.EncBinary() - _ = yym1210 + yym1217 := z.EncBinary() + _ = yym1217 if false { } else { r.EncodeInt(int64(x.MinimumTimeoutNFS)) @@ -10436,17 +10504,17 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("minimumTimeoutNFS")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1211 := z.EncBinary() - _ = yym1211 + yym1218 := z.EncBinary() + _ = yym1218 if false { } else { r.EncodeInt(int64(x.MinimumTimeoutNFS)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1213 := z.EncBinary() - _ = yym1213 + yym1220 := z.EncBinary() + _ = yym1220 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathNFS)) @@ -10455,17 +10523,17 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("podTemplateFilePathNFS")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1214 := z.EncBinary() - _ = yym1214 + yym1221 := z.EncBinary() + _ = yym1221 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathNFS)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1216 := z.EncBinary() - _ = yym1216 + yym1223 := z.EncBinary() + _ = yym1223 if false { } else { r.EncodeInt(int64(x.IncrementTimeoutNFS)) @@ -10474,17 +10542,17 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("incrementTimeoutNFS")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1217 := z.EncBinary() - _ = yym1217 + yym1224 := z.EncBinary() + _ = yym1224 if false { } else { r.EncodeInt(int64(x.IncrementTimeoutNFS)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1219 := z.EncBinary() - _ = yym1219 + yym1226 := z.EncBinary() + _ = yym1226 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathHostPath)) @@ -10493,17 +10561,17 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("podTemplateFilePathHostPath")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1220 := z.EncBinary() - _ = yym1220 + yym1227 := z.EncBinary() + _ = yym1227 if false { } else { r.EncodeString(codecSelferC_UTF81234, string(x.PodTemplateFilePathHostPath)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1222 := z.EncBinary() - _ = yym1222 + yym1229 := z.EncBinary() + _ = yym1229 if false { } else { r.EncodeInt(int64(x.MinimumTimeoutHostPath)) @@ -10512,17 +10580,17 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("minimumTimeoutHostPath")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1223 := z.EncBinary() - _ = yym1223 + yym1230 := z.EncBinary() + _ = yym1230 if false { } else { r.EncodeInt(int64(x.MinimumTimeoutHostPath)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayElem1234) - yym1225 := z.EncBinary() - _ = yym1225 + yym1232 := z.EncBinary() + _ = yym1232 if false { } else { r.EncodeInt(int64(x.IncrementTimeoutHostPath)) @@ -10531,14 +10599,14 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecEncodeSelf(e *codec1978.Enc z.EncSendContainerState(codecSelfer_containerMapKey1234) r.EncodeString(codecSelferC_UTF81234, string("incrementTimeoutHostPath")) z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1226 := z.EncBinary() - _ = yym1226 + yym1233 := z.EncBinary() + _ = yym1233 if false { } else { r.EncodeInt(int64(x.IncrementTimeoutHostPath)) } } - if yyr1205 || yy2arr1205 { + if yyr1212 || yy2arr1212 { z.EncSendContainerState(codecSelfer_containerArrayEnd1234) } else { z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -10551,25 +10619,25 @@ func (x *PersistentVolumeRecyclerConfiguration) CodecDecodeSelf(d *codec1978.Dec var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yym1227 := z.DecBinary() - _ = yym1227 + yym1234 := z.DecBinary() + _ = yym1234 if false { } else if z.HasExtensions() && z.DecExt(x) { } else { - yyct1228 := r.ContainerType() - if yyct1228 == codecSelferValueTypeMap1234 { - yyl1228 := r.ReadMapStart() - if yyl1228 == 0 { + yyct1235 := r.ContainerType() + if yyct1235 == codecSelferValueTypeMap1234 { + yyl1235 := r.ReadMapStart() + if yyl1235 == 0 { z.DecSendContainerState(codecSelfer_containerMapEnd1234) } else { - x.codecDecodeSelfFromMap(yyl1228, d) + x.codecDecodeSelfFromMap(yyl1235, d) } - } else if yyct1228 == codecSelferValueTypeArray1234 { - yyl1228 := r.ReadArrayStart() - if yyl1228 == 0 { + } else if yyct1235 == codecSelferValueTypeArray1234 { + yyl1235 := r.ReadArrayStart() + if yyl1235 == 0 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } else { - x.codecDecodeSelfFromArray(yyl1228, d) + x.codecDecodeSelfFromArray(yyl1235, d) } } else { panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234) @@ -10581,12 +10649,12 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yys1229Slc = z.DecScratchBuffer() // default slice to decode into - _ = yys1229Slc - var yyhl1229 bool = l >= 0 - for yyj1229 := 0; ; yyj1229++ { - if yyhl1229 { - if yyj1229 >= l { + var yys1236Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys1236Slc + var yyhl1236 bool = l >= 0 + for yyj1236 := 0; ; yyj1236++ { + if yyhl1236 { + if yyj1236 >= l { break } } else { @@ -10595,10 +10663,10 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d } } z.DecSendContainerState(codecSelfer_containerMapKey1234) - yys1229Slc = r.DecodeBytes(yys1229Slc, true, true) - yys1229 := string(yys1229Slc) + yys1236Slc = r.DecodeBytes(yys1236Slc, true, true) + yys1236 := string(yys1236Slc) z.DecSendContainerState(codecSelfer_containerMapValue1234) - switch yys1229 { + switch yys1236 { case "maximumRetry": if r.TryDecodeAsNil() { x.MaximumRetry = 0 @@ -10642,9 +10710,9 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromMap(l int, d x.IncrementTimeoutHostPath = int32(r.DecodeInt(32)) } default: - z.DecStructFieldNotFound(-1, yys1229) - } // end switch yys1229 - } // end for yyj1229 + z.DecStructFieldNotFound(-1, yys1236) + } // end switch yys1236 + } // end for yyj1236 z.DecSendContainerState(codecSelfer_containerMapEnd1234) } @@ -10652,16 +10720,16 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, var h codecSelfer1234 z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - var yyj1237 int - var yyb1237 bool - var yyhl1237 bool = l >= 0 - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + var yyj1244 int + var yyb1244 bool + var yyhl1244 bool = l >= 0 + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10671,13 +10739,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, } else { x.MaximumRetry = int32(r.DecodeInt(32)) } - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10687,13 +10755,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, } else { x.MinimumTimeoutNFS = int32(r.DecodeInt(32)) } - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10703,13 +10771,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, } else { x.PodTemplateFilePathNFS = string(r.DecodeString()) } - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10719,13 +10787,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, } else { x.IncrementTimeoutNFS = int32(r.DecodeInt(32)) } - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10735,13 +10803,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, } else { x.PodTemplateFilePathHostPath = string(r.DecodeString()) } - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10751,13 +10819,13 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, } else { x.MinimumTimeoutHostPath = int32(r.DecodeInt(32)) } - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { z.DecSendContainerState(codecSelfer_containerArrayEnd1234) return } @@ -10768,17 +10836,17 @@ func (x *PersistentVolumeRecyclerConfiguration) codecDecodeSelfFromArray(l int, x.IncrementTimeoutHostPath = int32(r.DecodeInt(32)) } for { - yyj1237++ - if yyhl1237 { - yyb1237 = yyj1237 > l + yyj1244++ + if yyhl1244 { + yyb1244 = yyj1244 > l } else { - yyb1237 = r.CheckBreak() + yyb1244 = r.CheckBreak() } - if yyb1237 { + if yyb1244 { break } z.DecSendContainerState(codecSelfer_containerArrayElem1234) - z.DecStructFieldNotFound(yyj1237-1, "") + z.DecStructFieldNotFound(yyj1244-1, "") } z.DecSendContainerState(codecSelfer_containerArrayEnd1234) } @@ -10788,20 +10856,20 @@ func (x codecSelfer1234) encconfig_ConfigurationMap(v pkg2_config.ConfigurationM z, r := codec1978.GenHelperEncoder(e) _, _, _ = h, z, r r.EncodeMapStart(len(v)) - for yyk1245, yyv1245 := range v { + for yyk1252, yyv1252 := range v { z.EncSendContainerState(codecSelfer_containerMapKey1234) - yym1246 := z.EncBinary() - _ = yym1246 + yym1253 := z.EncBinary() + _ = yym1253 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(yyk1245)) + r.EncodeString(codecSelferC_UTF81234, string(yyk1252)) } z.EncSendContainerState(codecSelfer_containerMapValue1234) - yym1247 := z.EncBinary() - _ = yym1247 + yym1254 := z.EncBinary() + _ = yym1254 if false { } else { - r.EncodeString(codecSelferC_UTF81234, string(yyv1245)) + r.EncodeString(codecSelferC_UTF81234, string(yyv1252)) } } z.EncSendContainerState(codecSelfer_containerMapEnd1234) @@ -10812,63 +10880,63 @@ func (x codecSelfer1234) decconfig_ConfigurationMap(v *pkg2_config.Configuration z, r := codec1978.GenHelperDecoder(d) _, _, _ = h, z, r - yyv1248 := *v - yyl1248 := r.ReadMapStart() - yybh1248 := z.DecBasicHandle() - if yyv1248 == nil { - yyrl1248, _ := z.DecInferLen(yyl1248, yybh1248.MaxInitLen, 32) - yyv1248 = make(map[string]string, yyrl1248) - *v = yyv1248 + yyv1255 := *v + yyl1255 := r.ReadMapStart() + yybh1255 := z.DecBasicHandle() + if yyv1255 == nil { + yyrl1255, _ := z.DecInferLen(yyl1255, yybh1255.MaxInitLen, 32) + yyv1255 = make(map[string]string, yyrl1255) + *v = yyv1255 } - var yymk1248 string - var yymv1248 string - var yymg1248 bool - if yybh1248.MapValueReset { + var yymk1255 string + var yymv1255 string + var yymg1255 bool + if yybh1255.MapValueReset { } - if yyl1248 > 0 { - for yyj1248 := 0; yyj1248 < yyl1248; yyj1248++ { + if yyl1255 > 0 { + for yyj1255 := 0; yyj1255 < yyl1255; yyj1255++ { z.DecSendContainerState(codecSelfer_containerMapKey1234) if r.TryDecodeAsNil() { - yymk1248 = "" + yymk1255 = "" } else { - yymk1248 = string(r.DecodeString()) + yymk1255 = string(r.DecodeString()) } - if yymg1248 { - yymv1248 = yyv1248[yymk1248] + if yymg1255 { + yymv1255 = yyv1255[yymk1255] } z.DecSendContainerState(codecSelfer_containerMapValue1234) if r.TryDecodeAsNil() { - yymv1248 = "" + yymv1255 = "" } else { - yymv1248 = string(r.DecodeString()) + yymv1255 = string(r.DecodeString()) } - if yyv1248 != nil { - yyv1248[yymk1248] = yymv1248 + if yyv1255 != nil { + yyv1255[yymk1255] = yymv1255 } } - } else if yyl1248 < 0 { - for yyj1248 := 0; !r.CheckBreak(); yyj1248++ { + } else if yyl1255 < 0 { + for yyj1255 := 0; !r.CheckBreak(); yyj1255++ { z.DecSendContainerState(codecSelfer_containerMapKey1234) if r.TryDecodeAsNil() { - yymk1248 = "" + yymk1255 = "" } else { - yymk1248 = string(r.DecodeString()) + yymk1255 = string(r.DecodeString()) } - if yymg1248 { - yymv1248 = yyv1248[yymk1248] + if yymg1255 { + yymv1255 = yyv1255[yymk1255] } z.DecSendContainerState(codecSelfer_containerMapValue1234) if r.TryDecodeAsNil() { - yymv1248 = "" + yymv1255 = "" } else { - yymv1248 = string(r.DecodeString()) + yymv1255 = string(r.DecodeString()) } - if yyv1248 != nil { - yyv1248[yymk1248] = yymv1248 + if yyv1255 != nil { + yyv1255[yymk1255] = yymv1255 } } } // else len==0: TODO: Should we clear map entries? diff --git a/pkg/apis/componentconfig/v1alpha1/zz_generated.conversion.go b/pkg/apis/componentconfig/v1alpha1/zz_generated.conversion.go index 2911e45aeee..d5dc36acec4 100644 --- a/pkg/apis/componentconfig/v1alpha1/zz_generated.conversion.go +++ b/pkg/apis/componentconfig/v1alpha1/zz_generated.conversion.go @@ -332,6 +332,7 @@ func autoConvert_v1alpha1_KubeletConfiguration_To_componentconfig_KubeletConfigu if err := api.Convert_Pointer_int32_To_int32(&in.IPTablesDropBit, &out.IPTablesDropBit, s); err != nil { return err } + out.AllowedUnsafeSysctls = in.AllowedUnsafeSysctls return nil } @@ -509,6 +510,7 @@ func autoConvert_componentconfig_KubeletConfiguration_To_v1alpha1_KubeletConfigu if err := api.Convert_int32_To_Pointer_int32(&in.IPTablesDropBit, &out.IPTablesDropBit, s); err != nil { return err } + out.AllowedUnsafeSysctls = in.AllowedUnsafeSysctls return nil } diff --git a/pkg/apis/componentconfig/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/componentconfig/v1alpha1/zz_generated.deepcopy.go index 121860a74d1..952ce0de60e 100644 --- a/pkg/apis/componentconfig/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/componentconfig/v1alpha1/zz_generated.deepcopy.go @@ -402,6 +402,13 @@ func DeepCopy_v1alpha1_KubeletConfiguration(in interface{}, out interface{}, c * } else { out.IPTablesDropBit = nil } + if in.AllowedUnsafeSysctls != nil { + in, out := &in.AllowedUnsafeSysctls, &out.AllowedUnsafeSysctls + *out = make([]string, len(*in)) + copy(*out, *in) + } else { + out.AllowedUnsafeSysctls = nil + } return nil } } diff --git a/pkg/apis/componentconfig/zz_generated.deepcopy.go b/pkg/apis/componentconfig/zz_generated.deepcopy.go index b3d40c826be..7f3dd1b15f5 100644 --- a/pkg/apis/componentconfig/zz_generated.deepcopy.go +++ b/pkg/apis/componentconfig/zz_generated.deepcopy.go @@ -337,6 +337,13 @@ func DeepCopy_componentconfig_KubeletConfiguration(in interface{}, out interface out.MakeIPTablesUtilChains = in.MakeIPTablesUtilChains out.IPTablesMasqueradeBit = in.IPTablesMasqueradeBit out.IPTablesDropBit = in.IPTablesDropBit + if in.AllowedUnsafeSysctls != nil { + in, out := &in.AllowedUnsafeSysctls, &out.AllowedUnsafeSysctls + *out = make([]string, len(*in)) + copy(*out, *in) + } else { + out.AllowedUnsafeSysctls = nil + } return nil } }