func typeStack(registry rdl.TypeRegistry, typeDef *rdl.Type) []*rdl.Type {
var types []*rdl.Type
types = append(types, typeDef)
tName, tType, _ := rdl.TypeInfo(typeDef)
for tName != rdl.TypeName(tType) {
supertype := registry.FindType(tType)
types = append(types, supertype)
tName, tType, _ = rdl.TypeInfo(supertype)
}
return types
}
func (gen *modelGenerator) emitType(t *rdl.Type) {
if gen.err == nil {
tName, _, _ := rdl.TypeInfo(t)
if strings.HasPrefix(string(tName), "rdl.") {
return
}
tName = rdl.TypeName(goTypeName(tName))
bt := gen.registry.BaseType(t)
switch bt {
case rdl.BaseTypeAny:
gen.emit("\n")
gen.emitTypeComment(t)
gen.emit(fmt.Sprintf("type %s interface{}\n", tName))
case rdl.BaseTypeString, rdl.BaseTypeBool, rdl.BaseTypeInt8, rdl.BaseTypeInt16, rdl.BaseTypeInt32, rdl.BaseTypeInt64, rdl.BaseTypeFloat32, rdl.BaseTypeFloat64, rdl.BaseTypeSymbol:
if gen.precise {
gen.emit("\n")
gen.emitTypeComment(t)
gen.emit(fmt.Sprintf("type %s %s\n", tName, goType(gen.registry, rdl.TypeRef(bt.String()), false, "", "", gen.precise, false)))
}
case rdl.BaseTypeStruct:
gen.emit("\n")
gen.emitStruct(t)
case rdl.BaseTypeUnion:
gen.emit("\n")
gen.emitUnion(t)
case rdl.BaseTypeArray:
gen.emit("\n")
gen.emitArray(t)
case rdl.BaseTypeMap:
gen.emit("\n")
gen.emitMap(t)
case rdl.BaseTypeEnum:
gen.emit("\n")
gen.emitTypeComment(t)
gen.emitEnum(t)
}
}
}
func goTypeName(name rdl.TypeName) rdl.TypeName {
tokens := strings.Split(string(name), ".")
return rdl.TypeName(capitalize(strings.Join(tokens, "_")))
}
func goType(reg rdl.TypeRegistry, rdlType rdl.TypeRef, optional bool, items rdl.TypeRef, keys rdl.TypeRef, precise bool, reference bool) string {
rdlPrefix := "rdl."
if reg.Name() == "rdl" {
rdlPrefix = ""
}
cleanType := string(rdlType)
if !strings.HasPrefix(cleanType, "rdl.") {
cleanType = capitalize(strings.Replace(string(rdlType), ".", "_", -1))
}
prefix := ""
if optional {
prefix = "*"
}
t := reg.FindType(rdlType)
if t.Variant == 0 {
panic("Cannot find type '" + rdlType + "'")
}
lrdlType := strings.ToLower(string(rdlType))
if precise {
switch lrdlType {
case "string":
return "string"
case "symbol":
return rdlPrefix + "Symbol"
case "bool", "int32", "int64", "int16", "int8", "float64", "float32":
return prefix + strings.ToLower(cleanType)
default:
bt := reg.BaseType(t)
switch bt {
case rdl.BaseTypeString, rdl.BaseTypeSymbol:
return cleanType
case rdl.BaseTypeInt8, rdl.BaseTypeInt16, rdl.BaseTypeInt32, rdl.BaseTypeInt64, rdl.BaseTypeFloat32, rdl.BaseTypeFloat64, rdl.BaseTypeBool:
return prefix + cleanType
case rdl.BaseTypeTimestamp, rdl.BaseTypeUUID:
fullTypeName := rdlPrefix + cleanType
return prefix + fullTypeName
default:
if lrdlType == "struct" {
fullTypeName := rdlPrefix + cleanType
return prefix + fullTypeName
}
}
}
} else {
switch lrdlType {
case "timestamp":
return prefix + rdlPrefix + "Timestamp"
case "uuid":
return prefix + rdlPrefix + "UUID"
case "struct":
return prefix + rdlPrefix + "Struct"
}
}
bt := reg.BaseType(t)
switch bt {
case rdl.BaseTypeAny:
return "interface{}"
case rdl.BaseTypeString:
return "string"
case rdl.BaseTypeSymbol:
return rdlPrefix + "Symbol"
case rdl.BaseTypeBool:
return prefix + "bool"
case rdl.BaseTypeInt8, rdl.BaseTypeInt16, rdl.BaseTypeInt32, rdl.BaseTypeInt64, rdl.BaseTypeFloat32, rdl.BaseTypeFloat64:
return prefix + strings.ToLower(bt.String())
case rdl.BaseTypeArray:
if reference {
name := "Array"
if t.ArrayTypeDef != nil {
name = string(t.ArrayTypeDef.Name)
}
if name != "Array" {
return name
}
}
i := rdl.TypeRef("Any")
switch t.Variant {
case rdl.TypeVariantArrayTypeDef:
i = t.ArrayTypeDef.Items
default:
if items != "" {
i = items
}
}
gitems := goType(reg, i, false, "", "", precise, reference)
return "[]" + gitems
case rdl.BaseTypeMap:
if reference {
//we check if we have defined a type, i.e. the type name is not "Map"
name := rdl.TypeName("Map")
if t.MapTypeDef != nil {
name = t.MapTypeDef.Name
} else if t.AliasTypeDef != nil {
name = t.AliasTypeDef.Name
}
if name != "Map" {
return string(name)
}
}
k := rdl.TypeRef("Any")
i := rdl.TypeRef("Any")
switch t.Variant {
case rdl.TypeVariantMapTypeDef:
k = t.MapTypeDef.Keys
i = t.MapTypeDef.Items
default:
if keys != "" {
k = keys
}
if items != "" {
i = items
}
}
gkeys := goType(reg, k, false, "", "", precise, reference)
gitems := goType(reg, i, false, "", "", precise, reference)
return "map[" + gkeys + "]" + gitems
case rdl.BaseTypeStruct:
switch t.Variant {
case rdl.TypeVariantAliasTypeDef:
if t.AliasTypeDef.Name == "Struct" {
return prefix + "map[string]interface{}"
}
}
return "*" + cleanType
case rdl.BaseTypeUnion:
return "*" + cleanType
case rdl.BaseTypeEnum:
return prefix + cleanType
default:
return prefix + cleanType
}
}
