1// +build !ignore_autogenerated 2 3/* 4Copyright 2017 The Kubernetes Authors. 5 6Licensed under the Apache License, Version 2.0 (the "License"); 7you may not use this file except in compliance with the License. 8You may obtain a copy of the License at 9 10 http://www.apache.org/licenses/LICENSE-2.0 11 12Unless required by applicable law or agreed to in writing, software 13distributed under the License is distributed on an "AS IS" BASIS, 14WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15See the License for the specific language governing permissions and 16limitations under the License. 17*/ 18 19// This file was autogenerated by deepcopy-gen. Do not edit it manually! 20 21package api 22 23import ( 24 v1 "k8s.io/apimachinery/pkg/apis/meta/v1" 25 conversion "k8s.io/apimachinery/pkg/conversion" 26 fields "k8s.io/apimachinery/pkg/fields" 27 labels "k8s.io/apimachinery/pkg/labels" 28 runtime "k8s.io/apimachinery/pkg/runtime" 29 types "k8s.io/apimachinery/pkg/types" 30 reflect "reflect" 31) 32 33func init() { 34 SchemeBuilder.Register(RegisterDeepCopies) 35} 36 37// RegisterDeepCopies adds deep-copy functions to the given scheme. Public 38// to allow building arbitrary schemes. 39func RegisterDeepCopies(scheme *runtime.Scheme) error { 40 return scheme.AddGeneratedDeepCopyFuncs( 41 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_AWSElasticBlockStoreVolumeSource, InType: reflect.TypeOf(&AWSElasticBlockStoreVolumeSource{})}, 42 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Affinity, InType: reflect.TypeOf(&Affinity{})}, 43 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_AttachedVolume, InType: reflect.TypeOf(&AttachedVolume{})}, 44 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_AvoidPods, InType: reflect.TypeOf(&AvoidPods{})}, 45 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_AzureDiskVolumeSource, InType: reflect.TypeOf(&AzureDiskVolumeSource{})}, 46 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_AzureFileVolumeSource, InType: reflect.TypeOf(&AzureFileVolumeSource{})}, 47 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Binding, InType: reflect.TypeOf(&Binding{})}, 48 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Capabilities, InType: reflect.TypeOf(&Capabilities{})}, 49 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_CephFSVolumeSource, InType: reflect.TypeOf(&CephFSVolumeSource{})}, 50 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_CinderVolumeSource, InType: reflect.TypeOf(&CinderVolumeSource{})}, 51 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ComponentCondition, InType: reflect.TypeOf(&ComponentCondition{})}, 52 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ComponentStatus, InType: reflect.TypeOf(&ComponentStatus{})}, 53 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ComponentStatusList, InType: reflect.TypeOf(&ComponentStatusList{})}, 54 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConfigMap, InType: reflect.TypeOf(&ConfigMap{})}, 55 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConfigMapEnvSource, InType: reflect.TypeOf(&ConfigMapEnvSource{})}, 56 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConfigMapKeySelector, InType: reflect.TypeOf(&ConfigMapKeySelector{})}, 57 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConfigMapList, InType: reflect.TypeOf(&ConfigMapList{})}, 58 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConfigMapProjection, InType: reflect.TypeOf(&ConfigMapProjection{})}, 59 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConfigMapVolumeSource, InType: reflect.TypeOf(&ConfigMapVolumeSource{})}, 60 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Container, InType: reflect.TypeOf(&Container{})}, 61 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerImage, InType: reflect.TypeOf(&ContainerImage{})}, 62 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerPort, InType: reflect.TypeOf(&ContainerPort{})}, 63 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerState, InType: reflect.TypeOf(&ContainerState{})}, 64 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerStateRunning, InType: reflect.TypeOf(&ContainerStateRunning{})}, 65 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerStateTerminated, InType: reflect.TypeOf(&ContainerStateTerminated{})}, 66 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerStateWaiting, InType: reflect.TypeOf(&ContainerStateWaiting{})}, 67 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ContainerStatus, InType: reflect.TypeOf(&ContainerStatus{})}, 68 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ConversionError, InType: reflect.TypeOf(&ConversionError{})}, 69 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_DaemonEndpoint, InType: reflect.TypeOf(&DaemonEndpoint{})}, 70 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_DeleteOptions, InType: reflect.TypeOf(&DeleteOptions{})}, 71 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_DownwardAPIProjection, InType: reflect.TypeOf(&DownwardAPIProjection{})}, 72 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_DownwardAPIVolumeFile, InType: reflect.TypeOf(&DownwardAPIVolumeFile{})}, 73 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_DownwardAPIVolumeSource, InType: reflect.TypeOf(&DownwardAPIVolumeSource{})}, 74 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EmptyDirVolumeSource, InType: reflect.TypeOf(&EmptyDirVolumeSource{})}, 75 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EndpointAddress, InType: reflect.TypeOf(&EndpointAddress{})}, 76 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EndpointPort, InType: reflect.TypeOf(&EndpointPort{})}, 77 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EndpointSubset, InType: reflect.TypeOf(&EndpointSubset{})}, 78 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Endpoints, InType: reflect.TypeOf(&Endpoints{})}, 79 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EndpointsList, InType: reflect.TypeOf(&EndpointsList{})}, 80 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EnvFromSource, InType: reflect.TypeOf(&EnvFromSource{})}, 81 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EnvVar, InType: reflect.TypeOf(&EnvVar{})}, 82 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EnvVarSource, InType: reflect.TypeOf(&EnvVarSource{})}, 83 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Event, InType: reflect.TypeOf(&Event{})}, 84 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EventList, InType: reflect.TypeOf(&EventList{})}, 85 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_EventSource, InType: reflect.TypeOf(&EventSource{})}, 86 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ExecAction, InType: reflect.TypeOf(&ExecAction{})}, 87 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_FCVolumeSource, InType: reflect.TypeOf(&FCVolumeSource{})}, 88 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_FlexVolumeSource, InType: reflect.TypeOf(&FlexVolumeSource{})}, 89 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_FlockerVolumeSource, InType: reflect.TypeOf(&FlockerVolumeSource{})}, 90 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_GCEPersistentDiskVolumeSource, InType: reflect.TypeOf(&GCEPersistentDiskVolumeSource{})}, 91 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_GitRepoVolumeSource, InType: reflect.TypeOf(&GitRepoVolumeSource{})}, 92 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_GlusterfsVolumeSource, InType: reflect.TypeOf(&GlusterfsVolumeSource{})}, 93 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_HTTPGetAction, InType: reflect.TypeOf(&HTTPGetAction{})}, 94 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_HTTPHeader, InType: reflect.TypeOf(&HTTPHeader{})}, 95 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Handler, InType: reflect.TypeOf(&Handler{})}, 96 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_HostPathVolumeSource, InType: reflect.TypeOf(&HostPathVolumeSource{})}, 97 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ISCSIVolumeSource, InType: reflect.TypeOf(&ISCSIVolumeSource{})}, 98 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_KeyToPath, InType: reflect.TypeOf(&KeyToPath{})}, 99 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Lifecycle, InType: reflect.TypeOf(&Lifecycle{})}, 100 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LimitRange, InType: reflect.TypeOf(&LimitRange{})}, 101 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LimitRangeItem, InType: reflect.TypeOf(&LimitRangeItem{})}, 102 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LimitRangeList, InType: reflect.TypeOf(&LimitRangeList{})}, 103 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LimitRangeSpec, InType: reflect.TypeOf(&LimitRangeSpec{})}, 104 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_List, InType: reflect.TypeOf(&List{})}, 105 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ListOptions, InType: reflect.TypeOf(&ListOptions{})}, 106 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LoadBalancerIngress, InType: reflect.TypeOf(&LoadBalancerIngress{})}, 107 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LoadBalancerStatus, InType: reflect.TypeOf(&LoadBalancerStatus{})}, 108 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_LocalObjectReference, InType: reflect.TypeOf(&LocalObjectReference{})}, 109 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NFSVolumeSource, InType: reflect.TypeOf(&NFSVolumeSource{})}, 110 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Namespace, InType: reflect.TypeOf(&Namespace{})}, 111 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NamespaceList, InType: reflect.TypeOf(&NamespaceList{})}, 112 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NamespaceSpec, InType: reflect.TypeOf(&NamespaceSpec{})}, 113 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NamespaceStatus, InType: reflect.TypeOf(&NamespaceStatus{})}, 114 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Node, InType: reflect.TypeOf(&Node{})}, 115 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeAddress, InType: reflect.TypeOf(&NodeAddress{})}, 116 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeAffinity, InType: reflect.TypeOf(&NodeAffinity{})}, 117 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeCondition, InType: reflect.TypeOf(&NodeCondition{})}, 118 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeDaemonEndpoints, InType: reflect.TypeOf(&NodeDaemonEndpoints{})}, 119 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeList, InType: reflect.TypeOf(&NodeList{})}, 120 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeProxyOptions, InType: reflect.TypeOf(&NodeProxyOptions{})}, 121 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeResources, InType: reflect.TypeOf(&NodeResources{})}, 122 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeSelector, InType: reflect.TypeOf(&NodeSelector{})}, 123 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeSelectorRequirement, InType: reflect.TypeOf(&NodeSelectorRequirement{})}, 124 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeSelectorTerm, InType: reflect.TypeOf(&NodeSelectorTerm{})}, 125 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeSpec, InType: reflect.TypeOf(&NodeSpec{})}, 126 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeStatus, InType: reflect.TypeOf(&NodeStatus{})}, 127 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_NodeSystemInfo, InType: reflect.TypeOf(&NodeSystemInfo{})}, 128 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ObjectFieldSelector, InType: reflect.TypeOf(&ObjectFieldSelector{})}, 129 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ObjectMeta, InType: reflect.TypeOf(&ObjectMeta{})}, 130 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ObjectReference, InType: reflect.TypeOf(&ObjectReference{})}, 131 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolume, InType: reflect.TypeOf(&PersistentVolume{})}, 132 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeClaim, InType: reflect.TypeOf(&PersistentVolumeClaim{})}, 133 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeClaimList, InType: reflect.TypeOf(&PersistentVolumeClaimList{})}, 134 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeClaimSpec, InType: reflect.TypeOf(&PersistentVolumeClaimSpec{})}, 135 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeClaimStatus, InType: reflect.TypeOf(&PersistentVolumeClaimStatus{})}, 136 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeClaimVolumeSource, InType: reflect.TypeOf(&PersistentVolumeClaimVolumeSource{})}, 137 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeList, InType: reflect.TypeOf(&PersistentVolumeList{})}, 138 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeSource, InType: reflect.TypeOf(&PersistentVolumeSource{})}, 139 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeSpec, InType: reflect.TypeOf(&PersistentVolumeSpec{})}, 140 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PersistentVolumeStatus, InType: reflect.TypeOf(&PersistentVolumeStatus{})}, 141 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PhotonPersistentDiskVolumeSource, InType: reflect.TypeOf(&PhotonPersistentDiskVolumeSource{})}, 142 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Pod, InType: reflect.TypeOf(&Pod{})}, 143 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodAffinity, InType: reflect.TypeOf(&PodAffinity{})}, 144 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodAffinityTerm, InType: reflect.TypeOf(&PodAffinityTerm{})}, 145 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodAntiAffinity, InType: reflect.TypeOf(&PodAntiAffinity{})}, 146 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodAttachOptions, InType: reflect.TypeOf(&PodAttachOptions{})}, 147 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodCondition, InType: reflect.TypeOf(&PodCondition{})}, 148 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodExecOptions, InType: reflect.TypeOf(&PodExecOptions{})}, 149 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodList, InType: reflect.TypeOf(&PodList{})}, 150 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodLogOptions, InType: reflect.TypeOf(&PodLogOptions{})}, 151 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodPortForwardOptions, InType: reflect.TypeOf(&PodPortForwardOptions{})}, 152 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodProxyOptions, InType: reflect.TypeOf(&PodProxyOptions{})}, 153 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodSecurityContext, InType: reflect.TypeOf(&PodSecurityContext{})}, 154 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodSignature, InType: reflect.TypeOf(&PodSignature{})}, 155 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodSpec, InType: reflect.TypeOf(&PodSpec{})}, 156 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodStatus, InType: reflect.TypeOf(&PodStatus{})}, 157 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodStatusResult, InType: reflect.TypeOf(&PodStatusResult{})}, 158 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodTemplate, InType: reflect.TypeOf(&PodTemplate{})}, 159 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodTemplateList, InType: reflect.TypeOf(&PodTemplateList{})}, 160 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PodTemplateSpec, InType: reflect.TypeOf(&PodTemplateSpec{})}, 161 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PortworxVolumeSource, InType: reflect.TypeOf(&PortworxVolumeSource{})}, 162 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Preconditions, InType: reflect.TypeOf(&Preconditions{})}, 163 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PreferAvoidPodsEntry, InType: reflect.TypeOf(&PreferAvoidPodsEntry{})}, 164 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_PreferredSchedulingTerm, InType: reflect.TypeOf(&PreferredSchedulingTerm{})}, 165 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Probe, InType: reflect.TypeOf(&Probe{})}, 166 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ProjectedVolumeSource, InType: reflect.TypeOf(&ProjectedVolumeSource{})}, 167 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_QuobyteVolumeSource, InType: reflect.TypeOf(&QuobyteVolumeSource{})}, 168 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_RBDVolumeSource, InType: reflect.TypeOf(&RBDVolumeSource{})}, 169 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_RangeAllocation, InType: reflect.TypeOf(&RangeAllocation{})}, 170 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ReplicationController, InType: reflect.TypeOf(&ReplicationController{})}, 171 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ReplicationControllerCondition, InType: reflect.TypeOf(&ReplicationControllerCondition{})}, 172 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ReplicationControllerList, InType: reflect.TypeOf(&ReplicationControllerList{})}, 173 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ReplicationControllerSpec, InType: reflect.TypeOf(&ReplicationControllerSpec{})}, 174 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ReplicationControllerStatus, InType: reflect.TypeOf(&ReplicationControllerStatus{})}, 175 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ResourceFieldSelector, InType: reflect.TypeOf(&ResourceFieldSelector{})}, 176 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ResourceQuota, InType: reflect.TypeOf(&ResourceQuota{})}, 177 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ResourceQuotaList, InType: reflect.TypeOf(&ResourceQuotaList{})}, 178 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ResourceQuotaSpec, InType: reflect.TypeOf(&ResourceQuotaSpec{})}, 179 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ResourceQuotaStatus, InType: reflect.TypeOf(&ResourceQuotaStatus{})}, 180 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ResourceRequirements, InType: reflect.TypeOf(&ResourceRequirements{})}, 181 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SELinuxOptions, InType: reflect.TypeOf(&SELinuxOptions{})}, 182 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ScaleIOVolumeSource, InType: reflect.TypeOf(&ScaleIOVolumeSource{})}, 183 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Secret, InType: reflect.TypeOf(&Secret{})}, 184 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SecretEnvSource, InType: reflect.TypeOf(&SecretEnvSource{})}, 185 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SecretKeySelector, InType: reflect.TypeOf(&SecretKeySelector{})}, 186 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SecretList, InType: reflect.TypeOf(&SecretList{})}, 187 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SecretProjection, InType: reflect.TypeOf(&SecretProjection{})}, 188 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SecretVolumeSource, InType: reflect.TypeOf(&SecretVolumeSource{})}, 189 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SecurityContext, InType: reflect.TypeOf(&SecurityContext{})}, 190 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_SerializedReference, InType: reflect.TypeOf(&SerializedReference{})}, 191 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Service, InType: reflect.TypeOf(&Service{})}, 192 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceAccount, InType: reflect.TypeOf(&ServiceAccount{})}, 193 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceAccountList, InType: reflect.TypeOf(&ServiceAccountList{})}, 194 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceList, InType: reflect.TypeOf(&ServiceList{})}, 195 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServicePort, InType: reflect.TypeOf(&ServicePort{})}, 196 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceProxyOptions, InType: reflect.TypeOf(&ServiceProxyOptions{})}, 197 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceSpec, InType: reflect.TypeOf(&ServiceSpec{})}, 198 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_ServiceStatus, InType: reflect.TypeOf(&ServiceStatus{})}, 199 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Sysctl, InType: reflect.TypeOf(&Sysctl{})}, 200 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_TCPSocketAction, InType: reflect.TypeOf(&TCPSocketAction{})}, 201 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Taint, InType: reflect.TypeOf(&Taint{})}, 202 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Toleration, InType: reflect.TypeOf(&Toleration{})}, 203 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_Volume, InType: reflect.TypeOf(&Volume{})}, 204 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_VolumeMount, InType: reflect.TypeOf(&VolumeMount{})}, 205 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_VolumeProjection, InType: reflect.TypeOf(&VolumeProjection{})}, 206 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_VolumeSource, InType: reflect.TypeOf(&VolumeSource{})}, 207 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_VsphereVirtualDiskVolumeSource, InType: reflect.TypeOf(&VsphereVirtualDiskVolumeSource{})}, 208 conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_api_WeightedPodAffinityTerm, InType: reflect.TypeOf(&WeightedPodAffinityTerm{})}, 209 ) 210} 211 212func DeepCopy_api_AWSElasticBlockStoreVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 213 { 214 in := in.(*AWSElasticBlockStoreVolumeSource) 215 out := out.(*AWSElasticBlockStoreVolumeSource) 216 *out = *in 217 return nil 218 } 219} 220 221func DeepCopy_api_Affinity(in interface{}, out interface{}, c *conversion.Cloner) error { 222 { 223 in := in.(*Affinity) 224 out := out.(*Affinity) 225 *out = *in 226 if in.NodeAffinity != nil { 227 in, out := &in.NodeAffinity, &out.NodeAffinity 228 *out = new(NodeAffinity) 229 if err := DeepCopy_api_NodeAffinity(*in, *out, c); err != nil { 230 return err 231 } 232 } 233 if in.PodAffinity != nil { 234 in, out := &in.PodAffinity, &out.PodAffinity 235 *out = new(PodAffinity) 236 if err := DeepCopy_api_PodAffinity(*in, *out, c); err != nil { 237 return err 238 } 239 } 240 if in.PodAntiAffinity != nil { 241 in, out := &in.PodAntiAffinity, &out.PodAntiAffinity 242 *out = new(PodAntiAffinity) 243 if err := DeepCopy_api_PodAntiAffinity(*in, *out, c); err != nil { 244 return err 245 } 246 } 247 return nil 248 } 249} 250 251func DeepCopy_api_AttachedVolume(in interface{}, out interface{}, c *conversion.Cloner) error { 252 { 253 in := in.(*AttachedVolume) 254 out := out.(*AttachedVolume) 255 *out = *in 256 return nil 257 } 258} 259 260func DeepCopy_api_AvoidPods(in interface{}, out interface{}, c *conversion.Cloner) error { 261 { 262 in := in.(*AvoidPods) 263 out := out.(*AvoidPods) 264 *out = *in 265 if in.PreferAvoidPods != nil { 266 in, out := &in.PreferAvoidPods, &out.PreferAvoidPods 267 *out = make([]PreferAvoidPodsEntry, len(*in)) 268 for i := range *in { 269 if err := DeepCopy_api_PreferAvoidPodsEntry(&(*in)[i], &(*out)[i], c); err != nil { 270 return err 271 } 272 } 273 } 274 return nil 275 } 276} 277 278func DeepCopy_api_AzureDiskVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 279 { 280 in := in.(*AzureDiskVolumeSource) 281 out := out.(*AzureDiskVolumeSource) 282 *out = *in 283 if in.CachingMode != nil { 284 in, out := &in.CachingMode, &out.CachingMode 285 *out = new(AzureDataDiskCachingMode) 286 **out = **in 287 } 288 if in.FSType != nil { 289 in, out := &in.FSType, &out.FSType 290 *out = new(string) 291 **out = **in 292 } 293 if in.ReadOnly != nil { 294 in, out := &in.ReadOnly, &out.ReadOnly 295 *out = new(bool) 296 **out = **in 297 } 298 return nil 299 } 300} 301 302func DeepCopy_api_AzureFileVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 303 { 304 in := in.(*AzureFileVolumeSource) 305 out := out.(*AzureFileVolumeSource) 306 *out = *in 307 return nil 308 } 309} 310 311func DeepCopy_api_Binding(in interface{}, out interface{}, c *conversion.Cloner) error { 312 { 313 in := in.(*Binding) 314 out := out.(*Binding) 315 *out = *in 316 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 317 return err 318 } else { 319 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 320 } 321 return nil 322 } 323} 324 325func DeepCopy_api_Capabilities(in interface{}, out interface{}, c *conversion.Cloner) error { 326 { 327 in := in.(*Capabilities) 328 out := out.(*Capabilities) 329 *out = *in 330 if in.Add != nil { 331 in, out := &in.Add, &out.Add 332 *out = make([]Capability, len(*in)) 333 copy(*out, *in) 334 } 335 if in.Drop != nil { 336 in, out := &in.Drop, &out.Drop 337 *out = make([]Capability, len(*in)) 338 copy(*out, *in) 339 } 340 return nil 341 } 342} 343 344func DeepCopy_api_CephFSVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 345 { 346 in := in.(*CephFSVolumeSource) 347 out := out.(*CephFSVolumeSource) 348 *out = *in 349 if in.Monitors != nil { 350 in, out := &in.Monitors, &out.Monitors 351 *out = make([]string, len(*in)) 352 copy(*out, *in) 353 } 354 if in.SecretRef != nil { 355 in, out := &in.SecretRef, &out.SecretRef 356 *out = new(LocalObjectReference) 357 **out = **in 358 } 359 return nil 360 } 361} 362 363func DeepCopy_api_CinderVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 364 { 365 in := in.(*CinderVolumeSource) 366 out := out.(*CinderVolumeSource) 367 *out = *in 368 return nil 369 } 370} 371 372func DeepCopy_api_ComponentCondition(in interface{}, out interface{}, c *conversion.Cloner) error { 373 { 374 in := in.(*ComponentCondition) 375 out := out.(*ComponentCondition) 376 *out = *in 377 return nil 378 } 379} 380 381func DeepCopy_api_ComponentStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 382 { 383 in := in.(*ComponentStatus) 384 out := out.(*ComponentStatus) 385 *out = *in 386 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 387 return err 388 } else { 389 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 390 } 391 if in.Conditions != nil { 392 in, out := &in.Conditions, &out.Conditions 393 *out = make([]ComponentCondition, len(*in)) 394 copy(*out, *in) 395 } 396 return nil 397 } 398} 399 400func DeepCopy_api_ComponentStatusList(in interface{}, out interface{}, c *conversion.Cloner) error { 401 { 402 in := in.(*ComponentStatusList) 403 out := out.(*ComponentStatusList) 404 *out = *in 405 if in.Items != nil { 406 in, out := &in.Items, &out.Items 407 *out = make([]ComponentStatus, len(*in)) 408 for i := range *in { 409 if err := DeepCopy_api_ComponentStatus(&(*in)[i], &(*out)[i], c); err != nil { 410 return err 411 } 412 } 413 } 414 return nil 415 } 416} 417 418func DeepCopy_api_ConfigMap(in interface{}, out interface{}, c *conversion.Cloner) error { 419 { 420 in := in.(*ConfigMap) 421 out := out.(*ConfigMap) 422 *out = *in 423 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 424 return err 425 } else { 426 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 427 } 428 if in.Data != nil { 429 in, out := &in.Data, &out.Data 430 *out = make(map[string]string) 431 for key, val := range *in { 432 (*out)[key] = val 433 } 434 } 435 return nil 436 } 437} 438 439func DeepCopy_api_ConfigMapEnvSource(in interface{}, out interface{}, c *conversion.Cloner) error { 440 { 441 in := in.(*ConfigMapEnvSource) 442 out := out.(*ConfigMapEnvSource) 443 *out = *in 444 if in.Optional != nil { 445 in, out := &in.Optional, &out.Optional 446 *out = new(bool) 447 **out = **in 448 } 449 return nil 450 } 451} 452 453func DeepCopy_api_ConfigMapKeySelector(in interface{}, out interface{}, c *conversion.Cloner) error { 454 { 455 in := in.(*ConfigMapKeySelector) 456 out := out.(*ConfigMapKeySelector) 457 *out = *in 458 if in.Optional != nil { 459 in, out := &in.Optional, &out.Optional 460 *out = new(bool) 461 **out = **in 462 } 463 return nil 464 } 465} 466 467func DeepCopy_api_ConfigMapList(in interface{}, out interface{}, c *conversion.Cloner) error { 468 { 469 in := in.(*ConfigMapList) 470 out := out.(*ConfigMapList) 471 *out = *in 472 if in.Items != nil { 473 in, out := &in.Items, &out.Items 474 *out = make([]ConfigMap, len(*in)) 475 for i := range *in { 476 if err := DeepCopy_api_ConfigMap(&(*in)[i], &(*out)[i], c); err != nil { 477 return err 478 } 479 } 480 } 481 return nil 482 } 483} 484 485func DeepCopy_api_ConfigMapProjection(in interface{}, out interface{}, c *conversion.Cloner) error { 486 { 487 in := in.(*ConfigMapProjection) 488 out := out.(*ConfigMapProjection) 489 *out = *in 490 if in.Items != nil { 491 in, out := &in.Items, &out.Items 492 *out = make([]KeyToPath, len(*in)) 493 for i := range *in { 494 if err := DeepCopy_api_KeyToPath(&(*in)[i], &(*out)[i], c); err != nil { 495 return err 496 } 497 } 498 } 499 if in.Optional != nil { 500 in, out := &in.Optional, &out.Optional 501 *out = new(bool) 502 **out = **in 503 } 504 return nil 505 } 506} 507 508func DeepCopy_api_ConfigMapVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 509 { 510 in := in.(*ConfigMapVolumeSource) 511 out := out.(*ConfigMapVolumeSource) 512 *out = *in 513 if in.Items != nil { 514 in, out := &in.Items, &out.Items 515 *out = make([]KeyToPath, len(*in)) 516 for i := range *in { 517 if err := DeepCopy_api_KeyToPath(&(*in)[i], &(*out)[i], c); err != nil { 518 return err 519 } 520 } 521 } 522 if in.DefaultMode != nil { 523 in, out := &in.DefaultMode, &out.DefaultMode 524 *out = new(int32) 525 **out = **in 526 } 527 if in.Optional != nil { 528 in, out := &in.Optional, &out.Optional 529 *out = new(bool) 530 **out = **in 531 } 532 return nil 533 } 534} 535 536func DeepCopy_api_Container(in interface{}, out interface{}, c *conversion.Cloner) error { 537 { 538 in := in.(*Container) 539 out := out.(*Container) 540 *out = *in 541 if in.Command != nil { 542 in, out := &in.Command, &out.Command 543 *out = make([]string, len(*in)) 544 copy(*out, *in) 545 } 546 if in.Args != nil { 547 in, out := &in.Args, &out.Args 548 *out = make([]string, len(*in)) 549 copy(*out, *in) 550 } 551 if in.Ports != nil { 552 in, out := &in.Ports, &out.Ports 553 *out = make([]ContainerPort, len(*in)) 554 copy(*out, *in) 555 } 556 if in.EnvFrom != nil { 557 in, out := &in.EnvFrom, &out.EnvFrom 558 *out = make([]EnvFromSource, len(*in)) 559 for i := range *in { 560 if err := DeepCopy_api_EnvFromSource(&(*in)[i], &(*out)[i], c); err != nil { 561 return err 562 } 563 } 564 } 565 if in.Env != nil { 566 in, out := &in.Env, &out.Env 567 *out = make([]EnvVar, len(*in)) 568 for i := range *in { 569 if err := DeepCopy_api_EnvVar(&(*in)[i], &(*out)[i], c); err != nil { 570 return err 571 } 572 } 573 } 574 if err := DeepCopy_api_ResourceRequirements(&in.Resources, &out.Resources, c); err != nil { 575 return err 576 } 577 if in.VolumeMounts != nil { 578 in, out := &in.VolumeMounts, &out.VolumeMounts 579 *out = make([]VolumeMount, len(*in)) 580 copy(*out, *in) 581 } 582 if in.LivenessProbe != nil { 583 in, out := &in.LivenessProbe, &out.LivenessProbe 584 *out = new(Probe) 585 if err := DeepCopy_api_Probe(*in, *out, c); err != nil { 586 return err 587 } 588 } 589 if in.ReadinessProbe != nil { 590 in, out := &in.ReadinessProbe, &out.ReadinessProbe 591 *out = new(Probe) 592 if err := DeepCopy_api_Probe(*in, *out, c); err != nil { 593 return err 594 } 595 } 596 if in.Lifecycle != nil { 597 in, out := &in.Lifecycle, &out.Lifecycle 598 *out = new(Lifecycle) 599 if err := DeepCopy_api_Lifecycle(*in, *out, c); err != nil { 600 return err 601 } 602 } 603 if in.SecurityContext != nil { 604 in, out := &in.SecurityContext, &out.SecurityContext 605 *out = new(SecurityContext) 606 if err := DeepCopy_api_SecurityContext(*in, *out, c); err != nil { 607 return err 608 } 609 } 610 return nil 611 } 612} 613 614func DeepCopy_api_ContainerImage(in interface{}, out interface{}, c *conversion.Cloner) error { 615 { 616 in := in.(*ContainerImage) 617 out := out.(*ContainerImage) 618 *out = *in 619 if in.Names != nil { 620 in, out := &in.Names, &out.Names 621 *out = make([]string, len(*in)) 622 copy(*out, *in) 623 } 624 return nil 625 } 626} 627 628func DeepCopy_api_ContainerPort(in interface{}, out interface{}, c *conversion.Cloner) error { 629 { 630 in := in.(*ContainerPort) 631 out := out.(*ContainerPort) 632 *out = *in 633 return nil 634 } 635} 636 637func DeepCopy_api_ContainerState(in interface{}, out interface{}, c *conversion.Cloner) error { 638 { 639 in := in.(*ContainerState) 640 out := out.(*ContainerState) 641 *out = *in 642 if in.Waiting != nil { 643 in, out := &in.Waiting, &out.Waiting 644 *out = new(ContainerStateWaiting) 645 **out = **in 646 } 647 if in.Running != nil { 648 in, out := &in.Running, &out.Running 649 *out = new(ContainerStateRunning) 650 if err := DeepCopy_api_ContainerStateRunning(*in, *out, c); err != nil { 651 return err 652 } 653 } 654 if in.Terminated != nil { 655 in, out := &in.Terminated, &out.Terminated 656 *out = new(ContainerStateTerminated) 657 if err := DeepCopy_api_ContainerStateTerminated(*in, *out, c); err != nil { 658 return err 659 } 660 } 661 return nil 662 } 663} 664 665func DeepCopy_api_ContainerStateRunning(in interface{}, out interface{}, c *conversion.Cloner) error { 666 { 667 in := in.(*ContainerStateRunning) 668 out := out.(*ContainerStateRunning) 669 *out = *in 670 out.StartedAt = in.StartedAt.DeepCopy() 671 return nil 672 } 673} 674 675func DeepCopy_api_ContainerStateTerminated(in interface{}, out interface{}, c *conversion.Cloner) error { 676 { 677 in := in.(*ContainerStateTerminated) 678 out := out.(*ContainerStateTerminated) 679 *out = *in 680 out.StartedAt = in.StartedAt.DeepCopy() 681 out.FinishedAt = in.FinishedAt.DeepCopy() 682 return nil 683 } 684} 685 686func DeepCopy_api_ContainerStateWaiting(in interface{}, out interface{}, c *conversion.Cloner) error { 687 { 688 in := in.(*ContainerStateWaiting) 689 out := out.(*ContainerStateWaiting) 690 *out = *in 691 return nil 692 } 693} 694 695func DeepCopy_api_ContainerStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 696 { 697 in := in.(*ContainerStatus) 698 out := out.(*ContainerStatus) 699 *out = *in 700 if err := DeepCopy_api_ContainerState(&in.State, &out.State, c); err != nil { 701 return err 702 } 703 if err := DeepCopy_api_ContainerState(&in.LastTerminationState, &out.LastTerminationState, c); err != nil { 704 return err 705 } 706 return nil 707 } 708} 709 710func DeepCopy_api_ConversionError(in interface{}, out interface{}, c *conversion.Cloner) error { 711 { 712 in := in.(*ConversionError) 713 out := out.(*ConversionError) 714 *out = *in 715 // in.In is kind 'Interface' 716 if in.In != nil { 717 if newVal, err := c.DeepCopy(&in.In); err != nil { 718 return err 719 } else { 720 out.In = *newVal.(*interface{}) 721 } 722 } 723 // in.Out is kind 'Interface' 724 if in.Out != nil { 725 if newVal, err := c.DeepCopy(&in.Out); err != nil { 726 return err 727 } else { 728 out.Out = *newVal.(*interface{}) 729 } 730 } 731 return nil 732 } 733} 734 735func DeepCopy_api_DaemonEndpoint(in interface{}, out interface{}, c *conversion.Cloner) error { 736 { 737 in := in.(*DaemonEndpoint) 738 out := out.(*DaemonEndpoint) 739 *out = *in 740 return nil 741 } 742} 743 744func DeepCopy_api_DeleteOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 745 { 746 in := in.(*DeleteOptions) 747 out := out.(*DeleteOptions) 748 *out = *in 749 if in.GracePeriodSeconds != nil { 750 in, out := &in.GracePeriodSeconds, &out.GracePeriodSeconds 751 *out = new(int64) 752 **out = **in 753 } 754 if in.Preconditions != nil { 755 in, out := &in.Preconditions, &out.Preconditions 756 *out = new(Preconditions) 757 if err := DeepCopy_api_Preconditions(*in, *out, c); err != nil { 758 return err 759 } 760 } 761 if in.OrphanDependents != nil { 762 in, out := &in.OrphanDependents, &out.OrphanDependents 763 *out = new(bool) 764 **out = **in 765 } 766 if in.PropagationPolicy != nil { 767 in, out := &in.PropagationPolicy, &out.PropagationPolicy 768 *out = new(DeletionPropagation) 769 **out = **in 770 } 771 return nil 772 } 773} 774 775func DeepCopy_api_DownwardAPIProjection(in interface{}, out interface{}, c *conversion.Cloner) error { 776 { 777 in := in.(*DownwardAPIProjection) 778 out := out.(*DownwardAPIProjection) 779 *out = *in 780 if in.Items != nil { 781 in, out := &in.Items, &out.Items 782 *out = make([]DownwardAPIVolumeFile, len(*in)) 783 for i := range *in { 784 if err := DeepCopy_api_DownwardAPIVolumeFile(&(*in)[i], &(*out)[i], c); err != nil { 785 return err 786 } 787 } 788 } 789 return nil 790 } 791} 792 793func DeepCopy_api_DownwardAPIVolumeFile(in interface{}, out interface{}, c *conversion.Cloner) error { 794 { 795 in := in.(*DownwardAPIVolumeFile) 796 out := out.(*DownwardAPIVolumeFile) 797 *out = *in 798 if in.FieldRef != nil { 799 in, out := &in.FieldRef, &out.FieldRef 800 *out = new(ObjectFieldSelector) 801 **out = **in 802 } 803 if in.ResourceFieldRef != nil { 804 in, out := &in.ResourceFieldRef, &out.ResourceFieldRef 805 *out = new(ResourceFieldSelector) 806 if err := DeepCopy_api_ResourceFieldSelector(*in, *out, c); err != nil { 807 return err 808 } 809 } 810 if in.Mode != nil { 811 in, out := &in.Mode, &out.Mode 812 *out = new(int32) 813 **out = **in 814 } 815 return nil 816 } 817} 818 819func DeepCopy_api_DownwardAPIVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 820 { 821 in := in.(*DownwardAPIVolumeSource) 822 out := out.(*DownwardAPIVolumeSource) 823 *out = *in 824 if in.Items != nil { 825 in, out := &in.Items, &out.Items 826 *out = make([]DownwardAPIVolumeFile, len(*in)) 827 for i := range *in { 828 if err := DeepCopy_api_DownwardAPIVolumeFile(&(*in)[i], &(*out)[i], c); err != nil { 829 return err 830 } 831 } 832 } 833 if in.DefaultMode != nil { 834 in, out := &in.DefaultMode, &out.DefaultMode 835 *out = new(int32) 836 **out = **in 837 } 838 return nil 839 } 840} 841 842func DeepCopy_api_EmptyDirVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 843 { 844 in := in.(*EmptyDirVolumeSource) 845 out := out.(*EmptyDirVolumeSource) 846 *out = *in 847 return nil 848 } 849} 850 851func DeepCopy_api_EndpointAddress(in interface{}, out interface{}, c *conversion.Cloner) error { 852 { 853 in := in.(*EndpointAddress) 854 out := out.(*EndpointAddress) 855 *out = *in 856 if in.NodeName != nil { 857 in, out := &in.NodeName, &out.NodeName 858 *out = new(string) 859 **out = **in 860 } 861 if in.TargetRef != nil { 862 in, out := &in.TargetRef, &out.TargetRef 863 *out = new(ObjectReference) 864 **out = **in 865 } 866 return nil 867 } 868} 869 870func DeepCopy_api_EndpointPort(in interface{}, out interface{}, c *conversion.Cloner) error { 871 { 872 in := in.(*EndpointPort) 873 out := out.(*EndpointPort) 874 *out = *in 875 return nil 876 } 877} 878 879func DeepCopy_api_EndpointSubset(in interface{}, out interface{}, c *conversion.Cloner) error { 880 { 881 in := in.(*EndpointSubset) 882 out := out.(*EndpointSubset) 883 *out = *in 884 if in.Addresses != nil { 885 in, out := &in.Addresses, &out.Addresses 886 *out = make([]EndpointAddress, len(*in)) 887 for i := range *in { 888 if err := DeepCopy_api_EndpointAddress(&(*in)[i], &(*out)[i], c); err != nil { 889 return err 890 } 891 } 892 } 893 if in.NotReadyAddresses != nil { 894 in, out := &in.NotReadyAddresses, &out.NotReadyAddresses 895 *out = make([]EndpointAddress, len(*in)) 896 for i := range *in { 897 if err := DeepCopy_api_EndpointAddress(&(*in)[i], &(*out)[i], c); err != nil { 898 return err 899 } 900 } 901 } 902 if in.Ports != nil { 903 in, out := &in.Ports, &out.Ports 904 *out = make([]EndpointPort, len(*in)) 905 copy(*out, *in) 906 } 907 return nil 908 } 909} 910 911func DeepCopy_api_Endpoints(in interface{}, out interface{}, c *conversion.Cloner) error { 912 { 913 in := in.(*Endpoints) 914 out := out.(*Endpoints) 915 *out = *in 916 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 917 return err 918 } else { 919 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 920 } 921 if in.Subsets != nil { 922 in, out := &in.Subsets, &out.Subsets 923 *out = make([]EndpointSubset, len(*in)) 924 for i := range *in { 925 if err := DeepCopy_api_EndpointSubset(&(*in)[i], &(*out)[i], c); err != nil { 926 return err 927 } 928 } 929 } 930 return nil 931 } 932} 933 934func DeepCopy_api_EndpointsList(in interface{}, out interface{}, c *conversion.Cloner) error { 935 { 936 in := in.(*EndpointsList) 937 out := out.(*EndpointsList) 938 *out = *in 939 if in.Items != nil { 940 in, out := &in.Items, &out.Items 941 *out = make([]Endpoints, len(*in)) 942 for i := range *in { 943 if err := DeepCopy_api_Endpoints(&(*in)[i], &(*out)[i], c); err != nil { 944 return err 945 } 946 } 947 } 948 return nil 949 } 950} 951 952func DeepCopy_api_EnvFromSource(in interface{}, out interface{}, c *conversion.Cloner) error { 953 { 954 in := in.(*EnvFromSource) 955 out := out.(*EnvFromSource) 956 *out = *in 957 if in.ConfigMapRef != nil { 958 in, out := &in.ConfigMapRef, &out.ConfigMapRef 959 *out = new(ConfigMapEnvSource) 960 if err := DeepCopy_api_ConfigMapEnvSource(*in, *out, c); err != nil { 961 return err 962 } 963 } 964 if in.SecretRef != nil { 965 in, out := &in.SecretRef, &out.SecretRef 966 *out = new(SecretEnvSource) 967 if err := DeepCopy_api_SecretEnvSource(*in, *out, c); err != nil { 968 return err 969 } 970 } 971 return nil 972 } 973} 974 975func DeepCopy_api_EnvVar(in interface{}, out interface{}, c *conversion.Cloner) error { 976 { 977 in := in.(*EnvVar) 978 out := out.(*EnvVar) 979 *out = *in 980 if in.ValueFrom != nil { 981 in, out := &in.ValueFrom, &out.ValueFrom 982 *out = new(EnvVarSource) 983 if err := DeepCopy_api_EnvVarSource(*in, *out, c); err != nil { 984 return err 985 } 986 } 987 return nil 988 } 989} 990 991func DeepCopy_api_EnvVarSource(in interface{}, out interface{}, c *conversion.Cloner) error { 992 { 993 in := in.(*EnvVarSource) 994 out := out.(*EnvVarSource) 995 *out = *in 996 if in.FieldRef != nil { 997 in, out := &in.FieldRef, &out.FieldRef 998 *out = new(ObjectFieldSelector) 999 **out = **in 1000 } 1001 if in.ResourceFieldRef != nil { 1002 in, out := &in.ResourceFieldRef, &out.ResourceFieldRef 1003 *out = new(ResourceFieldSelector) 1004 if err := DeepCopy_api_ResourceFieldSelector(*in, *out, c); err != nil { 1005 return err 1006 } 1007 } 1008 if in.ConfigMapKeyRef != nil { 1009 in, out := &in.ConfigMapKeyRef, &out.ConfigMapKeyRef 1010 *out = new(ConfigMapKeySelector) 1011 if err := DeepCopy_api_ConfigMapKeySelector(*in, *out, c); err != nil { 1012 return err 1013 } 1014 } 1015 if in.SecretKeyRef != nil { 1016 in, out := &in.SecretKeyRef, &out.SecretKeyRef 1017 *out = new(SecretKeySelector) 1018 if err := DeepCopy_api_SecretKeySelector(*in, *out, c); err != nil { 1019 return err 1020 } 1021 } 1022 return nil 1023 } 1024} 1025 1026func DeepCopy_api_Event(in interface{}, out interface{}, c *conversion.Cloner) error { 1027 { 1028 in := in.(*Event) 1029 out := out.(*Event) 1030 *out = *in 1031 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 1032 return err 1033 } else { 1034 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 1035 } 1036 out.FirstTimestamp = in.FirstTimestamp.DeepCopy() 1037 out.LastTimestamp = in.LastTimestamp.DeepCopy() 1038 return nil 1039 } 1040} 1041 1042func DeepCopy_api_EventList(in interface{}, out interface{}, c *conversion.Cloner) error { 1043 { 1044 in := in.(*EventList) 1045 out := out.(*EventList) 1046 *out = *in 1047 if in.Items != nil { 1048 in, out := &in.Items, &out.Items 1049 *out = make([]Event, len(*in)) 1050 for i := range *in { 1051 if err := DeepCopy_api_Event(&(*in)[i], &(*out)[i], c); err != nil { 1052 return err 1053 } 1054 } 1055 } 1056 return nil 1057 } 1058} 1059 1060func DeepCopy_api_EventSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1061 { 1062 in := in.(*EventSource) 1063 out := out.(*EventSource) 1064 *out = *in 1065 return nil 1066 } 1067} 1068 1069func DeepCopy_api_ExecAction(in interface{}, out interface{}, c *conversion.Cloner) error { 1070 { 1071 in := in.(*ExecAction) 1072 out := out.(*ExecAction) 1073 *out = *in 1074 if in.Command != nil { 1075 in, out := &in.Command, &out.Command 1076 *out = make([]string, len(*in)) 1077 copy(*out, *in) 1078 } 1079 return nil 1080 } 1081} 1082 1083func DeepCopy_api_FCVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1084 { 1085 in := in.(*FCVolumeSource) 1086 out := out.(*FCVolumeSource) 1087 *out = *in 1088 if in.TargetWWNs != nil { 1089 in, out := &in.TargetWWNs, &out.TargetWWNs 1090 *out = make([]string, len(*in)) 1091 copy(*out, *in) 1092 } 1093 if in.Lun != nil { 1094 in, out := &in.Lun, &out.Lun 1095 *out = new(int32) 1096 **out = **in 1097 } 1098 return nil 1099 } 1100} 1101 1102func DeepCopy_api_FlexVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1103 { 1104 in := in.(*FlexVolumeSource) 1105 out := out.(*FlexVolumeSource) 1106 *out = *in 1107 if in.SecretRef != nil { 1108 in, out := &in.SecretRef, &out.SecretRef 1109 *out = new(LocalObjectReference) 1110 **out = **in 1111 } 1112 if in.Options != nil { 1113 in, out := &in.Options, &out.Options 1114 *out = make(map[string]string) 1115 for key, val := range *in { 1116 (*out)[key] = val 1117 } 1118 } 1119 return nil 1120 } 1121} 1122 1123func DeepCopy_api_FlockerVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1124 { 1125 in := in.(*FlockerVolumeSource) 1126 out := out.(*FlockerVolumeSource) 1127 *out = *in 1128 return nil 1129 } 1130} 1131 1132func DeepCopy_api_GCEPersistentDiskVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1133 { 1134 in := in.(*GCEPersistentDiskVolumeSource) 1135 out := out.(*GCEPersistentDiskVolumeSource) 1136 *out = *in 1137 return nil 1138 } 1139} 1140 1141func DeepCopy_api_GitRepoVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1142 { 1143 in := in.(*GitRepoVolumeSource) 1144 out := out.(*GitRepoVolumeSource) 1145 *out = *in 1146 return nil 1147 } 1148} 1149 1150func DeepCopy_api_GlusterfsVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1151 { 1152 in := in.(*GlusterfsVolumeSource) 1153 out := out.(*GlusterfsVolumeSource) 1154 *out = *in 1155 return nil 1156 } 1157} 1158 1159func DeepCopy_api_HTTPGetAction(in interface{}, out interface{}, c *conversion.Cloner) error { 1160 { 1161 in := in.(*HTTPGetAction) 1162 out := out.(*HTTPGetAction) 1163 *out = *in 1164 if in.HTTPHeaders != nil { 1165 in, out := &in.HTTPHeaders, &out.HTTPHeaders 1166 *out = make([]HTTPHeader, len(*in)) 1167 copy(*out, *in) 1168 } 1169 return nil 1170 } 1171} 1172 1173func DeepCopy_api_HTTPHeader(in interface{}, out interface{}, c *conversion.Cloner) error { 1174 { 1175 in := in.(*HTTPHeader) 1176 out := out.(*HTTPHeader) 1177 *out = *in 1178 return nil 1179 } 1180} 1181 1182func DeepCopy_api_Handler(in interface{}, out interface{}, c *conversion.Cloner) error { 1183 { 1184 in := in.(*Handler) 1185 out := out.(*Handler) 1186 *out = *in 1187 if in.Exec != nil { 1188 in, out := &in.Exec, &out.Exec 1189 *out = new(ExecAction) 1190 if err := DeepCopy_api_ExecAction(*in, *out, c); err != nil { 1191 return err 1192 } 1193 } 1194 if in.HTTPGet != nil { 1195 in, out := &in.HTTPGet, &out.HTTPGet 1196 *out = new(HTTPGetAction) 1197 if err := DeepCopy_api_HTTPGetAction(*in, *out, c); err != nil { 1198 return err 1199 } 1200 } 1201 if in.TCPSocket != nil { 1202 in, out := &in.TCPSocket, &out.TCPSocket 1203 *out = new(TCPSocketAction) 1204 **out = **in 1205 } 1206 return nil 1207 } 1208} 1209 1210func DeepCopy_api_HostPathVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1211 { 1212 in := in.(*HostPathVolumeSource) 1213 out := out.(*HostPathVolumeSource) 1214 *out = *in 1215 return nil 1216 } 1217} 1218 1219func DeepCopy_api_ISCSIVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1220 { 1221 in := in.(*ISCSIVolumeSource) 1222 out := out.(*ISCSIVolumeSource) 1223 *out = *in 1224 if in.Portals != nil { 1225 in, out := &in.Portals, &out.Portals 1226 *out = make([]string, len(*in)) 1227 copy(*out, *in) 1228 } 1229 return nil 1230 } 1231} 1232 1233func DeepCopy_api_KeyToPath(in interface{}, out interface{}, c *conversion.Cloner) error { 1234 { 1235 in := in.(*KeyToPath) 1236 out := out.(*KeyToPath) 1237 *out = *in 1238 if in.Mode != nil { 1239 in, out := &in.Mode, &out.Mode 1240 *out = new(int32) 1241 **out = **in 1242 } 1243 return nil 1244 } 1245} 1246 1247func DeepCopy_api_Lifecycle(in interface{}, out interface{}, c *conversion.Cloner) error { 1248 { 1249 in := in.(*Lifecycle) 1250 out := out.(*Lifecycle) 1251 *out = *in 1252 if in.PostStart != nil { 1253 in, out := &in.PostStart, &out.PostStart 1254 *out = new(Handler) 1255 if err := DeepCopy_api_Handler(*in, *out, c); err != nil { 1256 return err 1257 } 1258 } 1259 if in.PreStop != nil { 1260 in, out := &in.PreStop, &out.PreStop 1261 *out = new(Handler) 1262 if err := DeepCopy_api_Handler(*in, *out, c); err != nil { 1263 return err 1264 } 1265 } 1266 return nil 1267 } 1268} 1269 1270func DeepCopy_api_LimitRange(in interface{}, out interface{}, c *conversion.Cloner) error { 1271 { 1272 in := in.(*LimitRange) 1273 out := out.(*LimitRange) 1274 *out = *in 1275 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 1276 return err 1277 } else { 1278 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 1279 } 1280 if err := DeepCopy_api_LimitRangeSpec(&in.Spec, &out.Spec, c); err != nil { 1281 return err 1282 } 1283 return nil 1284 } 1285} 1286 1287func DeepCopy_api_LimitRangeItem(in interface{}, out interface{}, c *conversion.Cloner) error { 1288 { 1289 in := in.(*LimitRangeItem) 1290 out := out.(*LimitRangeItem) 1291 *out = *in 1292 if in.Max != nil { 1293 in, out := &in.Max, &out.Max 1294 *out = make(ResourceList) 1295 for key, val := range *in { 1296 (*out)[key] = val.DeepCopy() 1297 } 1298 } 1299 if in.Min != nil { 1300 in, out := &in.Min, &out.Min 1301 *out = make(ResourceList) 1302 for key, val := range *in { 1303 (*out)[key] = val.DeepCopy() 1304 } 1305 } 1306 if in.Default != nil { 1307 in, out := &in.Default, &out.Default 1308 *out = make(ResourceList) 1309 for key, val := range *in { 1310 (*out)[key] = val.DeepCopy() 1311 } 1312 } 1313 if in.DefaultRequest != nil { 1314 in, out := &in.DefaultRequest, &out.DefaultRequest 1315 *out = make(ResourceList) 1316 for key, val := range *in { 1317 (*out)[key] = val.DeepCopy() 1318 } 1319 } 1320 if in.MaxLimitRequestRatio != nil { 1321 in, out := &in.MaxLimitRequestRatio, &out.MaxLimitRequestRatio 1322 *out = make(ResourceList) 1323 for key, val := range *in { 1324 (*out)[key] = val.DeepCopy() 1325 } 1326 } 1327 return nil 1328 } 1329} 1330 1331func DeepCopy_api_LimitRangeList(in interface{}, out interface{}, c *conversion.Cloner) error { 1332 { 1333 in := in.(*LimitRangeList) 1334 out := out.(*LimitRangeList) 1335 *out = *in 1336 if in.Items != nil { 1337 in, out := &in.Items, &out.Items 1338 *out = make([]LimitRange, len(*in)) 1339 for i := range *in { 1340 if err := DeepCopy_api_LimitRange(&(*in)[i], &(*out)[i], c); err != nil { 1341 return err 1342 } 1343 } 1344 } 1345 return nil 1346 } 1347} 1348 1349func DeepCopy_api_LimitRangeSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 1350 { 1351 in := in.(*LimitRangeSpec) 1352 out := out.(*LimitRangeSpec) 1353 *out = *in 1354 if in.Limits != nil { 1355 in, out := &in.Limits, &out.Limits 1356 *out = make([]LimitRangeItem, len(*in)) 1357 for i := range *in { 1358 if err := DeepCopy_api_LimitRangeItem(&(*in)[i], &(*out)[i], c); err != nil { 1359 return err 1360 } 1361 } 1362 } 1363 return nil 1364 } 1365} 1366 1367func DeepCopy_api_List(in interface{}, out interface{}, c *conversion.Cloner) error { 1368 { 1369 in := in.(*List) 1370 out := out.(*List) 1371 *out = *in 1372 if in.Items != nil { 1373 in, out := &in.Items, &out.Items 1374 *out = make([]runtime.Object, len(*in)) 1375 for i := range *in { 1376 if newVal, err := c.DeepCopy(&(*in)[i]); err != nil { 1377 return err 1378 } else { 1379 (*out)[i] = *newVal.(*runtime.Object) 1380 } 1381 } 1382 } 1383 return nil 1384 } 1385} 1386 1387func DeepCopy_api_ListOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 1388 { 1389 in := in.(*ListOptions) 1390 out := out.(*ListOptions) 1391 *out = *in 1392 // in.LabelSelector is kind 'Interface' 1393 if in.LabelSelector != nil { 1394 if newVal, err := c.DeepCopy(&in.LabelSelector); err != nil { 1395 return err 1396 } else { 1397 out.LabelSelector = *newVal.(*labels.Selector) 1398 } 1399 } 1400 // in.FieldSelector is kind 'Interface' 1401 if in.FieldSelector != nil { 1402 if newVal, err := c.DeepCopy(&in.FieldSelector); err != nil { 1403 return err 1404 } else { 1405 out.FieldSelector = *newVal.(*fields.Selector) 1406 } 1407 } 1408 if in.TimeoutSeconds != nil { 1409 in, out := &in.TimeoutSeconds, &out.TimeoutSeconds 1410 *out = new(int64) 1411 **out = **in 1412 } 1413 return nil 1414 } 1415} 1416 1417func DeepCopy_api_LoadBalancerIngress(in interface{}, out interface{}, c *conversion.Cloner) error { 1418 { 1419 in := in.(*LoadBalancerIngress) 1420 out := out.(*LoadBalancerIngress) 1421 *out = *in 1422 return nil 1423 } 1424} 1425 1426func DeepCopy_api_LoadBalancerStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 1427 { 1428 in := in.(*LoadBalancerStatus) 1429 out := out.(*LoadBalancerStatus) 1430 *out = *in 1431 if in.Ingress != nil { 1432 in, out := &in.Ingress, &out.Ingress 1433 *out = make([]LoadBalancerIngress, len(*in)) 1434 copy(*out, *in) 1435 } 1436 return nil 1437 } 1438} 1439 1440func DeepCopy_api_LocalObjectReference(in interface{}, out interface{}, c *conversion.Cloner) error { 1441 { 1442 in := in.(*LocalObjectReference) 1443 out := out.(*LocalObjectReference) 1444 *out = *in 1445 return nil 1446 } 1447} 1448 1449func DeepCopy_api_NFSVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1450 { 1451 in := in.(*NFSVolumeSource) 1452 out := out.(*NFSVolumeSource) 1453 *out = *in 1454 return nil 1455 } 1456} 1457 1458func DeepCopy_api_Namespace(in interface{}, out interface{}, c *conversion.Cloner) error { 1459 { 1460 in := in.(*Namespace) 1461 out := out.(*Namespace) 1462 *out = *in 1463 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 1464 return err 1465 } else { 1466 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 1467 } 1468 if err := DeepCopy_api_NamespaceSpec(&in.Spec, &out.Spec, c); err != nil { 1469 return err 1470 } 1471 return nil 1472 } 1473} 1474 1475func DeepCopy_api_NamespaceList(in interface{}, out interface{}, c *conversion.Cloner) error { 1476 { 1477 in := in.(*NamespaceList) 1478 out := out.(*NamespaceList) 1479 *out = *in 1480 if in.Items != nil { 1481 in, out := &in.Items, &out.Items 1482 *out = make([]Namespace, len(*in)) 1483 for i := range *in { 1484 if err := DeepCopy_api_Namespace(&(*in)[i], &(*out)[i], c); err != nil { 1485 return err 1486 } 1487 } 1488 } 1489 return nil 1490 } 1491} 1492 1493func DeepCopy_api_NamespaceSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 1494 { 1495 in := in.(*NamespaceSpec) 1496 out := out.(*NamespaceSpec) 1497 *out = *in 1498 if in.Finalizers != nil { 1499 in, out := &in.Finalizers, &out.Finalizers 1500 *out = make([]FinalizerName, len(*in)) 1501 copy(*out, *in) 1502 } 1503 return nil 1504 } 1505} 1506 1507func DeepCopy_api_NamespaceStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 1508 { 1509 in := in.(*NamespaceStatus) 1510 out := out.(*NamespaceStatus) 1511 *out = *in 1512 return nil 1513 } 1514} 1515 1516func DeepCopy_api_Node(in interface{}, out interface{}, c *conversion.Cloner) error { 1517 { 1518 in := in.(*Node) 1519 out := out.(*Node) 1520 *out = *in 1521 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 1522 return err 1523 } else { 1524 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 1525 } 1526 if err := DeepCopy_api_NodeSpec(&in.Spec, &out.Spec, c); err != nil { 1527 return err 1528 } 1529 if err := DeepCopy_api_NodeStatus(&in.Status, &out.Status, c); err != nil { 1530 return err 1531 } 1532 return nil 1533 } 1534} 1535 1536func DeepCopy_api_NodeAddress(in interface{}, out interface{}, c *conversion.Cloner) error { 1537 { 1538 in := in.(*NodeAddress) 1539 out := out.(*NodeAddress) 1540 *out = *in 1541 return nil 1542 } 1543} 1544 1545func DeepCopy_api_NodeAffinity(in interface{}, out interface{}, c *conversion.Cloner) error { 1546 { 1547 in := in.(*NodeAffinity) 1548 out := out.(*NodeAffinity) 1549 *out = *in 1550 if in.RequiredDuringSchedulingIgnoredDuringExecution != nil { 1551 in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution 1552 *out = new(NodeSelector) 1553 if err := DeepCopy_api_NodeSelector(*in, *out, c); err != nil { 1554 return err 1555 } 1556 } 1557 if in.PreferredDuringSchedulingIgnoredDuringExecution != nil { 1558 in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution 1559 *out = make([]PreferredSchedulingTerm, len(*in)) 1560 for i := range *in { 1561 if err := DeepCopy_api_PreferredSchedulingTerm(&(*in)[i], &(*out)[i], c); err != nil { 1562 return err 1563 } 1564 } 1565 } 1566 return nil 1567 } 1568} 1569 1570func DeepCopy_api_NodeCondition(in interface{}, out interface{}, c *conversion.Cloner) error { 1571 { 1572 in := in.(*NodeCondition) 1573 out := out.(*NodeCondition) 1574 *out = *in 1575 out.LastHeartbeatTime = in.LastHeartbeatTime.DeepCopy() 1576 out.LastTransitionTime = in.LastTransitionTime.DeepCopy() 1577 return nil 1578 } 1579} 1580 1581func DeepCopy_api_NodeDaemonEndpoints(in interface{}, out interface{}, c *conversion.Cloner) error { 1582 { 1583 in := in.(*NodeDaemonEndpoints) 1584 out := out.(*NodeDaemonEndpoints) 1585 *out = *in 1586 return nil 1587 } 1588} 1589 1590func DeepCopy_api_NodeList(in interface{}, out interface{}, c *conversion.Cloner) error { 1591 { 1592 in := in.(*NodeList) 1593 out := out.(*NodeList) 1594 *out = *in 1595 if in.Items != nil { 1596 in, out := &in.Items, &out.Items 1597 *out = make([]Node, len(*in)) 1598 for i := range *in { 1599 if err := DeepCopy_api_Node(&(*in)[i], &(*out)[i], c); err != nil { 1600 return err 1601 } 1602 } 1603 } 1604 return nil 1605 } 1606} 1607 1608func DeepCopy_api_NodeProxyOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 1609 { 1610 in := in.(*NodeProxyOptions) 1611 out := out.(*NodeProxyOptions) 1612 *out = *in 1613 return nil 1614 } 1615} 1616 1617func DeepCopy_api_NodeResources(in interface{}, out interface{}, c *conversion.Cloner) error { 1618 { 1619 in := in.(*NodeResources) 1620 out := out.(*NodeResources) 1621 *out = *in 1622 if in.Capacity != nil { 1623 in, out := &in.Capacity, &out.Capacity 1624 *out = make(ResourceList) 1625 for key, val := range *in { 1626 (*out)[key] = val.DeepCopy() 1627 } 1628 } 1629 return nil 1630 } 1631} 1632 1633func DeepCopy_api_NodeSelector(in interface{}, out interface{}, c *conversion.Cloner) error { 1634 { 1635 in := in.(*NodeSelector) 1636 out := out.(*NodeSelector) 1637 *out = *in 1638 if in.NodeSelectorTerms != nil { 1639 in, out := &in.NodeSelectorTerms, &out.NodeSelectorTerms 1640 *out = make([]NodeSelectorTerm, len(*in)) 1641 for i := range *in { 1642 if err := DeepCopy_api_NodeSelectorTerm(&(*in)[i], &(*out)[i], c); err != nil { 1643 return err 1644 } 1645 } 1646 } 1647 return nil 1648 } 1649} 1650 1651func DeepCopy_api_NodeSelectorRequirement(in interface{}, out interface{}, c *conversion.Cloner) error { 1652 { 1653 in := in.(*NodeSelectorRequirement) 1654 out := out.(*NodeSelectorRequirement) 1655 *out = *in 1656 if in.Values != nil { 1657 in, out := &in.Values, &out.Values 1658 *out = make([]string, len(*in)) 1659 copy(*out, *in) 1660 } 1661 return nil 1662 } 1663} 1664 1665func DeepCopy_api_NodeSelectorTerm(in interface{}, out interface{}, c *conversion.Cloner) error { 1666 { 1667 in := in.(*NodeSelectorTerm) 1668 out := out.(*NodeSelectorTerm) 1669 *out = *in 1670 if in.MatchExpressions != nil { 1671 in, out := &in.MatchExpressions, &out.MatchExpressions 1672 *out = make([]NodeSelectorRequirement, len(*in)) 1673 for i := range *in { 1674 if err := DeepCopy_api_NodeSelectorRequirement(&(*in)[i], &(*out)[i], c); err != nil { 1675 return err 1676 } 1677 } 1678 } 1679 return nil 1680 } 1681} 1682 1683func DeepCopy_api_NodeSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 1684 { 1685 in := in.(*NodeSpec) 1686 out := out.(*NodeSpec) 1687 *out = *in 1688 if in.Taints != nil { 1689 in, out := &in.Taints, &out.Taints 1690 *out = make([]Taint, len(*in)) 1691 for i := range *in { 1692 if err := DeepCopy_api_Taint(&(*in)[i], &(*out)[i], c); err != nil { 1693 return err 1694 } 1695 } 1696 } 1697 return nil 1698 } 1699} 1700 1701func DeepCopy_api_NodeStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 1702 { 1703 in := in.(*NodeStatus) 1704 out := out.(*NodeStatus) 1705 *out = *in 1706 if in.Capacity != nil { 1707 in, out := &in.Capacity, &out.Capacity 1708 *out = make(ResourceList) 1709 for key, val := range *in { 1710 (*out)[key] = val.DeepCopy() 1711 } 1712 } 1713 if in.Allocatable != nil { 1714 in, out := &in.Allocatable, &out.Allocatable 1715 *out = make(ResourceList) 1716 for key, val := range *in { 1717 (*out)[key] = val.DeepCopy() 1718 } 1719 } 1720 if in.Conditions != nil { 1721 in, out := &in.Conditions, &out.Conditions 1722 *out = make([]NodeCondition, len(*in)) 1723 for i := range *in { 1724 if err := DeepCopy_api_NodeCondition(&(*in)[i], &(*out)[i], c); err != nil { 1725 return err 1726 } 1727 } 1728 } 1729 if in.Addresses != nil { 1730 in, out := &in.Addresses, &out.Addresses 1731 *out = make([]NodeAddress, len(*in)) 1732 copy(*out, *in) 1733 } 1734 if in.Images != nil { 1735 in, out := &in.Images, &out.Images 1736 *out = make([]ContainerImage, len(*in)) 1737 for i := range *in { 1738 if err := DeepCopy_api_ContainerImage(&(*in)[i], &(*out)[i], c); err != nil { 1739 return err 1740 } 1741 } 1742 } 1743 if in.VolumesInUse != nil { 1744 in, out := &in.VolumesInUse, &out.VolumesInUse 1745 *out = make([]UniqueVolumeName, len(*in)) 1746 copy(*out, *in) 1747 } 1748 if in.VolumesAttached != nil { 1749 in, out := &in.VolumesAttached, &out.VolumesAttached 1750 *out = make([]AttachedVolume, len(*in)) 1751 copy(*out, *in) 1752 } 1753 return nil 1754 } 1755} 1756 1757func DeepCopy_api_NodeSystemInfo(in interface{}, out interface{}, c *conversion.Cloner) error { 1758 { 1759 in := in.(*NodeSystemInfo) 1760 out := out.(*NodeSystemInfo) 1761 *out = *in 1762 return nil 1763 } 1764} 1765 1766func DeepCopy_api_ObjectFieldSelector(in interface{}, out interface{}, c *conversion.Cloner) error { 1767 { 1768 in := in.(*ObjectFieldSelector) 1769 out := out.(*ObjectFieldSelector) 1770 *out = *in 1771 return nil 1772 } 1773} 1774 1775func DeepCopy_api_ObjectMeta(in interface{}, out interface{}, c *conversion.Cloner) error { 1776 { 1777 in := in.(*ObjectMeta) 1778 out := out.(*ObjectMeta) 1779 *out = *in 1780 out.CreationTimestamp = in.CreationTimestamp.DeepCopy() 1781 if in.DeletionTimestamp != nil { 1782 in, out := &in.DeletionTimestamp, &out.DeletionTimestamp 1783 *out = new(v1.Time) 1784 **out = (*in).DeepCopy() 1785 } 1786 if in.DeletionGracePeriodSeconds != nil { 1787 in, out := &in.DeletionGracePeriodSeconds, &out.DeletionGracePeriodSeconds 1788 *out = new(int64) 1789 **out = **in 1790 } 1791 if in.Labels != nil { 1792 in, out := &in.Labels, &out.Labels 1793 *out = make(map[string]string) 1794 for key, val := range *in { 1795 (*out)[key] = val 1796 } 1797 } 1798 if in.Annotations != nil { 1799 in, out := &in.Annotations, &out.Annotations 1800 *out = make(map[string]string) 1801 for key, val := range *in { 1802 (*out)[key] = val 1803 } 1804 } 1805 if in.OwnerReferences != nil { 1806 in, out := &in.OwnerReferences, &out.OwnerReferences 1807 *out = make([]v1.OwnerReference, len(*in)) 1808 for i := range *in { 1809 if newVal, err := c.DeepCopy(&(*in)[i]); err != nil { 1810 return err 1811 } else { 1812 (*out)[i] = *newVal.(*v1.OwnerReference) 1813 } 1814 } 1815 } 1816 if in.Finalizers != nil { 1817 in, out := &in.Finalizers, &out.Finalizers 1818 *out = make([]string, len(*in)) 1819 copy(*out, *in) 1820 } 1821 return nil 1822 } 1823} 1824 1825func DeepCopy_api_ObjectReference(in interface{}, out interface{}, c *conversion.Cloner) error { 1826 { 1827 in := in.(*ObjectReference) 1828 out := out.(*ObjectReference) 1829 *out = *in 1830 return nil 1831 } 1832} 1833 1834func DeepCopy_api_PersistentVolume(in interface{}, out interface{}, c *conversion.Cloner) error { 1835 { 1836 in := in.(*PersistentVolume) 1837 out := out.(*PersistentVolume) 1838 *out = *in 1839 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 1840 return err 1841 } else { 1842 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 1843 } 1844 if err := DeepCopy_api_PersistentVolumeSpec(&in.Spec, &out.Spec, c); err != nil { 1845 return err 1846 } 1847 return nil 1848 } 1849} 1850 1851func DeepCopy_api_PersistentVolumeClaim(in interface{}, out interface{}, c *conversion.Cloner) error { 1852 { 1853 in := in.(*PersistentVolumeClaim) 1854 out := out.(*PersistentVolumeClaim) 1855 *out = *in 1856 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 1857 return err 1858 } else { 1859 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 1860 } 1861 if err := DeepCopy_api_PersistentVolumeClaimSpec(&in.Spec, &out.Spec, c); err != nil { 1862 return err 1863 } 1864 if err := DeepCopy_api_PersistentVolumeClaimStatus(&in.Status, &out.Status, c); err != nil { 1865 return err 1866 } 1867 return nil 1868 } 1869} 1870 1871func DeepCopy_api_PersistentVolumeClaimList(in interface{}, out interface{}, c *conversion.Cloner) error { 1872 { 1873 in := in.(*PersistentVolumeClaimList) 1874 out := out.(*PersistentVolumeClaimList) 1875 *out = *in 1876 if in.Items != nil { 1877 in, out := &in.Items, &out.Items 1878 *out = make([]PersistentVolumeClaim, len(*in)) 1879 for i := range *in { 1880 if err := DeepCopy_api_PersistentVolumeClaim(&(*in)[i], &(*out)[i], c); err != nil { 1881 return err 1882 } 1883 } 1884 } 1885 return nil 1886 } 1887} 1888 1889func DeepCopy_api_PersistentVolumeClaimSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 1890 { 1891 in := in.(*PersistentVolumeClaimSpec) 1892 out := out.(*PersistentVolumeClaimSpec) 1893 *out = *in 1894 if in.AccessModes != nil { 1895 in, out := &in.AccessModes, &out.AccessModes 1896 *out = make([]PersistentVolumeAccessMode, len(*in)) 1897 copy(*out, *in) 1898 } 1899 if in.Selector != nil { 1900 in, out := &in.Selector, &out.Selector 1901 if newVal, err := c.DeepCopy(*in); err != nil { 1902 return err 1903 } else { 1904 *out = newVal.(*v1.LabelSelector) 1905 } 1906 } 1907 if err := DeepCopy_api_ResourceRequirements(&in.Resources, &out.Resources, c); err != nil { 1908 return err 1909 } 1910 if in.StorageClassName != nil { 1911 in, out := &in.StorageClassName, &out.StorageClassName 1912 *out = new(string) 1913 **out = **in 1914 } 1915 return nil 1916 } 1917} 1918 1919func DeepCopy_api_PersistentVolumeClaimStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 1920 { 1921 in := in.(*PersistentVolumeClaimStatus) 1922 out := out.(*PersistentVolumeClaimStatus) 1923 *out = *in 1924 if in.AccessModes != nil { 1925 in, out := &in.AccessModes, &out.AccessModes 1926 *out = make([]PersistentVolumeAccessMode, len(*in)) 1927 copy(*out, *in) 1928 } 1929 if in.Capacity != nil { 1930 in, out := &in.Capacity, &out.Capacity 1931 *out = make(ResourceList) 1932 for key, val := range *in { 1933 (*out)[key] = val.DeepCopy() 1934 } 1935 } 1936 return nil 1937 } 1938} 1939 1940func DeepCopy_api_PersistentVolumeClaimVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1941 { 1942 in := in.(*PersistentVolumeClaimVolumeSource) 1943 out := out.(*PersistentVolumeClaimVolumeSource) 1944 *out = *in 1945 return nil 1946 } 1947} 1948 1949func DeepCopy_api_PersistentVolumeList(in interface{}, out interface{}, c *conversion.Cloner) error { 1950 { 1951 in := in.(*PersistentVolumeList) 1952 out := out.(*PersistentVolumeList) 1953 *out = *in 1954 if in.Items != nil { 1955 in, out := &in.Items, &out.Items 1956 *out = make([]PersistentVolume, len(*in)) 1957 for i := range *in { 1958 if err := DeepCopy_api_PersistentVolume(&(*in)[i], &(*out)[i], c); err != nil { 1959 return err 1960 } 1961 } 1962 } 1963 return nil 1964 } 1965} 1966 1967func DeepCopy_api_PersistentVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 1968 { 1969 in := in.(*PersistentVolumeSource) 1970 out := out.(*PersistentVolumeSource) 1971 *out = *in 1972 if in.GCEPersistentDisk != nil { 1973 in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk 1974 *out = new(GCEPersistentDiskVolumeSource) 1975 **out = **in 1976 } 1977 if in.AWSElasticBlockStore != nil { 1978 in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore 1979 *out = new(AWSElasticBlockStoreVolumeSource) 1980 **out = **in 1981 } 1982 if in.HostPath != nil { 1983 in, out := &in.HostPath, &out.HostPath 1984 *out = new(HostPathVolumeSource) 1985 **out = **in 1986 } 1987 if in.Glusterfs != nil { 1988 in, out := &in.Glusterfs, &out.Glusterfs 1989 *out = new(GlusterfsVolumeSource) 1990 **out = **in 1991 } 1992 if in.NFS != nil { 1993 in, out := &in.NFS, &out.NFS 1994 *out = new(NFSVolumeSource) 1995 **out = **in 1996 } 1997 if in.RBD != nil { 1998 in, out := &in.RBD, &out.RBD 1999 *out = new(RBDVolumeSource) 2000 if err := DeepCopy_api_RBDVolumeSource(*in, *out, c); err != nil { 2001 return err 2002 } 2003 } 2004 if in.Quobyte != nil { 2005 in, out := &in.Quobyte, &out.Quobyte 2006 *out = new(QuobyteVolumeSource) 2007 **out = **in 2008 } 2009 if in.ISCSI != nil { 2010 in, out := &in.ISCSI, &out.ISCSI 2011 *out = new(ISCSIVolumeSource) 2012 if err := DeepCopy_api_ISCSIVolumeSource(*in, *out, c); err != nil { 2013 return err 2014 } 2015 } 2016 if in.FlexVolume != nil { 2017 in, out := &in.FlexVolume, &out.FlexVolume 2018 *out = new(FlexVolumeSource) 2019 if err := DeepCopy_api_FlexVolumeSource(*in, *out, c); err != nil { 2020 return err 2021 } 2022 } 2023 if in.Cinder != nil { 2024 in, out := &in.Cinder, &out.Cinder 2025 *out = new(CinderVolumeSource) 2026 **out = **in 2027 } 2028 if in.CephFS != nil { 2029 in, out := &in.CephFS, &out.CephFS 2030 *out = new(CephFSVolumeSource) 2031 if err := DeepCopy_api_CephFSVolumeSource(*in, *out, c); err != nil { 2032 return err 2033 } 2034 } 2035 if in.FC != nil { 2036 in, out := &in.FC, &out.FC 2037 *out = new(FCVolumeSource) 2038 if err := DeepCopy_api_FCVolumeSource(*in, *out, c); err != nil { 2039 return err 2040 } 2041 } 2042 if in.Flocker != nil { 2043 in, out := &in.Flocker, &out.Flocker 2044 *out = new(FlockerVolumeSource) 2045 **out = **in 2046 } 2047 if in.AzureFile != nil { 2048 in, out := &in.AzureFile, &out.AzureFile 2049 *out = new(AzureFileVolumeSource) 2050 **out = **in 2051 } 2052 if in.VsphereVolume != nil { 2053 in, out := &in.VsphereVolume, &out.VsphereVolume 2054 *out = new(VsphereVirtualDiskVolumeSource) 2055 **out = **in 2056 } 2057 if in.AzureDisk != nil { 2058 in, out := &in.AzureDisk, &out.AzureDisk 2059 *out = new(AzureDiskVolumeSource) 2060 if err := DeepCopy_api_AzureDiskVolumeSource(*in, *out, c); err != nil { 2061 return err 2062 } 2063 } 2064 if in.PhotonPersistentDisk != nil { 2065 in, out := &in.PhotonPersistentDisk, &out.PhotonPersistentDisk 2066 *out = new(PhotonPersistentDiskVolumeSource) 2067 **out = **in 2068 } 2069 if in.PortworxVolume != nil { 2070 in, out := &in.PortworxVolume, &out.PortworxVolume 2071 *out = new(PortworxVolumeSource) 2072 **out = **in 2073 } 2074 if in.ScaleIO != nil { 2075 in, out := &in.ScaleIO, &out.ScaleIO 2076 *out = new(ScaleIOVolumeSource) 2077 if err := DeepCopy_api_ScaleIOVolumeSource(*in, *out, c); err != nil { 2078 return err 2079 } 2080 } 2081 return nil 2082 } 2083} 2084 2085func DeepCopy_api_PersistentVolumeSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 2086 { 2087 in := in.(*PersistentVolumeSpec) 2088 out := out.(*PersistentVolumeSpec) 2089 *out = *in 2090 if in.Capacity != nil { 2091 in, out := &in.Capacity, &out.Capacity 2092 *out = make(ResourceList) 2093 for key, val := range *in { 2094 (*out)[key] = val.DeepCopy() 2095 } 2096 } 2097 if err := DeepCopy_api_PersistentVolumeSource(&in.PersistentVolumeSource, &out.PersistentVolumeSource, c); err != nil { 2098 return err 2099 } 2100 if in.AccessModes != nil { 2101 in, out := &in.AccessModes, &out.AccessModes 2102 *out = make([]PersistentVolumeAccessMode, len(*in)) 2103 copy(*out, *in) 2104 } 2105 if in.ClaimRef != nil { 2106 in, out := &in.ClaimRef, &out.ClaimRef 2107 *out = new(ObjectReference) 2108 **out = **in 2109 } 2110 return nil 2111 } 2112} 2113 2114func DeepCopy_api_PersistentVolumeStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 2115 { 2116 in := in.(*PersistentVolumeStatus) 2117 out := out.(*PersistentVolumeStatus) 2118 *out = *in 2119 return nil 2120 } 2121} 2122 2123func DeepCopy_api_PhotonPersistentDiskVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2124 { 2125 in := in.(*PhotonPersistentDiskVolumeSource) 2126 out := out.(*PhotonPersistentDiskVolumeSource) 2127 *out = *in 2128 return nil 2129 } 2130} 2131 2132func DeepCopy_api_Pod(in interface{}, out interface{}, c *conversion.Cloner) error { 2133 { 2134 in := in.(*Pod) 2135 out := out.(*Pod) 2136 *out = *in 2137 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2138 return err 2139 } else { 2140 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2141 } 2142 if err := DeepCopy_api_PodSpec(&in.Spec, &out.Spec, c); err != nil { 2143 return err 2144 } 2145 if err := DeepCopy_api_PodStatus(&in.Status, &out.Status, c); err != nil { 2146 return err 2147 } 2148 return nil 2149 } 2150} 2151 2152func DeepCopy_api_PodAffinity(in interface{}, out interface{}, c *conversion.Cloner) error { 2153 { 2154 in := in.(*PodAffinity) 2155 out := out.(*PodAffinity) 2156 *out = *in 2157 if in.RequiredDuringSchedulingIgnoredDuringExecution != nil { 2158 in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution 2159 *out = make([]PodAffinityTerm, len(*in)) 2160 for i := range *in { 2161 if err := DeepCopy_api_PodAffinityTerm(&(*in)[i], &(*out)[i], c); err != nil { 2162 return err 2163 } 2164 } 2165 } 2166 if in.PreferredDuringSchedulingIgnoredDuringExecution != nil { 2167 in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution 2168 *out = make([]WeightedPodAffinityTerm, len(*in)) 2169 for i := range *in { 2170 if err := DeepCopy_api_WeightedPodAffinityTerm(&(*in)[i], &(*out)[i], c); err != nil { 2171 return err 2172 } 2173 } 2174 } 2175 return nil 2176 } 2177} 2178 2179func DeepCopy_api_PodAffinityTerm(in interface{}, out interface{}, c *conversion.Cloner) error { 2180 { 2181 in := in.(*PodAffinityTerm) 2182 out := out.(*PodAffinityTerm) 2183 *out = *in 2184 if in.LabelSelector != nil { 2185 in, out := &in.LabelSelector, &out.LabelSelector 2186 if newVal, err := c.DeepCopy(*in); err != nil { 2187 return err 2188 } else { 2189 *out = newVal.(*v1.LabelSelector) 2190 } 2191 } 2192 if in.Namespaces != nil { 2193 in, out := &in.Namespaces, &out.Namespaces 2194 *out = make([]string, len(*in)) 2195 copy(*out, *in) 2196 } 2197 return nil 2198 } 2199} 2200 2201func DeepCopy_api_PodAntiAffinity(in interface{}, out interface{}, c *conversion.Cloner) error { 2202 { 2203 in := in.(*PodAntiAffinity) 2204 out := out.(*PodAntiAffinity) 2205 *out = *in 2206 if in.RequiredDuringSchedulingIgnoredDuringExecution != nil { 2207 in, out := &in.RequiredDuringSchedulingIgnoredDuringExecution, &out.RequiredDuringSchedulingIgnoredDuringExecution 2208 *out = make([]PodAffinityTerm, len(*in)) 2209 for i := range *in { 2210 if err := DeepCopy_api_PodAffinityTerm(&(*in)[i], &(*out)[i], c); err != nil { 2211 return err 2212 } 2213 } 2214 } 2215 if in.PreferredDuringSchedulingIgnoredDuringExecution != nil { 2216 in, out := &in.PreferredDuringSchedulingIgnoredDuringExecution, &out.PreferredDuringSchedulingIgnoredDuringExecution 2217 *out = make([]WeightedPodAffinityTerm, len(*in)) 2218 for i := range *in { 2219 if err := DeepCopy_api_WeightedPodAffinityTerm(&(*in)[i], &(*out)[i], c); err != nil { 2220 return err 2221 } 2222 } 2223 } 2224 return nil 2225 } 2226} 2227 2228func DeepCopy_api_PodAttachOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 2229 { 2230 in := in.(*PodAttachOptions) 2231 out := out.(*PodAttachOptions) 2232 *out = *in 2233 return nil 2234 } 2235} 2236 2237func DeepCopy_api_PodCondition(in interface{}, out interface{}, c *conversion.Cloner) error { 2238 { 2239 in := in.(*PodCondition) 2240 out := out.(*PodCondition) 2241 *out = *in 2242 out.LastProbeTime = in.LastProbeTime.DeepCopy() 2243 out.LastTransitionTime = in.LastTransitionTime.DeepCopy() 2244 return nil 2245 } 2246} 2247 2248func DeepCopy_api_PodExecOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 2249 { 2250 in := in.(*PodExecOptions) 2251 out := out.(*PodExecOptions) 2252 *out = *in 2253 if in.Command != nil { 2254 in, out := &in.Command, &out.Command 2255 *out = make([]string, len(*in)) 2256 copy(*out, *in) 2257 } 2258 return nil 2259 } 2260} 2261 2262func DeepCopy_api_PodList(in interface{}, out interface{}, c *conversion.Cloner) error { 2263 { 2264 in := in.(*PodList) 2265 out := out.(*PodList) 2266 *out = *in 2267 if in.Items != nil { 2268 in, out := &in.Items, &out.Items 2269 *out = make([]Pod, len(*in)) 2270 for i := range *in { 2271 if err := DeepCopy_api_Pod(&(*in)[i], &(*out)[i], c); err != nil { 2272 return err 2273 } 2274 } 2275 } 2276 return nil 2277 } 2278} 2279 2280func DeepCopy_api_PodLogOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 2281 { 2282 in := in.(*PodLogOptions) 2283 out := out.(*PodLogOptions) 2284 *out = *in 2285 if in.SinceSeconds != nil { 2286 in, out := &in.SinceSeconds, &out.SinceSeconds 2287 *out = new(int64) 2288 **out = **in 2289 } 2290 if in.SinceTime != nil { 2291 in, out := &in.SinceTime, &out.SinceTime 2292 *out = new(v1.Time) 2293 **out = (*in).DeepCopy() 2294 } 2295 if in.TailLines != nil { 2296 in, out := &in.TailLines, &out.TailLines 2297 *out = new(int64) 2298 **out = **in 2299 } 2300 if in.LimitBytes != nil { 2301 in, out := &in.LimitBytes, &out.LimitBytes 2302 *out = new(int64) 2303 **out = **in 2304 } 2305 return nil 2306 } 2307} 2308 2309func DeepCopy_api_PodPortForwardOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 2310 { 2311 in := in.(*PodPortForwardOptions) 2312 out := out.(*PodPortForwardOptions) 2313 *out = *in 2314 if in.Ports != nil { 2315 in, out := &in.Ports, &out.Ports 2316 *out = make([]int32, len(*in)) 2317 copy(*out, *in) 2318 } 2319 return nil 2320 } 2321} 2322 2323func DeepCopy_api_PodProxyOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 2324 { 2325 in := in.(*PodProxyOptions) 2326 out := out.(*PodProxyOptions) 2327 *out = *in 2328 return nil 2329 } 2330} 2331 2332func DeepCopy_api_PodSecurityContext(in interface{}, out interface{}, c *conversion.Cloner) error { 2333 { 2334 in := in.(*PodSecurityContext) 2335 out := out.(*PodSecurityContext) 2336 *out = *in 2337 if in.SELinuxOptions != nil { 2338 in, out := &in.SELinuxOptions, &out.SELinuxOptions 2339 *out = new(SELinuxOptions) 2340 **out = **in 2341 } 2342 if in.RunAsUser != nil { 2343 in, out := &in.RunAsUser, &out.RunAsUser 2344 *out = new(int64) 2345 **out = **in 2346 } 2347 if in.RunAsNonRoot != nil { 2348 in, out := &in.RunAsNonRoot, &out.RunAsNonRoot 2349 *out = new(bool) 2350 **out = **in 2351 } 2352 if in.SupplementalGroups != nil { 2353 in, out := &in.SupplementalGroups, &out.SupplementalGroups 2354 *out = make([]int64, len(*in)) 2355 copy(*out, *in) 2356 } 2357 if in.FSGroup != nil { 2358 in, out := &in.FSGroup, &out.FSGroup 2359 *out = new(int64) 2360 **out = **in 2361 } 2362 return nil 2363 } 2364} 2365 2366func DeepCopy_api_PodSignature(in interface{}, out interface{}, c *conversion.Cloner) error { 2367 { 2368 in := in.(*PodSignature) 2369 out := out.(*PodSignature) 2370 *out = *in 2371 if in.PodController != nil { 2372 in, out := &in.PodController, &out.PodController 2373 if newVal, err := c.DeepCopy(*in); err != nil { 2374 return err 2375 } else { 2376 *out = newVal.(*v1.OwnerReference) 2377 } 2378 } 2379 return nil 2380 } 2381} 2382 2383func DeepCopy_api_PodSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 2384 { 2385 in := in.(*PodSpec) 2386 out := out.(*PodSpec) 2387 *out = *in 2388 if in.Volumes != nil { 2389 in, out := &in.Volumes, &out.Volumes 2390 *out = make([]Volume, len(*in)) 2391 for i := range *in { 2392 if err := DeepCopy_api_Volume(&(*in)[i], &(*out)[i], c); err != nil { 2393 return err 2394 } 2395 } 2396 } 2397 if in.InitContainers != nil { 2398 in, out := &in.InitContainers, &out.InitContainers 2399 *out = make([]Container, len(*in)) 2400 for i := range *in { 2401 if err := DeepCopy_api_Container(&(*in)[i], &(*out)[i], c); err != nil { 2402 return err 2403 } 2404 } 2405 } 2406 if in.Containers != nil { 2407 in, out := &in.Containers, &out.Containers 2408 *out = make([]Container, len(*in)) 2409 for i := range *in { 2410 if err := DeepCopy_api_Container(&(*in)[i], &(*out)[i], c); err != nil { 2411 return err 2412 } 2413 } 2414 } 2415 if in.TerminationGracePeriodSeconds != nil { 2416 in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds 2417 *out = new(int64) 2418 **out = **in 2419 } 2420 if in.ActiveDeadlineSeconds != nil { 2421 in, out := &in.ActiveDeadlineSeconds, &out.ActiveDeadlineSeconds 2422 *out = new(int64) 2423 **out = **in 2424 } 2425 if in.NodeSelector != nil { 2426 in, out := &in.NodeSelector, &out.NodeSelector 2427 *out = make(map[string]string) 2428 for key, val := range *in { 2429 (*out)[key] = val 2430 } 2431 } 2432 if in.AutomountServiceAccountToken != nil { 2433 in, out := &in.AutomountServiceAccountToken, &out.AutomountServiceAccountToken 2434 *out = new(bool) 2435 **out = **in 2436 } 2437 if in.SecurityContext != nil { 2438 in, out := &in.SecurityContext, &out.SecurityContext 2439 *out = new(PodSecurityContext) 2440 if err := DeepCopy_api_PodSecurityContext(*in, *out, c); err != nil { 2441 return err 2442 } 2443 } 2444 if in.ImagePullSecrets != nil { 2445 in, out := &in.ImagePullSecrets, &out.ImagePullSecrets 2446 *out = make([]LocalObjectReference, len(*in)) 2447 copy(*out, *in) 2448 } 2449 if in.Affinity != nil { 2450 in, out := &in.Affinity, &out.Affinity 2451 *out = new(Affinity) 2452 if err := DeepCopy_api_Affinity(*in, *out, c); err != nil { 2453 return err 2454 } 2455 } 2456 if in.Tolerations != nil { 2457 in, out := &in.Tolerations, &out.Tolerations 2458 *out = make([]Toleration, len(*in)) 2459 for i := range *in { 2460 if err := DeepCopy_api_Toleration(&(*in)[i], &(*out)[i], c); err != nil { 2461 return err 2462 } 2463 } 2464 } 2465 return nil 2466 } 2467} 2468 2469func DeepCopy_api_PodStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 2470 { 2471 in := in.(*PodStatus) 2472 out := out.(*PodStatus) 2473 *out = *in 2474 if in.Conditions != nil { 2475 in, out := &in.Conditions, &out.Conditions 2476 *out = make([]PodCondition, len(*in)) 2477 for i := range *in { 2478 if err := DeepCopy_api_PodCondition(&(*in)[i], &(*out)[i], c); err != nil { 2479 return err 2480 } 2481 } 2482 } 2483 if in.StartTime != nil { 2484 in, out := &in.StartTime, &out.StartTime 2485 *out = new(v1.Time) 2486 **out = (*in).DeepCopy() 2487 } 2488 if in.InitContainerStatuses != nil { 2489 in, out := &in.InitContainerStatuses, &out.InitContainerStatuses 2490 *out = make([]ContainerStatus, len(*in)) 2491 for i := range *in { 2492 if err := DeepCopy_api_ContainerStatus(&(*in)[i], &(*out)[i], c); err != nil { 2493 return err 2494 } 2495 } 2496 } 2497 if in.ContainerStatuses != nil { 2498 in, out := &in.ContainerStatuses, &out.ContainerStatuses 2499 *out = make([]ContainerStatus, len(*in)) 2500 for i := range *in { 2501 if err := DeepCopy_api_ContainerStatus(&(*in)[i], &(*out)[i], c); err != nil { 2502 return err 2503 } 2504 } 2505 } 2506 return nil 2507 } 2508} 2509 2510func DeepCopy_api_PodStatusResult(in interface{}, out interface{}, c *conversion.Cloner) error { 2511 { 2512 in := in.(*PodStatusResult) 2513 out := out.(*PodStatusResult) 2514 *out = *in 2515 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2516 return err 2517 } else { 2518 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2519 } 2520 if err := DeepCopy_api_PodStatus(&in.Status, &out.Status, c); err != nil { 2521 return err 2522 } 2523 return nil 2524 } 2525} 2526 2527func DeepCopy_api_PodTemplate(in interface{}, out interface{}, c *conversion.Cloner) error { 2528 { 2529 in := in.(*PodTemplate) 2530 out := out.(*PodTemplate) 2531 *out = *in 2532 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2533 return err 2534 } else { 2535 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2536 } 2537 if err := DeepCopy_api_PodTemplateSpec(&in.Template, &out.Template, c); err != nil { 2538 return err 2539 } 2540 return nil 2541 } 2542} 2543 2544func DeepCopy_api_PodTemplateList(in interface{}, out interface{}, c *conversion.Cloner) error { 2545 { 2546 in := in.(*PodTemplateList) 2547 out := out.(*PodTemplateList) 2548 *out = *in 2549 if in.Items != nil { 2550 in, out := &in.Items, &out.Items 2551 *out = make([]PodTemplate, len(*in)) 2552 for i := range *in { 2553 if err := DeepCopy_api_PodTemplate(&(*in)[i], &(*out)[i], c); err != nil { 2554 return err 2555 } 2556 } 2557 } 2558 return nil 2559 } 2560} 2561 2562func DeepCopy_api_PodTemplateSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 2563 { 2564 in := in.(*PodTemplateSpec) 2565 out := out.(*PodTemplateSpec) 2566 *out = *in 2567 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2568 return err 2569 } else { 2570 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2571 } 2572 if err := DeepCopy_api_PodSpec(&in.Spec, &out.Spec, c); err != nil { 2573 return err 2574 } 2575 return nil 2576 } 2577} 2578 2579func DeepCopy_api_PortworxVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2580 { 2581 in := in.(*PortworxVolumeSource) 2582 out := out.(*PortworxVolumeSource) 2583 *out = *in 2584 return nil 2585 } 2586} 2587 2588func DeepCopy_api_Preconditions(in interface{}, out interface{}, c *conversion.Cloner) error { 2589 { 2590 in := in.(*Preconditions) 2591 out := out.(*Preconditions) 2592 *out = *in 2593 if in.UID != nil { 2594 in, out := &in.UID, &out.UID 2595 *out = new(types.UID) 2596 **out = **in 2597 } 2598 return nil 2599 } 2600} 2601 2602func DeepCopy_api_PreferAvoidPodsEntry(in interface{}, out interface{}, c *conversion.Cloner) error { 2603 { 2604 in := in.(*PreferAvoidPodsEntry) 2605 out := out.(*PreferAvoidPodsEntry) 2606 *out = *in 2607 if err := DeepCopy_api_PodSignature(&in.PodSignature, &out.PodSignature, c); err != nil { 2608 return err 2609 } 2610 out.EvictionTime = in.EvictionTime.DeepCopy() 2611 return nil 2612 } 2613} 2614 2615func DeepCopy_api_PreferredSchedulingTerm(in interface{}, out interface{}, c *conversion.Cloner) error { 2616 { 2617 in := in.(*PreferredSchedulingTerm) 2618 out := out.(*PreferredSchedulingTerm) 2619 *out = *in 2620 if err := DeepCopy_api_NodeSelectorTerm(&in.Preference, &out.Preference, c); err != nil { 2621 return err 2622 } 2623 return nil 2624 } 2625} 2626 2627func DeepCopy_api_Probe(in interface{}, out interface{}, c *conversion.Cloner) error { 2628 { 2629 in := in.(*Probe) 2630 out := out.(*Probe) 2631 *out = *in 2632 if err := DeepCopy_api_Handler(&in.Handler, &out.Handler, c); err != nil { 2633 return err 2634 } 2635 return nil 2636 } 2637} 2638 2639func DeepCopy_api_ProjectedVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2640 { 2641 in := in.(*ProjectedVolumeSource) 2642 out := out.(*ProjectedVolumeSource) 2643 *out = *in 2644 if in.Sources != nil { 2645 in, out := &in.Sources, &out.Sources 2646 *out = make([]VolumeProjection, len(*in)) 2647 for i := range *in { 2648 if err := DeepCopy_api_VolumeProjection(&(*in)[i], &(*out)[i], c); err != nil { 2649 return err 2650 } 2651 } 2652 } 2653 if in.DefaultMode != nil { 2654 in, out := &in.DefaultMode, &out.DefaultMode 2655 *out = new(int32) 2656 **out = **in 2657 } 2658 return nil 2659 } 2660} 2661 2662func DeepCopy_api_QuobyteVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2663 { 2664 in := in.(*QuobyteVolumeSource) 2665 out := out.(*QuobyteVolumeSource) 2666 *out = *in 2667 return nil 2668 } 2669} 2670 2671func DeepCopy_api_RBDVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2672 { 2673 in := in.(*RBDVolumeSource) 2674 out := out.(*RBDVolumeSource) 2675 *out = *in 2676 if in.CephMonitors != nil { 2677 in, out := &in.CephMonitors, &out.CephMonitors 2678 *out = make([]string, len(*in)) 2679 copy(*out, *in) 2680 } 2681 if in.SecretRef != nil { 2682 in, out := &in.SecretRef, &out.SecretRef 2683 *out = new(LocalObjectReference) 2684 **out = **in 2685 } 2686 return nil 2687 } 2688} 2689 2690func DeepCopy_api_RangeAllocation(in interface{}, out interface{}, c *conversion.Cloner) error { 2691 { 2692 in := in.(*RangeAllocation) 2693 out := out.(*RangeAllocation) 2694 *out = *in 2695 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2696 return err 2697 } else { 2698 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2699 } 2700 if in.Data != nil { 2701 in, out := &in.Data, &out.Data 2702 *out = make([]byte, len(*in)) 2703 copy(*out, *in) 2704 } 2705 return nil 2706 } 2707} 2708 2709func DeepCopy_api_ReplicationController(in interface{}, out interface{}, c *conversion.Cloner) error { 2710 { 2711 in := in.(*ReplicationController) 2712 out := out.(*ReplicationController) 2713 *out = *in 2714 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2715 return err 2716 } else { 2717 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2718 } 2719 if err := DeepCopy_api_ReplicationControllerSpec(&in.Spec, &out.Spec, c); err != nil { 2720 return err 2721 } 2722 if err := DeepCopy_api_ReplicationControllerStatus(&in.Status, &out.Status, c); err != nil { 2723 return err 2724 } 2725 return nil 2726 } 2727} 2728 2729func DeepCopy_api_ReplicationControllerCondition(in interface{}, out interface{}, c *conversion.Cloner) error { 2730 { 2731 in := in.(*ReplicationControllerCondition) 2732 out := out.(*ReplicationControllerCondition) 2733 *out = *in 2734 out.LastTransitionTime = in.LastTransitionTime.DeepCopy() 2735 return nil 2736 } 2737} 2738 2739func DeepCopy_api_ReplicationControllerList(in interface{}, out interface{}, c *conversion.Cloner) error { 2740 { 2741 in := in.(*ReplicationControllerList) 2742 out := out.(*ReplicationControllerList) 2743 *out = *in 2744 if in.Items != nil { 2745 in, out := &in.Items, &out.Items 2746 *out = make([]ReplicationController, len(*in)) 2747 for i := range *in { 2748 if err := DeepCopy_api_ReplicationController(&(*in)[i], &(*out)[i], c); err != nil { 2749 return err 2750 } 2751 } 2752 } 2753 return nil 2754 } 2755} 2756 2757func DeepCopy_api_ReplicationControllerSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 2758 { 2759 in := in.(*ReplicationControllerSpec) 2760 out := out.(*ReplicationControllerSpec) 2761 *out = *in 2762 if in.Selector != nil { 2763 in, out := &in.Selector, &out.Selector 2764 *out = make(map[string]string) 2765 for key, val := range *in { 2766 (*out)[key] = val 2767 } 2768 } 2769 if in.Template != nil { 2770 in, out := &in.Template, &out.Template 2771 *out = new(PodTemplateSpec) 2772 if err := DeepCopy_api_PodTemplateSpec(*in, *out, c); err != nil { 2773 return err 2774 } 2775 } 2776 return nil 2777 } 2778} 2779 2780func DeepCopy_api_ReplicationControllerStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 2781 { 2782 in := in.(*ReplicationControllerStatus) 2783 out := out.(*ReplicationControllerStatus) 2784 *out = *in 2785 if in.Conditions != nil { 2786 in, out := &in.Conditions, &out.Conditions 2787 *out = make([]ReplicationControllerCondition, len(*in)) 2788 for i := range *in { 2789 if err := DeepCopy_api_ReplicationControllerCondition(&(*in)[i], &(*out)[i], c); err != nil { 2790 return err 2791 } 2792 } 2793 } 2794 return nil 2795 } 2796} 2797 2798func DeepCopy_api_ResourceFieldSelector(in interface{}, out interface{}, c *conversion.Cloner) error { 2799 { 2800 in := in.(*ResourceFieldSelector) 2801 out := out.(*ResourceFieldSelector) 2802 *out = *in 2803 out.Divisor = in.Divisor.DeepCopy() 2804 return nil 2805 } 2806} 2807 2808func DeepCopy_api_ResourceQuota(in interface{}, out interface{}, c *conversion.Cloner) error { 2809 { 2810 in := in.(*ResourceQuota) 2811 out := out.(*ResourceQuota) 2812 *out = *in 2813 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2814 return err 2815 } else { 2816 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2817 } 2818 if err := DeepCopy_api_ResourceQuotaSpec(&in.Spec, &out.Spec, c); err != nil { 2819 return err 2820 } 2821 if err := DeepCopy_api_ResourceQuotaStatus(&in.Status, &out.Status, c); err != nil { 2822 return err 2823 } 2824 return nil 2825 } 2826} 2827 2828func DeepCopy_api_ResourceQuotaList(in interface{}, out interface{}, c *conversion.Cloner) error { 2829 { 2830 in := in.(*ResourceQuotaList) 2831 out := out.(*ResourceQuotaList) 2832 *out = *in 2833 if in.Items != nil { 2834 in, out := &in.Items, &out.Items 2835 *out = make([]ResourceQuota, len(*in)) 2836 for i := range *in { 2837 if err := DeepCopy_api_ResourceQuota(&(*in)[i], &(*out)[i], c); err != nil { 2838 return err 2839 } 2840 } 2841 } 2842 return nil 2843 } 2844} 2845 2846func DeepCopy_api_ResourceQuotaSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 2847 { 2848 in := in.(*ResourceQuotaSpec) 2849 out := out.(*ResourceQuotaSpec) 2850 *out = *in 2851 if in.Hard != nil { 2852 in, out := &in.Hard, &out.Hard 2853 *out = make(ResourceList) 2854 for key, val := range *in { 2855 (*out)[key] = val.DeepCopy() 2856 } 2857 } 2858 if in.Scopes != nil { 2859 in, out := &in.Scopes, &out.Scopes 2860 *out = make([]ResourceQuotaScope, len(*in)) 2861 copy(*out, *in) 2862 } 2863 return nil 2864 } 2865} 2866 2867func DeepCopy_api_ResourceQuotaStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 2868 { 2869 in := in.(*ResourceQuotaStatus) 2870 out := out.(*ResourceQuotaStatus) 2871 *out = *in 2872 if in.Hard != nil { 2873 in, out := &in.Hard, &out.Hard 2874 *out = make(ResourceList) 2875 for key, val := range *in { 2876 (*out)[key] = val.DeepCopy() 2877 } 2878 } 2879 if in.Used != nil { 2880 in, out := &in.Used, &out.Used 2881 *out = make(ResourceList) 2882 for key, val := range *in { 2883 (*out)[key] = val.DeepCopy() 2884 } 2885 } 2886 return nil 2887 } 2888} 2889 2890func DeepCopy_api_ResourceRequirements(in interface{}, out interface{}, c *conversion.Cloner) error { 2891 { 2892 in := in.(*ResourceRequirements) 2893 out := out.(*ResourceRequirements) 2894 *out = *in 2895 if in.Limits != nil { 2896 in, out := &in.Limits, &out.Limits 2897 *out = make(ResourceList) 2898 for key, val := range *in { 2899 (*out)[key] = val.DeepCopy() 2900 } 2901 } 2902 if in.Requests != nil { 2903 in, out := &in.Requests, &out.Requests 2904 *out = make(ResourceList) 2905 for key, val := range *in { 2906 (*out)[key] = val.DeepCopy() 2907 } 2908 } 2909 return nil 2910 } 2911} 2912 2913func DeepCopy_api_SELinuxOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 2914 { 2915 in := in.(*SELinuxOptions) 2916 out := out.(*SELinuxOptions) 2917 *out = *in 2918 return nil 2919 } 2920} 2921 2922func DeepCopy_api_ScaleIOVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2923 { 2924 in := in.(*ScaleIOVolumeSource) 2925 out := out.(*ScaleIOVolumeSource) 2926 *out = *in 2927 if in.SecretRef != nil { 2928 in, out := &in.SecretRef, &out.SecretRef 2929 *out = new(LocalObjectReference) 2930 **out = **in 2931 } 2932 return nil 2933 } 2934} 2935 2936func DeepCopy_api_Secret(in interface{}, out interface{}, c *conversion.Cloner) error { 2937 { 2938 in := in.(*Secret) 2939 out := out.(*Secret) 2940 *out = *in 2941 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 2942 return err 2943 } else { 2944 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 2945 } 2946 if in.Data != nil { 2947 in, out := &in.Data, &out.Data 2948 *out = make(map[string][]byte) 2949 for key, val := range *in { 2950 if newVal, err := c.DeepCopy(&val); err != nil { 2951 return err 2952 } else { 2953 (*out)[key] = *newVal.(*[]byte) 2954 } 2955 } 2956 } 2957 return nil 2958 } 2959} 2960 2961func DeepCopy_api_SecretEnvSource(in interface{}, out interface{}, c *conversion.Cloner) error { 2962 { 2963 in := in.(*SecretEnvSource) 2964 out := out.(*SecretEnvSource) 2965 *out = *in 2966 if in.Optional != nil { 2967 in, out := &in.Optional, &out.Optional 2968 *out = new(bool) 2969 **out = **in 2970 } 2971 return nil 2972 } 2973} 2974 2975func DeepCopy_api_SecretKeySelector(in interface{}, out interface{}, c *conversion.Cloner) error { 2976 { 2977 in := in.(*SecretKeySelector) 2978 out := out.(*SecretKeySelector) 2979 *out = *in 2980 if in.Optional != nil { 2981 in, out := &in.Optional, &out.Optional 2982 *out = new(bool) 2983 **out = **in 2984 } 2985 return nil 2986 } 2987} 2988 2989func DeepCopy_api_SecretList(in interface{}, out interface{}, c *conversion.Cloner) error { 2990 { 2991 in := in.(*SecretList) 2992 out := out.(*SecretList) 2993 *out = *in 2994 if in.Items != nil { 2995 in, out := &in.Items, &out.Items 2996 *out = make([]Secret, len(*in)) 2997 for i := range *in { 2998 if err := DeepCopy_api_Secret(&(*in)[i], &(*out)[i], c); err != nil { 2999 return err 3000 } 3001 } 3002 } 3003 return nil 3004 } 3005} 3006 3007func DeepCopy_api_SecretProjection(in interface{}, out interface{}, c *conversion.Cloner) error { 3008 { 3009 in := in.(*SecretProjection) 3010 out := out.(*SecretProjection) 3011 *out = *in 3012 if in.Items != nil { 3013 in, out := &in.Items, &out.Items 3014 *out = make([]KeyToPath, len(*in)) 3015 for i := range *in { 3016 if err := DeepCopy_api_KeyToPath(&(*in)[i], &(*out)[i], c); err != nil { 3017 return err 3018 } 3019 } 3020 } 3021 if in.Optional != nil { 3022 in, out := &in.Optional, &out.Optional 3023 *out = new(bool) 3024 **out = **in 3025 } 3026 return nil 3027 } 3028} 3029 3030func DeepCopy_api_SecretVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 3031 { 3032 in := in.(*SecretVolumeSource) 3033 out := out.(*SecretVolumeSource) 3034 *out = *in 3035 if in.Items != nil { 3036 in, out := &in.Items, &out.Items 3037 *out = make([]KeyToPath, len(*in)) 3038 for i := range *in { 3039 if err := DeepCopy_api_KeyToPath(&(*in)[i], &(*out)[i], c); err != nil { 3040 return err 3041 } 3042 } 3043 } 3044 if in.DefaultMode != nil { 3045 in, out := &in.DefaultMode, &out.DefaultMode 3046 *out = new(int32) 3047 **out = **in 3048 } 3049 if in.Optional != nil { 3050 in, out := &in.Optional, &out.Optional 3051 *out = new(bool) 3052 **out = **in 3053 } 3054 return nil 3055 } 3056} 3057 3058func DeepCopy_api_SecurityContext(in interface{}, out interface{}, c *conversion.Cloner) error { 3059 { 3060 in := in.(*SecurityContext) 3061 out := out.(*SecurityContext) 3062 *out = *in 3063 if in.Capabilities != nil { 3064 in, out := &in.Capabilities, &out.Capabilities 3065 *out = new(Capabilities) 3066 if err := DeepCopy_api_Capabilities(*in, *out, c); err != nil { 3067 return err 3068 } 3069 } 3070 if in.Privileged != nil { 3071 in, out := &in.Privileged, &out.Privileged 3072 *out = new(bool) 3073 **out = **in 3074 } 3075 if in.SELinuxOptions != nil { 3076 in, out := &in.SELinuxOptions, &out.SELinuxOptions 3077 *out = new(SELinuxOptions) 3078 **out = **in 3079 } 3080 if in.RunAsUser != nil { 3081 in, out := &in.RunAsUser, &out.RunAsUser 3082 *out = new(int64) 3083 **out = **in 3084 } 3085 if in.RunAsNonRoot != nil { 3086 in, out := &in.RunAsNonRoot, &out.RunAsNonRoot 3087 *out = new(bool) 3088 **out = **in 3089 } 3090 if in.ReadOnlyRootFilesystem != nil { 3091 in, out := &in.ReadOnlyRootFilesystem, &out.ReadOnlyRootFilesystem 3092 *out = new(bool) 3093 **out = **in 3094 } 3095 return nil 3096 } 3097} 3098 3099func DeepCopy_api_SerializedReference(in interface{}, out interface{}, c *conversion.Cloner) error { 3100 { 3101 in := in.(*SerializedReference) 3102 out := out.(*SerializedReference) 3103 *out = *in 3104 return nil 3105 } 3106} 3107 3108func DeepCopy_api_Service(in interface{}, out interface{}, c *conversion.Cloner) error { 3109 { 3110 in := in.(*Service) 3111 out := out.(*Service) 3112 *out = *in 3113 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 3114 return err 3115 } else { 3116 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 3117 } 3118 if err := DeepCopy_api_ServiceSpec(&in.Spec, &out.Spec, c); err != nil { 3119 return err 3120 } 3121 if err := DeepCopy_api_ServiceStatus(&in.Status, &out.Status, c); err != nil { 3122 return err 3123 } 3124 return nil 3125 } 3126} 3127 3128func DeepCopy_api_ServiceAccount(in interface{}, out interface{}, c *conversion.Cloner) error { 3129 { 3130 in := in.(*ServiceAccount) 3131 out := out.(*ServiceAccount) 3132 *out = *in 3133 if newVal, err := c.DeepCopy(&in.ObjectMeta); err != nil { 3134 return err 3135 } else { 3136 out.ObjectMeta = *newVal.(*v1.ObjectMeta) 3137 } 3138 if in.Secrets != nil { 3139 in, out := &in.Secrets, &out.Secrets 3140 *out = make([]ObjectReference, len(*in)) 3141 copy(*out, *in) 3142 } 3143 if in.ImagePullSecrets != nil { 3144 in, out := &in.ImagePullSecrets, &out.ImagePullSecrets 3145 *out = make([]LocalObjectReference, len(*in)) 3146 copy(*out, *in) 3147 } 3148 if in.AutomountServiceAccountToken != nil { 3149 in, out := &in.AutomountServiceAccountToken, &out.AutomountServiceAccountToken 3150 *out = new(bool) 3151 **out = **in 3152 } 3153 return nil 3154 } 3155} 3156 3157func DeepCopy_api_ServiceAccountList(in interface{}, out interface{}, c *conversion.Cloner) error { 3158 { 3159 in := in.(*ServiceAccountList) 3160 out := out.(*ServiceAccountList) 3161 *out = *in 3162 if in.Items != nil { 3163 in, out := &in.Items, &out.Items 3164 *out = make([]ServiceAccount, len(*in)) 3165 for i := range *in { 3166 if err := DeepCopy_api_ServiceAccount(&(*in)[i], &(*out)[i], c); err != nil { 3167 return err 3168 } 3169 } 3170 } 3171 return nil 3172 } 3173} 3174 3175func DeepCopy_api_ServiceList(in interface{}, out interface{}, c *conversion.Cloner) error { 3176 { 3177 in := in.(*ServiceList) 3178 out := out.(*ServiceList) 3179 *out = *in 3180 if in.Items != nil { 3181 in, out := &in.Items, &out.Items 3182 *out = make([]Service, len(*in)) 3183 for i := range *in { 3184 if err := DeepCopy_api_Service(&(*in)[i], &(*out)[i], c); err != nil { 3185 return err 3186 } 3187 } 3188 } 3189 return nil 3190 } 3191} 3192 3193func DeepCopy_api_ServicePort(in interface{}, out interface{}, c *conversion.Cloner) error { 3194 { 3195 in := in.(*ServicePort) 3196 out := out.(*ServicePort) 3197 *out = *in 3198 return nil 3199 } 3200} 3201 3202func DeepCopy_api_ServiceProxyOptions(in interface{}, out interface{}, c *conversion.Cloner) error { 3203 { 3204 in := in.(*ServiceProxyOptions) 3205 out := out.(*ServiceProxyOptions) 3206 *out = *in 3207 return nil 3208 } 3209} 3210 3211func DeepCopy_api_ServiceSpec(in interface{}, out interface{}, c *conversion.Cloner) error { 3212 { 3213 in := in.(*ServiceSpec) 3214 out := out.(*ServiceSpec) 3215 *out = *in 3216 if in.Ports != nil { 3217 in, out := &in.Ports, &out.Ports 3218 *out = make([]ServicePort, len(*in)) 3219 copy(*out, *in) 3220 } 3221 if in.Selector != nil { 3222 in, out := &in.Selector, &out.Selector 3223 *out = make(map[string]string) 3224 for key, val := range *in { 3225 (*out)[key] = val 3226 } 3227 } 3228 if in.ExternalIPs != nil { 3229 in, out := &in.ExternalIPs, &out.ExternalIPs 3230 *out = make([]string, len(*in)) 3231 copy(*out, *in) 3232 } 3233 if in.LoadBalancerSourceRanges != nil { 3234 in, out := &in.LoadBalancerSourceRanges, &out.LoadBalancerSourceRanges 3235 *out = make([]string, len(*in)) 3236 copy(*out, *in) 3237 } 3238 return nil 3239 } 3240} 3241 3242func DeepCopy_api_ServiceStatus(in interface{}, out interface{}, c *conversion.Cloner) error { 3243 { 3244 in := in.(*ServiceStatus) 3245 out := out.(*ServiceStatus) 3246 *out = *in 3247 if err := DeepCopy_api_LoadBalancerStatus(&in.LoadBalancer, &out.LoadBalancer, c); err != nil { 3248 return err 3249 } 3250 return nil 3251 } 3252} 3253 3254func DeepCopy_api_Sysctl(in interface{}, out interface{}, c *conversion.Cloner) error { 3255 { 3256 in := in.(*Sysctl) 3257 out := out.(*Sysctl) 3258 *out = *in 3259 return nil 3260 } 3261} 3262 3263func DeepCopy_api_TCPSocketAction(in interface{}, out interface{}, c *conversion.Cloner) error { 3264 { 3265 in := in.(*TCPSocketAction) 3266 out := out.(*TCPSocketAction) 3267 *out = *in 3268 return nil 3269 } 3270} 3271 3272func DeepCopy_api_Taint(in interface{}, out interface{}, c *conversion.Cloner) error { 3273 { 3274 in := in.(*Taint) 3275 out := out.(*Taint) 3276 *out = *in 3277 out.TimeAdded = in.TimeAdded.DeepCopy() 3278 return nil 3279 } 3280} 3281 3282func DeepCopy_api_Toleration(in interface{}, out interface{}, c *conversion.Cloner) error { 3283 { 3284 in := in.(*Toleration) 3285 out := out.(*Toleration) 3286 *out = *in 3287 if in.TolerationSeconds != nil { 3288 in, out := &in.TolerationSeconds, &out.TolerationSeconds 3289 *out = new(int64) 3290 **out = **in 3291 } 3292 return nil 3293 } 3294} 3295 3296func DeepCopy_api_Volume(in interface{}, out interface{}, c *conversion.Cloner) error { 3297 { 3298 in := in.(*Volume) 3299 out := out.(*Volume) 3300 *out = *in 3301 if err := DeepCopy_api_VolumeSource(&in.VolumeSource, &out.VolumeSource, c); err != nil { 3302 return err 3303 } 3304 return nil 3305 } 3306} 3307 3308func DeepCopy_api_VolumeMount(in interface{}, out interface{}, c *conversion.Cloner) error { 3309 { 3310 in := in.(*VolumeMount) 3311 out := out.(*VolumeMount) 3312 *out = *in 3313 return nil 3314 } 3315} 3316 3317func DeepCopy_api_VolumeProjection(in interface{}, out interface{}, c *conversion.Cloner) error { 3318 { 3319 in := in.(*VolumeProjection) 3320 out := out.(*VolumeProjection) 3321 *out = *in 3322 if in.Secret != nil { 3323 in, out := &in.Secret, &out.Secret 3324 *out = new(SecretProjection) 3325 if err := DeepCopy_api_SecretProjection(*in, *out, c); err != nil { 3326 return err 3327 } 3328 } 3329 if in.DownwardAPI != nil { 3330 in, out := &in.DownwardAPI, &out.DownwardAPI 3331 *out = new(DownwardAPIProjection) 3332 if err := DeepCopy_api_DownwardAPIProjection(*in, *out, c); err != nil { 3333 return err 3334 } 3335 } 3336 if in.ConfigMap != nil { 3337 in, out := &in.ConfigMap, &out.ConfigMap 3338 *out = new(ConfigMapProjection) 3339 if err := DeepCopy_api_ConfigMapProjection(*in, *out, c); err != nil { 3340 return err 3341 } 3342 } 3343 return nil 3344 } 3345} 3346 3347func DeepCopy_api_VolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 3348 { 3349 in := in.(*VolumeSource) 3350 out := out.(*VolumeSource) 3351 *out = *in 3352 if in.HostPath != nil { 3353 in, out := &in.HostPath, &out.HostPath 3354 *out = new(HostPathVolumeSource) 3355 **out = **in 3356 } 3357 if in.EmptyDir != nil { 3358 in, out := &in.EmptyDir, &out.EmptyDir 3359 *out = new(EmptyDirVolumeSource) 3360 **out = **in 3361 } 3362 if in.GCEPersistentDisk != nil { 3363 in, out := &in.GCEPersistentDisk, &out.GCEPersistentDisk 3364 *out = new(GCEPersistentDiskVolumeSource) 3365 **out = **in 3366 } 3367 if in.AWSElasticBlockStore != nil { 3368 in, out := &in.AWSElasticBlockStore, &out.AWSElasticBlockStore 3369 *out = new(AWSElasticBlockStoreVolumeSource) 3370 **out = **in 3371 } 3372 if in.GitRepo != nil { 3373 in, out := &in.GitRepo, &out.GitRepo 3374 *out = new(GitRepoVolumeSource) 3375 **out = **in 3376 } 3377 if in.Secret != nil { 3378 in, out := &in.Secret, &out.Secret 3379 *out = new(SecretVolumeSource) 3380 if err := DeepCopy_api_SecretVolumeSource(*in, *out, c); err != nil { 3381 return err 3382 } 3383 } 3384 if in.NFS != nil { 3385 in, out := &in.NFS, &out.NFS 3386 *out = new(NFSVolumeSource) 3387 **out = **in 3388 } 3389 if in.ISCSI != nil { 3390 in, out := &in.ISCSI, &out.ISCSI 3391 *out = new(ISCSIVolumeSource) 3392 if err := DeepCopy_api_ISCSIVolumeSource(*in, *out, c); err != nil { 3393 return err 3394 } 3395 } 3396 if in.Glusterfs != nil { 3397 in, out := &in.Glusterfs, &out.Glusterfs 3398 *out = new(GlusterfsVolumeSource) 3399 **out = **in 3400 } 3401 if in.PersistentVolumeClaim != nil { 3402 in, out := &in.PersistentVolumeClaim, &out.PersistentVolumeClaim 3403 *out = new(PersistentVolumeClaimVolumeSource) 3404 **out = **in 3405 } 3406 if in.RBD != nil { 3407 in, out := &in.RBD, &out.RBD 3408 *out = new(RBDVolumeSource) 3409 if err := DeepCopy_api_RBDVolumeSource(*in, *out, c); err != nil { 3410 return err 3411 } 3412 } 3413 if in.Quobyte != nil { 3414 in, out := &in.Quobyte, &out.Quobyte 3415 *out = new(QuobyteVolumeSource) 3416 **out = **in 3417 } 3418 if in.FlexVolume != nil { 3419 in, out := &in.FlexVolume, &out.FlexVolume 3420 *out = new(FlexVolumeSource) 3421 if err := DeepCopy_api_FlexVolumeSource(*in, *out, c); err != nil { 3422 return err 3423 } 3424 } 3425 if in.Cinder != nil { 3426 in, out := &in.Cinder, &out.Cinder 3427 *out = new(CinderVolumeSource) 3428 **out = **in 3429 } 3430 if in.CephFS != nil { 3431 in, out := &in.CephFS, &out.CephFS 3432 *out = new(CephFSVolumeSource) 3433 if err := DeepCopy_api_CephFSVolumeSource(*in, *out, c); err != nil { 3434 return err 3435 } 3436 } 3437 if in.Flocker != nil { 3438 in, out := &in.Flocker, &out.Flocker 3439 *out = new(FlockerVolumeSource) 3440 **out = **in 3441 } 3442 if in.DownwardAPI != nil { 3443 in, out := &in.DownwardAPI, &out.DownwardAPI 3444 *out = new(DownwardAPIVolumeSource) 3445 if err := DeepCopy_api_DownwardAPIVolumeSource(*in, *out, c); err != nil { 3446 return err 3447 } 3448 } 3449 if in.FC != nil { 3450 in, out := &in.FC, &out.FC 3451 *out = new(FCVolumeSource) 3452 if err := DeepCopy_api_FCVolumeSource(*in, *out, c); err != nil { 3453 return err 3454 } 3455 } 3456 if in.AzureFile != nil { 3457 in, out := &in.AzureFile, &out.AzureFile 3458 *out = new(AzureFileVolumeSource) 3459 **out = **in 3460 } 3461 if in.ConfigMap != nil { 3462 in, out := &in.ConfigMap, &out.ConfigMap 3463 *out = new(ConfigMapVolumeSource) 3464 if err := DeepCopy_api_ConfigMapVolumeSource(*in, *out, c); err != nil { 3465 return err 3466 } 3467 } 3468 if in.VsphereVolume != nil { 3469 in, out := &in.VsphereVolume, &out.VsphereVolume 3470 *out = new(VsphereVirtualDiskVolumeSource) 3471 **out = **in 3472 } 3473 if in.AzureDisk != nil { 3474 in, out := &in.AzureDisk, &out.AzureDisk 3475 *out = new(AzureDiskVolumeSource) 3476 if err := DeepCopy_api_AzureDiskVolumeSource(*in, *out, c); err != nil { 3477 return err 3478 } 3479 } 3480 if in.PhotonPersistentDisk != nil { 3481 in, out := &in.PhotonPersistentDisk, &out.PhotonPersistentDisk 3482 *out = new(PhotonPersistentDiskVolumeSource) 3483 **out = **in 3484 } 3485 if in.Projected != nil { 3486 in, out := &in.Projected, &out.Projected 3487 *out = new(ProjectedVolumeSource) 3488 if err := DeepCopy_api_ProjectedVolumeSource(*in, *out, c); err != nil { 3489 return err 3490 } 3491 } 3492 if in.PortworxVolume != nil { 3493 in, out := &in.PortworxVolume, &out.PortworxVolume 3494 *out = new(PortworxVolumeSource) 3495 **out = **in 3496 } 3497 if in.ScaleIO != nil { 3498 in, out := &in.ScaleIO, &out.ScaleIO 3499 *out = new(ScaleIOVolumeSource) 3500 if err := DeepCopy_api_ScaleIOVolumeSource(*in, *out, c); err != nil { 3501 return err 3502 } 3503 } 3504 return nil 3505 } 3506} 3507 3508func DeepCopy_api_VsphereVirtualDiskVolumeSource(in interface{}, out interface{}, c *conversion.Cloner) error { 3509 { 3510 in := in.(*VsphereVirtualDiskVolumeSource) 3511 out := out.(*VsphereVirtualDiskVolumeSource) 3512 *out = *in 3513 return nil 3514 } 3515} 3516 3517func DeepCopy_api_WeightedPodAffinityTerm(in interface{}, out interface{}, c *conversion.Cloner) error { 3518 { 3519 in := in.(*WeightedPodAffinityTerm) 3520 out := out.(*WeightedPodAffinityTerm) 3521 *out = *in 3522 if err := DeepCopy_api_PodAffinityTerm(&in.PodAffinityTerm, &out.PodAffinityTerm, c); err != nil { 3523 return err 3524 } 3525 return nil 3526 } 3527} 3528