-
Notifications
You must be signed in to change notification settings - Fork 0
/
model.go
141 lines (120 loc) · 2.46 KB
/
model.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
package equ
type ItemType int
const (
itemEOF ItemType = iota
itemError
itemPath
itemOr
itemAnd
itemFiltersStart
itemFiltersEnd
itemBundleStart
itemBundleEnd
itemString
itemNumber
itemFilter
)
func (i ItemType) String() string {
switch i {
case itemEOF:
return "eof"
case itemError:
return "error"
case itemPath:
return "path"
case itemOr:
return "or"
case itemAnd:
return "and"
case itemFiltersStart:
return "filtersStart"
case itemFiltersEnd:
return "filtersEnd"
case itemBundleStart:
return "bundleStart"
case itemBundleEnd:
return "bundleEnd"
case itemString:
return "string"
case itemNumber:
return "number"
case itemFilter:
return "filterExpression"
}
return ""
}
type Item struct {
ItemType ItemType
Value string
Pos int
}
type FilterItem interface {
isFilterItem()
}
type FilterOperand struct {
path string
expressionItems []ExpressionItem
}
func (f *FilterOperand) isFilterItem() {}
type filterOperatorType int
const (
FilterOperatorTypeOr filterOperatorType = iota
FilterOperatorTypeAnd
filterOperatorTypeBundleStart
filterOperatorTypeBundleEnd
)
func (f *filterOperatorType) String() string {
switch *f {
case FilterOperatorTypeOr:
return "or"
case FilterOperatorTypeAnd:
return "and"
case filterOperatorTypeBundleStart:
return "bundleStart"
case filterOperatorTypeBundleEnd:
return "bundleEnd"
default:
return "fop"
}
}
type FilterOperator struct {
operatorType filterOperatorType
}
func (f *FilterOperator) isFilterItem() {}
type ExpressionItem interface {
isExpressionItem()
}
type ExpressionValueType int
type ExpressionOperatorType int
const (
ExpressionValueTypeString ExpressionValueType = iota
ExpressionValueTypeNumber
ExpressionOperatorTypeOr ExpressionOperatorType = iota
ExpressionOperatorTypeAnd
ExpressionOperatorTypeBundleStart
ExpressionOperatorTypeBundleEnd
)
func (e *ExpressionOperatorType) String() string {
switch *e {
case ExpressionOperatorTypeOr:
return "or"
case ExpressionOperatorTypeAnd:
return "and"
case ExpressionOperatorTypeBundleStart:
return "bundleStart"
case ExpressionOperatorTypeBundleEnd:
return "bundleEnd"
default:
return "eop"
}
}
type ExpressionOperand struct {
expressionType string
valueType ExpressionValueType
value interface{}
}
type ExpressionOperator struct {
operatorType ExpressionOperatorType
}
func (e *ExpressionOperator) isExpressionItem() {}
func (e *ExpressionOperand) isExpressionItem() {}