go-rule/composite_rule.go at master · Salpadding/go-rule · GitHub

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
package rule

// Rule and 方式组合
type AndRuler []Ruler

// Rule 与组合
func (r AndRuler) Rule(c Context) (bool, error) {
	result := true
	for _, ruler := range []Ruler(r) {
		res, err := ruler.Rule(c)
		if err != nil {
			return false, err
		}
		result = result && res
		if !result {
			return result, nil
		}
	}
	return result, nil
}

func NewAndRuler(rules []Ruler) AndRuler {
	return AndRuler(rules)
}

// Rule or 方式组合
type OrRuler []Ruler

// Rule 或组合
func (r OrRuler) Rule(c Context) (bool, error) {
	result := false
	for _, ruler := range []Ruler(r) {
		res, err := ruler.Rule(c)
		if err != nil {
			return false, err
		}
		result = result || res
		if result {
			return result, nil
		}
	}
	return result, nil
}

func NewOrRuler(rules []Ruler) OrRuler {
	return OrRuler(rules)
}

type AtLeastNRuler struct {
	rulers []Ruler
	N      int
}

func (r *AtLeastNRuler) Rule(c Context) (bool, error) {
	n := 0
	for _, rule := range r.rulers {
		res, err := rule.Rule(c)
		if err != nil {
			return false, err
		}
		if res {
			n++
		}
	}
	return n >= r.N, nil
}

func NewAtLeastNRuler(rules []Ruler, n int) *AtLeastNRuler {
	return &AtLeastNRuler{
		rulers: rules,
		N:      n,
	}
}

type AtMostNRuler struct {
	rulers []Ruler
	N      int
}

func (r *AtMostNRuler) Rule(c Context) (bool, error) {
	n := 0
	for _, rule := range r.rulers {
		res, err := rule.Rule(c)
		if err != nil {
			return false, err
		}
		if res {
			n++
		}
	}
	return n <= r.N, nil
}

func NewAtMostNRuler(rules []Ruler, n int) *AtMostNRuler {
	return &AtMostNRuler{
		rulers: rules,
		N:      n,
	}
}