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
|
package bexpr
import (
"fmt"
"reflect"
)
type Filter struct {
// The underlying boolean expression evaluator
evaluator *Evaluator
}
func getElementType(dataType interface{}) reflect.Type {
rtype := reflect.TypeOf(dataType)
if rtype == nil {
return nil
}
switch rtype.Kind() {
case reflect.Map, reflect.Slice, reflect.Array:
return rtype.Elem()
default:
return rtype
}
}
// Creates a filter to operate on the given data type.
// The data type passed can be either be a container type (map, slice or array) or the element type.
// For example, if you want to filter a []Foo then the data type to pass here is either []Foo or just Foo.
// If no expression is provided the nil filter will be returned but is not an error. This is done
// to allow for executing the nil filter which is just a no-op
func CreateFilter(expression string, config *EvaluatorConfig, dataType interface{}) (*Filter, error) {
if expression == "" {
// nil filter
return nil, nil
}
exp, err := CreateEvaluatorForType(expression, config, getElementType(dataType))
if err != nil {
return nil, fmt.Errorf("Failed to create boolean expression evaluator: %v", err)
}
return &Filter{
evaluator: exp,
}, nil
}
// Execute the filter. If called on a nil filter this is a no-op and
// will return the original data
func (f *Filter) Execute(data interface{}) (interface{}, error) {
if f == nil {
return data, nil
}
rvalue := reflect.ValueOf(data)
rtype := rvalue.Type()
switch rvalue.Kind() {
case reflect.Array:
// For arrays we return slices instead of fixed sized arrays
rtype = reflect.SliceOf(rtype.Elem())
fallthrough
case reflect.Slice:
newSlice := reflect.MakeSlice(rtype, 0, rvalue.Len())
for i := 0; i < rvalue.Len(); i++ {
item := rvalue.Index(i)
if !item.CanInterface() {
return nil, fmt.Errorf("Slice/Array value can not be used")
}
result, err := f.evaluator.Evaluate(item.Interface())
if err != nil {
return nil, err
}
if result {
newSlice = reflect.Append(newSlice, item)
}
}
return newSlice.Interface(), nil
case reflect.Map:
newMap := reflect.MakeMap(rtype)
// TODO (mkeeler) - Update to use a MapRange iterator once Go 1.12 is usable
// for all of our products
for _, mapKey := range rvalue.MapKeys() {
item := rvalue.MapIndex(mapKey)
if !item.CanInterface() {
return nil, fmt.Errorf("Map value cannot be used")
}
result, err := f.evaluator.Evaluate(item.Interface())
if err != nil {
return nil, err
}
if result {
newMap.SetMapIndex(mapKey, item)
}
}
return newMap.Interface(), nil
default:
return nil, fmt.Errorf("Only slices, arrays and maps are filterable")
}
}
|
