cubefs

1
package ast
2

3
import (
4
	"github.com/graphql-go/graphql/language/kinds"
5
)
6

7
type Value interface {
8
	GetValue() interface{}
9
	GetKind() string
10
	GetLoc() *Location
11
}
12

13
// Ensure that all value types implements Value interface
14
var _ Value = (*Variable)(nil)
15
var _ Value = (*IntValue)(nil)
16
var _ Value = (*FloatValue)(nil)
17
var _ Value = (*StringValue)(nil)
18
var _ Value = (*BooleanValue)(nil)
19
var _ Value = (*EnumValue)(nil)
20
var _ Value = (*ListValue)(nil)
21
var _ Value = (*ObjectValue)(nil)
22

23
// Variable implements Node, Value
24
type Variable struct {
25
	Kind string
26
	Loc  *Location
27
	Name *Name
28
}
29

30
func NewVariable(v *Variable) *Variable {
31
	if v == nil {
32
		v = &Variable{}
33
	}
34
	v.Kind = kinds.Variable
35
	return v
36
}
37

38
func (v *Variable) GetKind() string {
39
	return v.Kind
40
}
41

42
func (v *Variable) GetLoc() *Location {
43
	return v.Loc
44
}
45

46
// GetValue alias to Variable.GetName()
47
func (v *Variable) GetValue() interface{} {
48
	return v.GetName()
49
}
50

51
func (v *Variable) GetName() interface{} {
52
	return v.Name
53
}
54

55
// IntValue implements Node, Value
56
type IntValue struct {
57
	Kind  string
58
	Loc   *Location
59
	Value string
60
}
61

62
func NewIntValue(v *IntValue) *IntValue {
63
	if v == nil {
64
		v = &IntValue{}
65
	}
66
	return &IntValue{
67
		Kind:  kinds.IntValue,
68
		Loc:   v.Loc,
69
		Value: v.Value,
70
	}
71
}
72

73
func (v *IntValue) GetKind() string {
74
	return v.Kind
75
}
76

77
func (v *IntValue) GetLoc() *Location {
78
	return v.Loc
79
}
80

81
func (v *IntValue) GetValue() interface{} {
82
	return v.Value
83
}
84

85
// FloatValue implements Node, Value
86
type FloatValue struct {
87
	Kind  string
88
	Loc   *Location
89
	Value string
90
}
91

92
func NewFloatValue(v *FloatValue) *FloatValue {
93
	if v == nil {
94
		v = &FloatValue{}
95
	}
96
	return &FloatValue{
97
		Kind:  kinds.FloatValue,
98
		Loc:   v.Loc,
99
		Value: v.Value,
100
	}
101
}
102

103
func (v *FloatValue) GetKind() string {
104
	return v.Kind
105
}
106

107
func (v *FloatValue) GetLoc() *Location {
108
	return v.Loc
109
}
110

111
func (v *FloatValue) GetValue() interface{} {
112
	return v.Value
113
}
114

115
// StringValue implements Node, Value
116
type StringValue struct {
117
	Kind  string
118
	Loc   *Location
119
	Value string
120
}
121

122
func NewStringValue(v *StringValue) *StringValue {
123
	if v == nil {
124
		v = &StringValue{}
125
	}
126
	return &StringValue{
127
		Kind:  kinds.StringValue,
128
		Loc:   v.Loc,
129
		Value: v.Value,
130
	}
131
}
132

133
func (v *StringValue) GetKind() string {
134
	return v.Kind
135
}
136

137
func (v *StringValue) GetLoc() *Location {
138
	return v.Loc
139
}
140

141
func (v *StringValue) GetValue() interface{} {
142
	return v.Value
143
}
144

145
// BooleanValue implements Node, Value
146
type BooleanValue struct {
147
	Kind  string
148
	Loc   *Location
149
	Value bool
150
}
151

152
func NewBooleanValue(v *BooleanValue) *BooleanValue {
153
	if v == nil {
154
		v = &BooleanValue{}
155
	}
156
	return &BooleanValue{
157
		Kind:  kinds.BooleanValue,
158
		Loc:   v.Loc,
159
		Value: v.Value,
160
	}
161
}
162

163
func (v *BooleanValue) GetKind() string {
164
	return v.Kind
165
}
166

167
func (v *BooleanValue) GetLoc() *Location {
168
	return v.Loc
169
}
170

171
func (v *BooleanValue) GetValue() interface{} {
172
	return v.Value
173
}
174

175
// EnumValue implements Node, Value
176
type EnumValue struct {
177
	Kind  string
178
	Loc   *Location
179
	Value string
180
}
181

182
func NewEnumValue(v *EnumValue) *EnumValue {
183
	if v == nil {
184
		v = &EnumValue{}
185
	}
186
	return &EnumValue{
187
		Kind:  kinds.EnumValue,
188
		Loc:   v.Loc,
189
		Value: v.Value,
190
	}
191
}
192

193
func (v *EnumValue) GetKind() string {
194
	return v.Kind
195
}
196

197
func (v *EnumValue) GetLoc() *Location {
198
	return v.Loc
199
}
200

201
func (v *EnumValue) GetValue() interface{} {
202
	return v.Value
203
}
204

205
// ListValue implements Node, Value
206
type ListValue struct {
207
	Kind   string
208
	Loc    *Location
209
	Values []Value
210
}
211

212
func NewListValue(v *ListValue) *ListValue {
213
	if v == nil {
214
		v = &ListValue{}
215
	}
216
	return &ListValue{
217
		Kind:   kinds.ListValue,
218
		Loc:    v.Loc,
219
		Values: v.Values,
220
	}
221
}
222

223
func (v *ListValue) GetKind() string {
224
	return v.Kind
225
}
226

227
func (v *ListValue) GetLoc() *Location {
228
	return v.Loc
229
}
230

231
// GetValue alias to ListValue.GetValues()
232
func (v *ListValue) GetValue() interface{} {
233
	return v.GetValues()
234
}
235

236
func (v *ListValue) GetValues() interface{} {
237
	// TODO: verify ObjectValue.GetValue()
238
	return v.Values
239
}
240

241
// ObjectValue implements Node, Value
242
type ObjectValue struct {
243
	Kind   string
244
	Loc    *Location
245
	Fields []*ObjectField
246
}
247

248
func NewObjectValue(v *ObjectValue) *ObjectValue {
249
	if v == nil {
250
		v = &ObjectValue{}
251
	}
252
	return &ObjectValue{
253
		Kind:   kinds.ObjectValue,
254
		Loc:    v.Loc,
255
		Fields: v.Fields,
256
	}
257
}
258

259
func (v *ObjectValue) GetKind() string {
260
	return v.Kind
261
}
262

263
func (v *ObjectValue) GetLoc() *Location {
264
	return v.Loc
265
}
266

267
func (v *ObjectValue) GetValue() interface{} {
268
	// TODO: verify ObjectValue.GetValue()
269
	return v.Fields
270
}
271

272
// ObjectField implements Node, Value
273
type ObjectField struct {
274
	Kind  string
275
	Name  *Name
276
	Loc   *Location
277
	Value Value
278
}
279

280
func NewObjectField(f *ObjectField) *ObjectField {
281
	if f == nil {
282
		f = &ObjectField{}
283
	}
284
	return &ObjectField{
285
		Kind:  kinds.ObjectField,
286
		Loc:   f.Loc,
287
		Name:  f.Name,
288
		Value: f.Value,
289
	}
290
}
291

292
func (f *ObjectField) GetKind() string {
293
	return f.Kind
294
}
295

296
func (f *ObjectField) GetLoc() *Location {
297
	return f.Loc
298
}
299

300
func (f *ObjectField) GetValue() interface{} {
301
	return f.Value
302
}
303