/
TripleFilter.java
142 lines (123 loc) · 4.17 KB
/
TripleFilter.java
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
142
/*
* Copyright 2013, 2014 Deutsche Nationalbibliothek
*
* Licensed under the Apache License, Version 2.0 the "License";
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.metafacture.triples;
import org.metafacture.framework.FluxCommand;
import org.metafacture.framework.ObjectReceiver;
import org.metafacture.framework.annotations.Description;
import org.metafacture.framework.annotations.In;
import org.metafacture.framework.annotations.Out;
import org.metafacture.framework.helpers.DefaultObjectPipe;
import org.metafacture.framework.objects.Triple;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Filters triples. The patterns for subject, predicate and object are disjunctive.
*
* @author Christoph Böhme
*
*/
@Description("Filters triple. The patterns for subject, predicate and object are disjunctive.")
@In(Triple.class)
@Out(Triple.class)
@FluxCommand("filter-triples")
public final class TripleFilter extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>> {
// A regexp that is guaranteed to never match ( an `a` after the end
// of the string, see http://stackoverflow.com/a/1723225 for details):
private static final Matcher MATCH_NOTHING = Pattern.compile("$a").matcher("");
private Matcher subjectMatcher = MATCH_NOTHING;
private Matcher predicateMatcher = MATCH_NOTHING;
private Matcher objectMatcher = MATCH_NOTHING;
private boolean passMatches = true;
/**
* Creates an instance of {@link TripleFilter}.
*/
public TripleFilter() {
}
/**
* Gets the pattern of the subject filter.
*
* @return the pattern of the subject filter
*/
public String getSubjectPattern() {
return subjectMatcher.pattern().pattern();
}
/**
* Gets the pattern of the subject filter.
*
* @param pattern the pattern of the subject filter
*/
public void setSubjectPattern(final String pattern) {
subjectMatcher = Pattern.compile(pattern).matcher("");
}
/**
* Gets the pattern of the predicate filter.
*
* @return the pattern of the predicate filter
*/
public String getPredicatePattern() {
return predicateMatcher.pattern().pattern();
}
/**
* Gets the pattern of the predicate filter.
*
* @param pattern the pattern of the predicate filter
*/
public void setPredicatePattern(final String pattern) {
predicateMatcher = Pattern.compile(pattern).matcher("");
}
/**
* Gets the pattern of the object filter.
*
* @return the pattern of the object filter
*/
public String getObjectPattern() {
return objectMatcher.pattern().pattern();
}
/**
* Sets a pattern to filter objects.
*
* @param pattern the pattern
*/
public void setObjectPattern(final String pattern) {
objectMatcher = Pattern.compile(pattern).matcher("");
}
/**
* Checks whether matches passes.
*
* @return true if matches should pass
*/
public boolean isPassMatches() {
return passMatches;
}
/**
* Flags whether matches should pass.
*
* @param passMatches true if matches should pass, otherwise matches don't pass
*/
public void setPassMatches(final boolean passMatches) {
this.passMatches = passMatches;
}
@Override
public void process(final Triple obj) {
subjectMatcher.reset(obj.getSubject());
predicateMatcher.reset(obj.getPredicate());
objectMatcher.reset(obj.getObject());
final boolean matches = subjectMatcher.matches() || predicateMatcher.matches() || objectMatcher.matches();
if ((matches && passMatches) || (!matches && !passMatches)) {
getReceiver().process(obj);
}
}
}