-
Notifications
You must be signed in to change notification settings - Fork 0
/
filter.go
140 lines (116 loc) · 3.15 KB
/
filter.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
package resource
import (
"fmt"
preflect "google.golang.org/protobuf/reflect/protoreflect"
"github.com/cloudwan/goten-sdk/runtime/object"
filterParser "github.com/cloudwan/goten-sdk/runtime/resource/filter"
)
// Interface for goten filter
type Filter interface {
fmt.Stringer
preflect.ProtoStringer
EvaluateRaw(Resource) bool
GetRawCondition() FilterCondition
}
type FilterCondition interface {
fmt.Stringer
EvaluateRaw(Resource) bool
SatisfiesRaw(FilterCondition) bool
SpecifiesRawFieldPath(object.FieldPath) bool
}
type ConditionComposite interface {
FilterCondition
GetOperator() filterParser.CompositeOperator
GetSubConditions() []FilterCondition
ConditionComposite()
}
type ConditionNot interface {
FilterCondition
GetSubCondition() FilterCondition
ConditionNot()
}
type FieldPathCondition interface {
FilterCondition
GetRawFieldPath() object.FieldPath
}
type ConditionCompare interface {
FieldPathCondition
GetOperator() filterParser.CompareOperator
GetRawFieldPathValue() object.FieldPathValue
ConditionCompare()
}
type UnknownConditionContainsType struct {
Type ConditionContainsType
}
func NewUnknownConditionContainsType(ct ConditionContainsType) error {
return &UnknownConditionContainsType{ct}
}
func (ucct *UnknownConditionContainsType) Error() string {
return fmt.Sprintf("unknown Condition Contains Type: %s: %d", ucct.Type, ucct.Type)
}
type ConditionContainsType int
const (
ConditionContainsTypeUnspecified = iota
ConditionContainsTypeValue
ConditionContainsTypeAny
ConditionContainsTypeAll
)
func ConditionContainsTypeFromParser(contains *filterParser.Contains) ConditionContainsType {
if contains.Value != nil {
return ConditionContainsTypeValue
} else if contains.Any != nil {
return ConditionContainsTypeAny
} else if contains.All != nil {
return ConditionContainsTypeAll
} else {
panic("empty filter parser contains")
}
}
func (cct ConditionContainsType) IsValue() bool {
return cct == ConditionContainsTypeValue
}
func (cct ConditionContainsType) IsAny() bool {
return cct == ConditionContainsTypeAny
}
func (cct ConditionContainsType) IsAll() bool {
return cct == ConditionContainsTypeAll
}
func (cct ConditionContainsType) String() string {
switch cct {
case ConditionContainsTypeValue:
return "VALUE"
case ConditionContainsTypeAny:
return "ANY"
case ConditionContainsTypeAll:
return "ALL"
default:
panic(fmt.Errorf("unknown condition contains type: %d", cct))
}
}
type ConditionContains interface {
FieldPathCondition
ConditionContainsType() ConditionContainsType
GetRawFieldPathItemValue() object.FieldPathArrayItemValue // Value
GetRawFieldPathItemValues() []object.FieldPathArrayItemValue // Any | All
}
type ConditionIn interface {
FieldPathCondition
GetRawFieldPathArrayOfValues() object.FieldPathArrayOfValues
ConditionIn()
}
type ConditionNotIn interface {
FieldPathCondition
GetRawFieldPathArrayOfValues() object.FieldPathArrayOfValues
ConditionNotIn()
}
type ConditionIsNull interface {
FieldPathCondition
NotNull() bool
GetRawFieldPath() object.FieldPath
ConditionIsNull()
}
type ConditionIsNaN interface {
FieldPathCondition
GetRawFieldPath() object.FieldPath
ConditionIsNaN()
}