/
types.go
144 lines (125 loc) · 2.62 KB
/
types.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package java
import (
"path"
"strings"
"github.com/EverythingMe/vertex/swagger"
"github.com/alecthomas/jsonschema"
)
// Class represents a local class definition from a swagger return type schema
type Class struct {
Name string
Members []Member
// Optionally, a class can just extend an external class, as defined in the generator.
Extends string
Implements string
}
// Member is a member in a class
type Member struct {
Name string
Type TypeRef
}
// TypeRef represents the type of a member or a parameter, either to a java type or to a class defined in the API
type TypeRef struct {
Namespace string
Type string
Contained []TypeRef
}
const (
String = "String"
Boolean = "boolean"
Integer = "int"
Object = "Object"
List = "List"
Float = "float"
)
const typesNamespace = "Types"
func newTypeRef(t *jsonschema.Type) TypeRef {
ret := TypeRef{}
switch swagger.Type(t.Type) {
case swagger.String:
ret.Type = String
case swagger.Number:
ret.Type = Float
case swagger.Boolean:
ret.Type = Boolean
case swagger.Integer:
ret.Type = Integer
case swagger.Array:
ret.Type = List
ret.Contained = []TypeRef{newTypeRef(t.Items)}
case swagger.Object:
ret.Type = Object
default:
ret.Namespace = typesNamespace
if t.Ref != "" {
ret.Type = path.Base(t.Ref)
} else {
ret.Type = t.Type
}
}
return ret
}
func newTypeRefSwagger(t swagger.Type, items swagger.Type) TypeRef {
ret := TypeRef{}
switch t {
case swagger.Number:
ret.Type = Float
case swagger.Boolean:
ret.Type = Boolean
case swagger.Integer:
ret.Type = Integer
case swagger.Array:
ret.Type = List
ret.Contained = []TypeRef{newTypeRefSwagger(items, "")}
case swagger.Object:
ret.Type = Object
case swagger.String:
fallthrough
default:
ret.Type = String
}
return ret
}
func (t TypeRef) String() string {
ret := ""
if t.Namespace != "" {
ret = t.Namespace + "."
}
ret += t.Type
if t.Contained != nil && len(t.Contained) > 0 {
ret += "<"
for _, sub := range t.Contained {
ret += sub.String() + ","
}
ret = strings.TrimRight(ret, ",") + ">"
}
return ret
}
// Method hodls the mapping of a route to a java method and its parameters
type Method struct {
Name string
Returns TypeRef
Params []Param
HttpVerb string
Doc string
Path string
}
// Param is a method parameter
type Param struct {
Name string
Doc string
Type TypeRef
In string
Required bool
Global bool
}
// API holds the java-ready structure of an API definition
type API struct {
Name string
Package string
Doc string
Root string
Types []Class
Methods []Method
Globals []Param
}