func toType(val []string, midl *idl.Idl, typ *idl.Type, fmt rest.ListFmt) (interface{}, error) {
if typ.IsBool() {
return strconv.ParseBool(one(val))
} else if typ.IsInt() {
if typ.Name == "int64" {
// int64 is quoted
return one(val), nil
} else {
return strconv.ParseInt(one(val), 10, 32)
}
} else if typ.IsString() || typ.IsChar() || typ.IsDatetime() || typ.IsBinary() || typ.IsDecimal() {
// treat as string - these are all quoted
return one(val), nil
} else if typ.IsFloat() {
return strconv.ParseFloat(one(val), 64)
} else if typ.IsList() && typ.ValueType.IsPrimitive() {
var sep string
switch fmt {
case rest.CSV:
sep = ","
case rest.SSV:
sep = " "
case rest.TSV:
sep = "\t"
case rest.PIPES:
sep = "|"
case rest.MULTI:
default:
return nil, errors.New("Format must be specified when lists are encoded.")
}
vals := make([]interface{}, 0)
var arr []string
if sep != "" {
arr = strings.Split(one(val), sep)
} else {
if val == nil {
arr = []string{}
} else {
arr = val
}
}
for _, s := range arr {
v, err := toType([]string{s}, midl, typ.ValueType, rest.NONE)
if err != nil {
return nil, err
}
vals = append(vals, v)
}
return vals, nil
} else if typ.IsEnum(midl) {
// treat as string - quoted
return one(val), nil
}
// all other types are custom
// in theory maybe maps could be handled?
return nil, errors.New("Unexpected type: " + typ.String())
}
// formatType returns the Type as a string in format suitable for C#.
func (gen *goGenerator) formatType(t *idl.Type) string {
var s string
ms, ok := goTypes[t.Name]
if !ok {
ms = t.Name
}
if t.IsList() {
s = fmt.Sprintf(ms, gen.formatType(t.ValueType))
} else if t.IsMap() {
s = fmt.Sprintf(ms, goTypes[t.KeyType.Name], gen.formatType(t.ValueType))
} else if t.IsBinary() {
s = ms
} else if t.IsPrimitive() {
s = "*" + ms
} else if t.IsEnum(gen.tplRootIdl) {
s = "*" + ms
} else if t.IsVoid() {
s = ""
} else {
s = "*" + ms
}
return s
}
func typeToItems(pidl *idl.Idl, t *idl.Type) *swagger2.ItemsDef {
it := new(swagger2.ItemsDef)
it.Ref = ""
if t.IsPrimitive() {
it.Format = t.String()
if t.IsInt() || t.IsByte() {
it.Type = "integer"
it.Format = "int32"
if t.Name == "int64" {
if swagInt && restful {
// Swagger style int64
it.Format = "int64"
} else {
// Babel style int64
it.Type = "string" // ??? Babel quotes large integers to avoid precision loss in JavaScript
it.Format = "int64" // SWAGGER-CLARIFICATION: is format int64 legal with type string?
}
}
} else if t.IsFloat() {
it.Type = "number"
it.Format = "float"
if t.Name == "float64" {
it.Format = "double"
}
} else if t.IsBool() {
it.Type = "boolean"
it.Format = ""
} else if t.IsDatetime() {
it.Type = "string"
it.Format = "date-time"
} else if t.IsDecimal() {
it.Type = "string"
it.Format = ""
} else if t.IsString() || t.IsChar() {
it.Type = "string"
it.Format = ""
}
} else if t.IsBinary() {
it.Type = "string"
it.Format = "byte"
} else if t.IsMap() {
it.Type = "object"
// hmmm....what to do if keytype is not string?
// SWAGGER-CLARIFICATION: Does swagger require all key types to be strings?
it.AdditionalProperties = typeToItems(pidl, t.ValueType)
} else if t.IsList() {
it.Type = "array"
it.Format = ""
it.Items = typeToItems(pidl, t.ValueType)
} else if t.IsEnum(pidl) {
// SWAGGER-BUG: Enums cannot be delared in a schema
it.Type = "string"
it.Format = ""
it.Enum = make([]interface{}, 0)
e := pidl.FindEnum(t.Name)
if e != nil {
for _, x := range e.Values {
it.Enum = append(it.Enum, x.Name)
}
}
} else {
// user-defined, struct or enum
it.Ref = "#/definitions/" + t.Name
}
return it
}