public TimeExpression apply(SequenceMatchResult<CoreMap> matched) {
TimeExpression te =
new TimeExpression(
null,
Interval.toInterval(
matched.start(group), matched.end(group), Interval.INTERVAL_OPEN_END),
extractor,
0);
te.setIncludeNested(includeNested);
return te;
}
public SequenceMatchResult<T> apply(SequenceMatchResult<T> matchResult, int... groups) {
for (int group : groups) {
int groupStart = matchResult.start(group);
if (groupStart >= 0) {
int groupEnd = matchResult.end(group);
ChunkAnnotationUtils.annotateChunks(
matchResult.elements(), groupStart, groupEnd, attributes);
}
}
return matchResult;
}
public SUTime.Temporal apply(MatchResult in) {
if (in instanceof SequenceMatchResult) {
SequenceMatchResult<CoreMap> mr = (SequenceMatchResult<CoreMap>) (in);
if (group >= 0) {
List<? extends CoreMap> matched = mr.groupNodes(group);
if (matched != null) {
int i = (nodeIndex >= 0) ? 0 : (matched.size() + nodeIndex);
TimeExpression te = getTimeExpression(matched, i);
if (te != null) {
return te.getTemporal();
}
}
}
}
return null;
}
private void annotateMatched(List<CoreLabel> tokens) {
List<SequenceMatchResult<CoreMap>> matched = multiPatternMatcher.findNonOverlapping(tokens);
for (SequenceMatchResult<CoreMap> m : matched) {
Entry entry = patternToEntry.get(m.pattern());
// Check if we will overwrite the existing annotation with this annotation
int g = entry.annotateGroup;
int start = m.start(g);
int end = m.end(g);
boolean overwriteOriginalNer = checkPosTags(tokens, start, end);
if (overwriteOriginalNer) {
overwriteOriginalNer = checkOrigNerTags(entry, tokens, start, end);
}
if (overwriteOriginalNer) {
for (int i = start; i < end; i++) {
tokens.get(i).set(CoreAnnotations.NamedEntityTagAnnotation.class, entry.type);
}
} else {
if (verbose) {
System.err.println(
"Not annotating '"
+ m.group(g)
+ "': "
+ StringUtils.joinFields(
m.groupNodes(g), CoreAnnotations.NamedEntityTagAnnotation.class)
+ " with "
+ entry.type
+ ", sentence is '"
+ StringUtils.joinWords(tokens, " ")
+ '\'');
}
}
}
}
public SequenceMatchResult<CoreMap> apply(
SequenceMatchResult<CoreMap> matchResult, int... groups) {
BasicSequenceMatchResult<CoreMap> res = matchResult.toBasicSequenceMatchResult();
List<? extends CoreMap> elements = matchResult.elements();
List<CoreMap> mergedElements = new ArrayList<CoreMap>();
res.elements = mergedElements;
int last = 0;
int mergedGroup = 0;
int offset = 0;
List<Integer> orderedGroups = CollectionUtils.asList(groups);
Collections.sort(orderedGroups);
for (int group : orderedGroups) {
int groupStart = matchResult.start(group);
if (groupStart >= last) {
// Add elements from last to start of group to merged elements
mergedElements.addAll(elements.subList(last, groupStart));
// Fiddle with matched group indices
for (; mergedGroup < group; mergedGroup++) {
if (res.matchedGroups[mergedGroup] != null) {
res.matchedGroups[mergedGroup].matchBegin -= offset;
res.matchedGroups[mergedGroup].matchEnd -= offset;
}
}
// Get merged element
int groupEnd = matchResult.end(group);
if (groupEnd - groupStart >= 1) {
CoreMap merged = aggregator.merge(elements, groupStart, groupEnd);
mergedElements.add(merged);
last = groupEnd;
// Fiddle with matched group indices
res.matchedGroups[mergedGroup].matchBegin = mergedElements.size() - 1;
res.matchedGroups[mergedGroup].matchEnd = mergedElements.size();
mergedGroup++;
while (mergedGroup < res.matchedGroups.length) {
if (res.matchedGroups[mergedGroup] != null) {
if (res.matchedGroups[mergedGroup].matchBegin == matchResult.start(group)
&& res.matchedGroups[mergedGroup].matchEnd == matchResult.end(group)) {
res.matchedGroups[mergedGroup].matchBegin = res.matchedGroups[group].matchBegin;
res.matchedGroups[mergedGroup].matchEnd = res.matchedGroups[group].matchEnd;
} else if (res.matchedGroups[mergedGroup].matchEnd <= matchResult.end(group)) {
res.matchedGroups[mergedGroup] = null;
} else {
break;
}
}
mergedGroup++;
}
offset = matchResult.end(group) - res.matchedGroups[group].matchEnd;
}
}
}
// Add rest of elements
mergedElements.addAll(elements.subList(last, elements.size()));
// Fiddle with matched group indices
for (; mergedGroup < res.matchedGroups.length; mergedGroup++) {
if (res.matchedGroups[mergedGroup] != null) {
res.matchedGroups[mergedGroup].matchBegin -= offset;
res.matchedGroups[mergedGroup].matchEnd -= offset;
}
}
return res;
}
