update

Hunter0x7c7

2022-08-11 b8230139fb40edea387617b6accd8371e37eda58

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
package strmatcher 
 
// A MphIndexMatcher is divided into three parts: 
// 1. `full` and `domain` patterns are matched by Rabin-Karp algorithm and minimal perfect hash table; 
// 2. `substr` patterns are matched by ac automaton; 
// 3. `regex` patterns are matched with the regex library. 
type MphIndexMatcher struct { 
    count uint32 
    mph   *MphMatcherGroup 
    ac    *ACAutomatonMatcherGroup 
    regex SimpleMatcherGroup 
} 
 
func NewMphIndexMatcher() *MphIndexMatcher { 
    return &MphIndexMatcher{ 
        mph:   nil, 
        ac:    nil, 
        regex: SimpleMatcherGroup{}, 
    } 
} 
 
// Add implements IndexMatcher.Add. 
func (g *MphIndexMatcher) Add(matcher Matcher) uint32 { 
    g.count++ 
    index := g.count 
 
    switch matcher := matcher.(type) { 
    case FullMatcher: 
        if g.mph == nil { 
            g.mph = NewMphMatcherGroup() 
        } 
        g.mph.AddFullMatcher(matcher, index) 
    case DomainMatcher: 
        if g.mph == nil { 
            g.mph = NewMphMatcherGroup() 
        } 
        g.mph.AddDomainMatcher(matcher, index) 
    case SubstrMatcher: 
        if g.ac == nil { 
            g.ac = NewACAutomatonMatcherGroup() 
        } 
        g.ac.AddSubstrMatcher(matcher, index) 
    case *RegexMatcher: 
        g.regex.AddMatcher(matcher, index) 
    } 
 
    return index 
} 
 
// Build implements IndexMatcher.Build. 
func (g *MphIndexMatcher) Build() error { 
    if g.mph != nil { 
        g.mph.Build() 
    } 
    if g.ac != nil { 
        g.ac.Build() 
    } 
    return nil 
} 
 
// Match implements IndexMatcher.Match. 
func (*MphIndexMatcher) Match(string) []uint32 { 
    return nil 
} 
 
// MatchAny implements IndexMatcher.MatchAny. 
func (g *MphIndexMatcher) MatchAny(input string) bool { 
    if g.mph != nil && g.mph.MatchAny(input) { 
        return true 
    } 
    if g.ac != nil && g.ac.MatchAny(input) { 
        return true 
    } 
    return g.regex.MatchAny(input) 
} 
 
// Size implements IndexMatcher.Size. 
func (g *MphIndexMatcher) Size() uint32 { 
    return g.count 
}