cmd/bpa-operator/vendor/k8s.io/client-go/tools/clientcmd/api/zz_generated.deepcopy.go

   1 // +build !ignore_autogenerated
   2
   3 /*
   4 Copyright The Kubernetes Authors.
   5
   6 Licensed under the Apache License, Version 2.0 (the "License");
   7 you may not use this file except in compliance with the License.
   8 You may obtain a copy of the License at
   9
  10     http://www.apache.org/licenses/LICENSE-2.0
  11
  12 Unless required by applicable law or agreed to in writing, software
  13 distributed under the License is distributed on an "AS IS" BASIS,
  14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 See the License for the specific language governing permissions and
  16 limitations under the License.
  17 */
  18
  19 // Code generated by deepcopy-gen. DO NOT EDIT.
  20
  21 package api
  22
  23 import (
  24         runtime "k8s.io/apimachinery/pkg/runtime"
  25 )
  26
  27 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
  28 func (in *AuthInfo) DeepCopyInto(out *AuthInfo) {
  29         *out = *in
  30         if in.ClientCertificateData != nil {
  31                 in, out := &in.ClientCertificateData, &out.ClientCertificateData
  32                 *out = make([]byte, len(*in))
  33                 copy(*out, *in)
  34         }
  35         if in.ClientKeyData != nil {
  36                 in, out := &in.ClientKeyData, &out.ClientKeyData
  37                 *out = make([]byte, len(*in))
  38                 copy(*out, *in)
  39         }
  40         if in.ImpersonateGroups != nil {
  41                 in, out := &in.ImpersonateGroups, &out.ImpersonateGroups
  42                 *out = make([]string, len(*in))
  43                 copy(*out, *in)
  44         }
  45         if in.ImpersonateUserExtra != nil {
  46                 in, out := &in.ImpersonateUserExtra, &out.ImpersonateUserExtra
  47                 *out = make(map[string][]string, len(*in))
  48                 for key, val := range *in {
  49                         var outVal []string
  50                         if val == nil {
  51                                 (*out)[key] = nil
  52                         } else {
  53                                 in, out := &val, &outVal
  54                                 *out = make([]string, len(*in))
  55                                 copy(*out, *in)
  56                         }
  57                         (*out)[key] = outVal
  58                 }
  59         }
  60         if in.AuthProvider != nil {
  61                 in, out := &in.AuthProvider, &out.AuthProvider
  62                 *out = new(AuthProviderConfig)
  63                 (*in).DeepCopyInto(*out)
  64         }
  65         if in.Exec != nil {
  66                 in, out := &in.Exec, &out.Exec
  67                 *out = new(ExecConfig)
  68                 (*in).DeepCopyInto(*out)
  69         }
  70         if in.Extensions != nil {
  71                 in, out := &in.Extensions, &out.Extensions
  72                 *out = make(map[string]runtime.Object, len(*in))
  73                 for key, val := range *in {
  74                         if val == nil {
  75                                 (*out)[key] = nil
  76                         } else {
  77                                 (*out)[key] = val.DeepCopyObject()
  78                         }
  79                 }
  80         }
  81         return
  82 }
  83
  84 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthInfo.
  85 func (in *AuthInfo) DeepCopy() *AuthInfo {
  86         if in == nil {
  87                 return nil
  88         }
  89         out := new(AuthInfo)
  90         in.DeepCopyInto(out)
  91         return out
  92 }
  93
  94 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
  95 func (in *AuthProviderConfig) DeepCopyInto(out *AuthProviderConfig) {
  96         *out = *in
  97         if in.Config != nil {
  98                 in, out := &in.Config, &out.Config
  99                 *out = make(map[string]string, len(*in))
 100                 for key, val := range *in {
 101                         (*out)[key] = val
 102                 }
 103         }
 104         return
 105 }
 106
 107 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthProviderConfig.
 108 func (in *AuthProviderConfig) DeepCopy() *AuthProviderConfig {
 109         if in == nil {
 110                 return nil
 111         }
 112         out := new(AuthProviderConfig)
 113         in.DeepCopyInto(out)
 114         return out
 115 }
 116
 117 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 118 func (in *Cluster) DeepCopyInto(out *Cluster) {
 119         *out = *in
 120         if in.CertificateAuthorityData != nil {
 121                 in, out := &in.CertificateAuthorityData, &out.CertificateAuthorityData
 122                 *out = make([]byte, len(*in))
 123                 copy(*out, *in)
 124         }
 125         if in.Extensions != nil {
 126                 in, out := &in.Extensions, &out.Extensions
 127                 *out = make(map[string]runtime.Object, len(*in))
 128                 for key, val := range *in {
 129                         if val == nil {
 130                                 (*out)[key] = nil
 131                         } else {
 132                                 (*out)[key] = val.DeepCopyObject()
 133                         }
 134                 }
 135         }
 136         return
 137 }
 138
 139 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Cluster.
 140 func (in *Cluster) DeepCopy() *Cluster {
 141         if in == nil {
 142                 return nil
 143         }
 144         out := new(Cluster)
 145         in.DeepCopyInto(out)
 146         return out
 147 }
 148
 149 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 150 func (in *Config) DeepCopyInto(out *Config) {
 151         *out = *in
 152         in.Preferences.DeepCopyInto(&out.Preferences)
 153         if in.Clusters != nil {
 154                 in, out := &in.Clusters, &out.Clusters
 155                 *out = make(map[string]*Cluster, len(*in))
 156                 for key, val := range *in {
 157                         var outVal *Cluster
 158                         if val == nil {
 159                                 (*out)[key] = nil
 160                         } else {
 161                                 in, out := &val, &outVal
 162                                 *out = new(Cluster)
 163                                 (*in).DeepCopyInto(*out)
 164                         }
 165                         (*out)[key] = outVal
 166                 }
 167         }
 168         if in.AuthInfos != nil {
 169                 in, out := &in.AuthInfos, &out.AuthInfos
 170                 *out = make(map[string]*AuthInfo, len(*in))
 171                 for key, val := range *in {
 172                         var outVal *AuthInfo
 173                         if val == nil {
 174                                 (*out)[key] = nil
 175                         } else {
 176                                 in, out := &val, &outVal
 177                                 *out = new(AuthInfo)
 178                                 (*in).DeepCopyInto(*out)
 179                         }
 180                         (*out)[key] = outVal
 181                 }
 182         }
 183         if in.Contexts != nil {
 184                 in, out := &in.Contexts, &out.Contexts
 185                 *out = make(map[string]*Context, len(*in))
 186                 for key, val := range *in {
 187                         var outVal *Context
 188                         if val == nil {
 189                                 (*out)[key] = nil
 190                         } else {
 191                                 in, out := &val, &outVal
 192                                 *out = new(Context)
 193                                 (*in).DeepCopyInto(*out)
 194                         }
 195                         (*out)[key] = outVal
 196                 }
 197         }
 198         if in.Extensions != nil {
 199                 in, out := &in.Extensions, &out.Extensions
 200                 *out = make(map[string]runtime.Object, len(*in))
 201                 for key, val := range *in {
 202                         if val == nil {
 203                                 (*out)[key] = nil
 204                         } else {
 205                                 (*out)[key] = val.DeepCopyObject()
 206                         }
 207                 }
 208         }
 209         return
 210 }
 211
 212 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Config.
 213 func (in *Config) DeepCopy() *Config {
 214         if in == nil {
 215                 return nil
 216         }
 217         out := new(Config)
 218         in.DeepCopyInto(out)
 219         return out
 220 }
 221
 222 // DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
 223 func (in *Config) DeepCopyObject() runtime.Object {
 224         if c := in.DeepCopy(); c != nil {
 225                 return c
 226         }
 227         return nil
 228 }
 229
 230 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 231 func (in *Context) DeepCopyInto(out *Context) {
 232         *out = *in
 233         if in.Extensions != nil {
 234                 in, out := &in.Extensions, &out.Extensions
 235                 *out = make(map[string]runtime.Object, len(*in))
 236                 for key, val := range *in {
 237                         if val == nil {
 238                                 (*out)[key] = nil
 239                         } else {
 240                                 (*out)[key] = val.DeepCopyObject()
 241                         }
 242                 }
 243         }
 244         return
 245 }
 246
 247 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Context.
 248 func (in *Context) DeepCopy() *Context {
 249         if in == nil {
 250                 return nil
 251         }
 252         out := new(Context)
 253         in.DeepCopyInto(out)
 254         return out
 255 }
 256
 257 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 258 func (in *ExecConfig) DeepCopyInto(out *ExecConfig) {
 259         *out = *in
 260         if in.Args != nil {
 261                 in, out := &in.Args, &out.Args
 262                 *out = make([]string, len(*in))
 263                 copy(*out, *in)
 264         }
 265         if in.Env != nil {
 266                 in, out := &in.Env, &out.Env
 267                 *out = make([]ExecEnvVar, len(*in))
 268                 copy(*out, *in)
 269         }
 270         return
 271 }
 272
 273 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExecConfig.
 274 func (in *ExecConfig) DeepCopy() *ExecConfig {
 275         if in == nil {
 276                 return nil
 277         }
 278         out := new(ExecConfig)
 279         in.DeepCopyInto(out)
 280         return out
 281 }
 282
 283 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 284 func (in *ExecEnvVar) DeepCopyInto(out *ExecEnvVar) {
 285         *out = *in
 286         return
 287 }
 288
 289 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExecEnvVar.
 290 func (in *ExecEnvVar) DeepCopy() *ExecEnvVar {
 291         if in == nil {
 292                 return nil
 293         }
 294         out := new(ExecEnvVar)
 295         in.DeepCopyInto(out)
 296         return out
 297 }
 298
 299 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 300 func (in *Preferences) DeepCopyInto(out *Preferences) {
 301         *out = *in
 302         if in.Extensions != nil {
 303                 in, out := &in.Extensions, &out.Extensions
 304                 *out = make(map[string]runtime.Object, len(*in))
 305                 for key, val := range *in {
 306                         if val == nil {
 307                                 (*out)[key] = nil
 308                         } else {
 309                                 (*out)[key] = val.DeepCopyObject()
 310                         }
 311                 }
 312         }
 313         return
 314 }
 315
 316 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Preferences.
 317 func (in *Preferences) DeepCopy() *Preferences {
 318         if in == nil {
 319                 return nil
 320         }
 321         out := new(Preferences)
 322         in.DeepCopyInto(out)
 323         return out
 324 }