github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-29 22:46:12 +00:00
Code Issues Projects Releases Wiki Activity

Renames for clarity in conversion-gen

Browse Source 
This is to clarify the intent of the code for new readers (me).
This commit is contained in:
Tim Hockin 2016-06-25 01:50:29 +09:00
parent ab16ccc158
commit ed59210f04
1 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
cmd/libs/go2idl/conversion-gen/generators/conversion.go
View File

@ -88,23 +88,23 @@ func getInternalTypeFor(context *generator.Context, t *types.Type) (*types.Type,
return context.Universe.Package(internalPackage).Type(t.Name.Name), true return context.Universe.Package(internalPackage).Type(t.Name.Name), true
} }
type conversionType struct { type conversionPair struct {
inType *types.Type inType *types.Type
outType *types.Type outType *types.Type
} }
// All of the types in conversions map are of type "DeclarationOf" with // All of the types in conversions map are of type "DeclarationOf" with
// the underlying type being "Func". // the underlying type being "Func".
type conversions map[conversionType]*types.Type type conversionFuncMap map[conversionPair]*types.Type
// Returns all already existing conversion functions that we are able to find. // Returns all manually-defined conversion functions that we are able to find.
func existingConversionFunctions(context *generator.Context) conversions { func getManualConversionFunctions(context *generator.Context) conversionFuncMap {
scopeName := types.Name{Package: conversionPackagePath, Name: "Scope"} scopeName := types.Name{Package: conversionPackagePath, Name: "Scope"}
errorName := types.Name{Package: "", Name: "error"} errorName := types.Name{Package: "", Name: "error"}
buffer := &bytes.Buffer{} buffer := &bytes.Buffer{}
sw := generator.NewSnippetWriter(buffer, context, "$", "$") sw := generator.NewSnippetWriter(buffer, context, "$", "$")
preexisting := make(conversions) manualMap := make(conversionFuncMap)
for _, p := range context.Universe { for _, p := range context.Universe {
for _, f := range p.Functions { for _, f := range p.Functions {
if f.Underlying == nil || f.Underlying.Kind != types.Func { if f.Underlying == nil || f.Underlying.Kind != types.Func {
@ -137,28 +137,28 @@ func existingConversionFunctions(context *generator.Context) conversions {
args := argsFromType(inType.Elem, outType.Elem) args := argsFromType(inType.Elem, outType.Elem)
sw.Do("Convert_$.inType|public$_To_$.outType|public$", args) sw.Do("Convert_$.inType|public$_To_$.outType|public$", args)
if f.Name.Name == buffer.String() { if f.Name.Name == buffer.String() {
key := conversionType{inType.Elem, outType.Elem} key := conversionPair{inType.Elem, outType.Elem}
if v, ok := preexisting[key]; ok && v != nil { if v, ok := manualMap[key]; ok && v != nil {
panic(fmt.Sprintf("duplicate static conversion defined: %#v", key)) panic(fmt.Sprintf("duplicate static conversion defined: %#v", key))
} }
preexisting[key] = f manualMap[key] = f
} }
buffer.Reset() buffer.Reset()
} }
} }
return preexisting return manualMap
} }
// All of the types in conversions map are of type "DeclarationOf" with // All of the types in conversions map are of type "DeclarationOf" with
// the underlying type being "Func". // the underlying type being "Func".
type defaulters map[*types.Type]*types.Type type defaulterFuncMap map[*types.Type]*types.Type
// Returns all already existing defaulting functions that we are able to find. // Returns all manually-defined defaulting functions that we are able to find.
func existingDefaultingFunctions(context *generator.Context) defaulters { func getManualDefaultingFunctions(context *generator.Context) defaulterFuncMap {
buffer := &bytes.Buffer{} buffer := &bytes.Buffer{}
sw := generator.NewSnippetWriter(buffer, context, "$", "$") sw := generator.NewSnippetWriter(buffer, context, "$", "$")
preexisting := make(defaulters) manualMap := make(defaulterFuncMap)
for _, p := range context.Universe { for _, p := range context.Universe {
for _, f := range p.Functions { for _, f := range p.Functions {
if f.Underlying == nil || f.Underlying.Kind != types.Func { if f.Underlying == nil || f.Underlying.Kind != types.Func {
@ -191,15 +191,15 @@ func existingDefaultingFunctions(context *generator.Context) defaulters {
sw.Do("$.inType|defaultfn$", args) sw.Do("$.inType|defaultfn$", args)
if f.Name.Name == buffer.String() { if f.Name.Name == buffer.String() {
key := inType.Elem key := inType.Elem
if v, ok := preexisting[key]; ok && v != nil { if v, ok := manualMap[key]; ok && v != nil {
panic(fmt.Sprintf("duplicate static defaulter defined: %#v", key)) panic(fmt.Sprintf("duplicate static defaulter defined: %#v", key))
} }
preexisting[key] = f manualMap[key] = f
} }
buffer.Reset() buffer.Reset()
} }
} }
return preexisting return manualMap
} }
func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages {
@ -218,8 +218,8 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
`)...) `)...)
// Compute all pre-existing conversion functions. // Compute all pre-existing conversion functions.
preexisting := existingConversionFunctions(context) manualConversions := getManualConversionFunctions(context)
preexistingDefaults := existingDefaultingFunctions(context) manualDefaulters := getManualDefaultingFunctions(context)
// We are generating conversions only for packages that are explicitly // We are generating conversions only for packages that are explicitly
// passed as InputDir, and only for those that have a corresponding type // passed as InputDir, and only for those that have a corresponding type
@ -254,7 +254,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
} }
// If we can generate conversion in any direction, we should // If we can generate conversion in any direction, we should
// generate this package. // generate this package.
if isConvertible(t, internalType, preexisting) || isConvertible(internalType, t, preexisting) { if isConvertible(t, internalType, manualConversions) || isConvertible(internalType, t, manualConversions) {
convertibleType = true convertibleType = true
} }
} }
@ -268,7 +268,7 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat
GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) { GeneratorFunc: func(c *generator.Context) (generators []generator.Generator) {
generators = []generator.Generator{} generators = []generator.Generator{}
generators = append( generators = append(
generators, NewGenConversion("conversion_generated", path, preexisting, preexistingDefaults)) generators, NewGenConversion("conversion_generated", path, manualConversions, manualDefaulters))
return generators return generators
}, },
FilterFunc: func(c *generator.Context, t *types.Type) bool { FilterFunc: func(c *generator.Context, t *types.Type) bool {
@ -292,21 +292,21 @@ func findMember(t *types.Type, name string) (types.Member, bool) {
return types.Member{}, false return types.Member{}, false
} }
func isConvertible(in, out *types.Type, preexisting conversions) bool { func isConvertible(in, out *types.Type, manualConversions conversionFuncMap) bool {
// If there is pre-existing conversion function, return true immediately. // If there is pre-existing conversion function, return true immediately.
if _, ok := preexisting[conversionType{in, out}]; ok { if _, ok := manualConversions[conversionPair{in, out}]; ok {
return true return true
} }
return isDirectlyConvertible(in, out, preexisting) return isDirectlyConvertible(in, out, manualConversions)
} }
func isDirectlyConvertible(in, out *types.Type, preexisting conversions) bool { func isDirectlyConvertible(in, out *types.Type, manualConversions conversionFuncMap) bool {
// If one of the types is Alias, resolve it. // If one of the types is Alias, resolve it.
if in.Kind == types.Alias { if in.Kind == types.Alias {
return isConvertible(in.Underlying, out, preexisting) return isConvertible(in.Underlying, out, manualConversions)
} }
if out.Kind == types.Alias { if out.Kind == types.Alias {
return isConvertible(in, out.Underlying, preexisting) return isConvertible(in, out.Underlying, manualConversions)
} }
if in.Kind != out.Kind { if in.Kind != out.Kind {
@ -347,15 +347,15 @@ func isDirectlyConvertible(in, out *types.Type, preexisting conversions) bool {
} }
return false return false
} }
convertible = convertible && isConvertible(inMember.Type, outMember.Type, preexisting) convertible = convertible && isConvertible(inMember.Type, outMember.Type, manualConversions)
} }
return convertible return convertible
case types.Map: case types.Map:
return isConvertible(in.Key, out.Key, preexisting) && isConvertible(in.Elem, out.Elem, preexisting) return isConvertible(in.Key, out.Key, manualConversions) && isConvertible(in.Elem, out.Elem, manualConversions)
case types.Slice: case types.Slice:
return isConvertible(in.Elem, out.Elem, preexisting) return isConvertible(in.Elem, out.Elem, manualConversions)
case types.Pointer: case types.Pointer:
return isConvertible(in.Elem, out.Elem, preexisting) return isConvertible(in.Elem, out.Elem, manualConversions)
} }
glog.Fatalf("All other types should be filtered before") glog.Fatalf("All other types should be filtered before")
return false return false
@ -389,25 +389,25 @@ const (
// genConversion produces a file with a autogenerated conversions. // genConversion produces a file with a autogenerated conversions.
type genConversion struct { type genConversion struct {
generator.DefaultGen generator.DefaultGen
targetPackage string targetPackage string
preexisting conversions manualConversions conversionFuncMap
defaulters defaulters manualDefaulters defaulterFuncMap
imports namer.ImportTracker imports namer.ImportTracker
typesForInit []conversionType typesForInit []conversionPair
globalVariables map[string]interface{} globalVariables map[string]interface{}
} }
func NewGenConversion(sanitizedName, targetPackage string, preexisting conversions, defaulters defaulters) generator.Generator { func NewGenConversion(sanitizedName, targetPackage string, manualConversions conversionFuncMap, manualDefaulters defaulterFuncMap) generator.Generator {
return &genConversion{ return &genConversion{
DefaultGen: generator.DefaultGen{ DefaultGen: generator.DefaultGen{
OptionalName: sanitizedName, OptionalName: sanitizedName,
}, },
targetPackage: targetPackage, targetPackage: targetPackage,
preexisting: preexisting, manualConversions: manualConversions,
defaulters: defaulters, manualDefaulters: manualDefaulters,
imports: generator.NewImportTracker(), imports: generator.NewImportTracker(),
typesForInit: make([]conversionType, 0), typesForInit: make([]conversionPair, 0),
} }
} }
@ -453,12 +453,12 @@ func (g *genConversion) Filter(c *generator.Context, t *types.Type) bool {
// We explicitly return true if any conversion is possible - this needs // We explicitly return true if any conversion is possible - this needs
// to be checked again while generating code for that type. // to be checked again while generating code for that type.
convertible := false convertible := false
if isConvertible(t, internalType, g.preexisting) { if isConvertible(t, internalType, g.manualConversions) {
g.typesForInit = append(g.typesForInit, conversionType{t, internalType}) g.typesForInit = append(g.typesForInit, conversionPair{t, internalType})
convertible = true convertible = true
} }
if isConvertible(internalType, t, g.preexisting) { if isConvertible(internalType, t, g.manualConversions) {
g.typesForInit = append(g.typesForInit, conversionType{internalType, t}) g.typesForInit = append(g.typesForInit, conversionPair{internalType, t})
convertible = true convertible = true
} }
return convertible return convertible
@ -513,7 +513,7 @@ func (g *genConversion) funcNameTmpl(inType, outType *types.Type) string {
} }
func (g *genConversion) preexists(inType, outType *types.Type) (*types.Type, bool) { func (g *genConversion) preexists(inType, outType *types.Type) (*types.Type, bool) {
function, ok := g.preexisting[conversionType{inType, outType}] function, ok := g.manualConversions[conversionPair{inType, outType}]
return function, ok return function, ok
} }
@ -547,10 +547,10 @@ func (g *genConversion) Init(c *generator.Context, w io.Writer) error {
func (g *genConversion) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error { func (g *genConversion) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
sw := generator.NewSnippetWriter(w, c, "$", "$") sw := generator.NewSnippetWriter(w, c, "$", "$")
internalType, _ := getInternalTypeFor(c, t) internalType, _ := getInternalTypeFor(c, t)
if isDirectlyConvertible(t, internalType, g.preexisting) { if isDirectlyConvertible(t, internalType, g.manualConversions) {
g.generateConversion(t, internalType, sw) g.generateConversion(t, internalType, sw)
} }
if isDirectlyConvertible(internalType, t, g.preexisting) { if isDirectlyConvertible(internalType, t, g.manualConversions) {
g.generateConversion(internalType, t, sw) g.generateConversion(internalType, t, sw)
} }
return sw.Error() return sw.Error()
@ -561,14 +561,14 @@ func (g *genConversion) generateConversion(inType, outType *types.Type, sw *gene
sw.Do(fmt.Sprintf("func auto%s(in *$.inType|raw$, out *$.outType|raw$, s $.Scope|raw$) error {\n", funcName), g.withGlobals(argsFromType(inType, outType))) sw.Do(fmt.Sprintf("func auto%s(in *$.inType|raw$, out *$.outType|raw$, s $.Scope|raw$) error {\n", funcName), g.withGlobals(argsFromType(inType, outType)))
// if no defaulter of form SetDefaults_XXX is defined, do not inline a check for defaulting. // if no defaulter of form SetDefaults_XXX is defined, do not inline a check for defaulting.
if function, ok := g.defaulters[inType]; ok { if function, ok := g.manualDefaulters[inType]; ok {
sw.Do("$.|raw$(in)\n", function) sw.Do("$.|raw$(in)\n", function)
} }
g.generateFor(inType, outType, sw) g.generateFor(inType, outType, sw)
sw.Do("return nil\n", nil) sw.Do("return nil\n", nil)
sw.Do("}\n\n", nil) sw.Do("}\n\n", nil)
// If there is no public preexisting Convert method, generate it. // If there is no public manual Conversion method, generate it.
if _, ok := g.preexists(inType, outType); !ok { if _, ok := g.preexists(inType, outType); !ok {
sw.Do(fmt.Sprintf("func %s(in *$.inType|raw$, out *$.outType|raw$, s $.Scope|raw$) error {\n", funcName), g.withGlobals(argsFromType(inType, outType))) sw.Do(fmt.Sprintf("func %s(in *$.inType|raw$, out *$.outType|raw$, s $.Scope|raw$) error {\n", funcName), g.withGlobals(argsFromType(inType, outType)))
sw.Do(fmt.Sprintf("return auto%s(in, out, s)\n", funcName), argsFromType(inType, outType)) sw.Do(fmt.Sprintf("return auto%s(in, out, s)\n", funcName), argsFromType(inType, outType))