kubernetes/staging/src/k8s.io/code-generator/cmd/deepcopy-gen/generators/deepcopy.go

const tagEnabledName …

const interfacesTagName …

const interfacesNonPointerTagName …

const tagValuePackage …

type enabledTagValue …

func extractEnabledTypeTag(t *types.Type) *enabledTagValue { … }

func extractEnabledTag(comments []string) *enabledTagValue { … }

// TODO: This is created only to reduce number of changes in a single PR.
// Remove it and use PublicNamer instead.
func deepCopyNamer() *namer.NameStrategy { … }

// NameSystems returns the name system used by the generators in this package.
func NameSystems() namer.NameSystems { … }

// DefaultNameSystem returns the default name system for ordering the types to be
// processed by the generators in this package.
func DefaultNameSystem() string { … }

func GetTargets(context *generator.Context, args *args.Args) []generator.Target { … }

type genDeepCopy …

func NewGenDeepCopy(outputFilename, targetPackage string, boundingDirs []string, allTypes, registerTypes bool) generator.Generator { … }

func (g *genDeepCopy) Namers(c *generator.Context) namer.NameSystems { … }

func (g *genDeepCopy) Filter(c *generator.Context, t *types.Type) bool { … }

// deepCopyMethod returns the signature of a DeepCopy() method, nil or an error
// if the type does not match. This allows more efficient deep copy
// implementations to be defined by the type's author.  The correct signature
// for a type T is:
//
//	func (t T) DeepCopy() T
//
// or:
//
//	func (t *T) DeepCopy() *T
func deepCopyMethod(t *types.Type) (*types.Signature, error) { … }

// deepCopyMethodOrDie returns the signatrue of a DeepCopy method, nil or calls klog.Fatalf
// if the type does not match.
func deepCopyMethodOrDie(t *types.Type) *types.Signature { … }

// deepCopyIntoMethod returns the signature of a DeepCopyInto() method, nil or an error
// if the type is wrong. DeepCopyInto allows more efficient deep copy
// implementations to be defined by the type's author.  The correct signature
// for a type T is:
//
//	func (t T) DeepCopyInto(t *T)
//
// or:
//
//	func (t *T) DeepCopyInto(t *T)
func deepCopyIntoMethod(t *types.Type) (*types.Signature, error) { … }

// deepCopyIntoMethodOrDie returns the signature of a DeepCopyInto() method, nil or calls klog.Fatalf
// if the type is wrong.
func deepCopyIntoMethodOrDie(t *types.Type) *types.Signature { … }

func copyableType(t *types.Type) bool { … }

func underlyingType(t *types.Type) *types.Type { … }

func (g *genDeepCopy) isOtherPackage(pkg string) bool { … }

func (g *genDeepCopy) Imports(c *generator.Context) (imports []string) { … }

func argsFromType(ts ...*types.Type) generator.Args { … }

func (g *genDeepCopy) Init(c *generator.Context, w io.Writer) error { … }

func (g *genDeepCopy) needsGeneration(t *types.Type) bool { … }

func extractInterfacesTag(t *types.Type) []string { … }

func extractNonPointerInterfaces(t *types.Type) (bool, error) { … }

func (g *genDeepCopy) deepCopyableInterfacesInner(c *generator.Context, t *types.Type) ([]*types.Type, error) { … }

// deepCopyableInterfaces returns the interface types to implement and whether they apply to a non-pointer receiver.
func (g *genDeepCopy) deepCopyableInterfaces(c *generator.Context, t *types.Type) ([]*types.Type, bool, error) { … }

type TypeSlice …

func (s TypeSlice) Len() int           { … }

func (s TypeSlice) Less(i, j int) bool { … }

func (s TypeSlice) Swap(i, j int)      { … }

func (s TypeSlice) Sort()              { … }

func (g *genDeepCopy) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { … }

// isReference return true for pointer, maps, slices and aliases of those.
func isReference(t *types.Type) bool { … }

// we use the system of shadowing 'in' and 'out' so that the same code is valid
// at any nesting level. This makes the autogenerator easy to understand, and
// the compiler shouldn't care.
func (g *genDeepCopy) generateFor(t *types.Type, sw *generator.SnippetWriter) { … }

// doBuiltin generates code for a builtin or an alias to a builtin. The generated code is
// is the same for both cases, i.e. it's the code for the underlying type.
func (g *genDeepCopy) doBuiltin(t *types.Type, sw *generator.SnippetWriter) { … }

// doMap generates code for a map or an alias to a map. The generated code is
// is the same for both cases, i.e. it's the code for the underlying type.
func (g *genDeepCopy) doMap(t *types.Type, sw *generator.SnippetWriter) { … }

// doSlice generates code for a slice or an alias to a slice. The generated code is
// is the same for both cases, i.e. it's the code for the underlying type.
func (g *genDeepCopy) doSlice(t *types.Type, sw *generator.SnippetWriter) { … }

// doStruct generates code for a struct or an alias to a struct. The generated code is
// is the same for both cases, i.e. it's the code for the underlying type.
func (g *genDeepCopy) doStruct(t *types.Type, sw *generator.SnippetWriter) { … }

// doPointer generates code for a pointer or an alias to a pointer. The generated code is
// is the same for both cases, i.e. it's the code for the underlying type.
func (g *genDeepCopy) doPointer(t *types.Type, sw *generator.SnippetWriter) { … }