public virtual void Annotate <_T0>(MatchedExpression matchedExpression, IList <_T0> nested) where _T0 : ICoreMap { if (resultNestedAnnotationField != null) { matchedExpression.annotation.Set(resultNestedAnnotationField, nested); } // NOTE: for now value must be extracted after nested annotation is in place... Annotate(matchedExpression); }
private Pair <IList <ICoreMap>, IList <T> > ApplyCompositeRule <_T0>(SequenceMatchRules.IExtractRule <IList <ICoreMap>, T> compositeExtractRule, IList <_T0> merged, IList <T> matchedExpressions, int limit) where _T0 : ICoreMap { // Apply higher order rules bool done = false; // Limit of number of times rules are applied just in case int maxIters = limit; int iters = 0; while (!done) { IList <T> newExprs = new List <T>(); bool extracted = compositeExtractRule.Extract(merged, newExprs); if (verbose && extracted) { log.Info("applyCompositeRule() extracting with " + compositeExtractRule + " from " + merged + " gives " + newExprs); } if (extracted) { AnnotateExpressions(merged, newExprs); newExprs = MatchedExpression.RemoveNullValues(newExprs); if (!newExprs.IsEmpty()) { newExprs = MatchedExpression.RemoveNested(newExprs); newExprs = MatchedExpression.RemoveOverlapping(newExprs); merged = MatchedExpression.ReplaceMerged(merged, newExprs); // Favor newly matched expressions over older ones Sharpen.Collections.AddAll(newExprs, matchedExpressions); matchedExpressions = MatchedExpression.RemoveNested(newExprs); matchedExpressions = MatchedExpression.RemoveOverlapping(matchedExpressions); } else { extracted = false; } } done = !extracted; iters++; if (maxIters > 0 && iters >= maxIters) { if (verbose) { log.Warn("Aborting application of composite rules: Maximum iteration " + maxIters + " reached"); } break; } } return(new Pair <IList <ICoreMap>, IList <T> >(merged, matchedExpressions)); }
public MatchedExpression(MatchedExpression me) { // end static class SingleAnnotationExtractor this.annotation = me.annotation; this.extractFunc = me.extractFunc; this.text = me.text; this.value = me.value; //this.attributes = me.attributes; this.priority = me.priority; this.weight = me.weight; this.order = me.order; this.charOffsets = me.charOffsets; this.tokenOffsets = me.tokenOffsets; this.chunkOffsets = me.tokenOffsets; }
public virtual void Annotate(MatchedExpression matchedExpression) { IValue ev = null; if (expressionToValue != null) { ev = expressionToValue.Apply(matchedExpression); } matchedExpression.value = (ev != null) ? ev : valueExtractor.Apply(matchedExpression.annotation); if (resultAnnotationField != null) { if (resultAnnotationExtractor != null) { object result = resultAnnotationExtractor.Apply(matchedExpression); SetAnnotations(matchedExpression.annotation, resultAnnotationField, result); } else { // TODO: Should default result be the matchedExpression, value, object??? //matchedExpression.annotation.set(resultAnnotationField, matchedExpression); IValue v = matchedExpression.GetValue(); SetAnnotations(matchedExpression.annotation, resultAnnotationField, (v != null) ? v.Get() : null); } } if (tokensResultAnnotationField != null) { IList <ICoreMap> tokens = (IList <ICoreMap>)matchedExpression.annotation.Get(tokensAnnotationField); if (resultAnnotationExtractor != null) { object result = resultAnnotationExtractor.Apply(matchedExpression); foreach (ICoreMap cm in tokens) { SetAnnotations(cm, tokensResultAnnotationField, result); } } else { // TODO: Should default result be the matchedExpression, value, object??? //matchedExpression.annotation.set(resultAnnotationField, matchedExpression); IValue v = matchedExpression.GetValue(); foreach (ICoreMap cm in tokens) { SetAnnotations(cm, tokensResultAnnotationField, (v != null) ? v.Get() : null); } } } }
public virtual IList <T> ExtractExpressions(ICoreMap annotation) { // Extract potential expressions IList <T> matchedExpressions = new List <T>(); IList <int> stageIds = new List <int>(stages.Keys); stageIds.Sort(); foreach (int stageId in stageIds) { CoreMapExpressionExtractor.Stage <T> stage = stages[stageId]; SequenceMatchRules.IExtractRule <ICoreMap, T> basicExtractRule = stage.basicExtractRule; if (stage.clearMatched) { matchedExpressions.Clear(); } if (basicExtractRule != null) { basicExtractRule.Extract(annotation, matchedExpressions); if (verbose && matchedExpressions != null) { log.Info("extractExpressions() extracting with " + basicExtractRule + " from " + annotation + " gives " + matchedExpressions); } AnnotateExpressions(annotation, matchedExpressions); matchedExpressions = MatchedExpression.RemoveNullValues(matchedExpressions); matchedExpressions = MatchedExpression.RemoveNested(matchedExpressions); matchedExpressions = MatchedExpression.RemoveOverlapping(matchedExpressions); } IList <ICoreMap> merged = MatchedExpression.ReplaceMergedUsingTokenOffsets(annotation.Get(tokensAnnotationKey), matchedExpressions); SequenceMatchRules.IExtractRule <IList <ICoreMap>, T> compositeExtractRule = stage.compositeExtractRule; if (compositeExtractRule != null) { Pair <IList <ICoreMap>, IList <T> > p = ApplyCompositeRule(compositeExtractRule, merged, matchedExpressions, stage.limitIters); merged = p.First(); matchedExpressions = p.Second(); } matchedExpressions = FilterInvalidExpressions(stage.filterRule, matchedExpressions); } matchedExpressions.Sort(MatchedExpression.ExprTokenOffsetsNestedFirstComparator); if (!keepTags) { CleanupTags(annotation); } return(matchedExpressions); }