private IList <SequenceMatchRules.IRule> Collapse(IList <SequenceMatchRules.IRule> rules)
        {
            IList <SequenceMatchRules.IRule> collapsed = new List <SequenceMatchRules.IRule>();
            IList <TokenSequencePattern>     patterns  = null;

            SequenceMatchRules.AnnotationExtractRule aerTemplate = null;
            foreach (SequenceMatchRules.IRule rule in rules)
            {
                bool ruleHandled = false;
                if (rule is SequenceMatchRules.AnnotationExtractRule)
                {
                    SequenceMatchRules.AnnotationExtractRule aer = (SequenceMatchRules.AnnotationExtractRule)rule;
                    if (aer.HasTokensRegexPattern())
                    {
                        if (aerTemplate == null || aerTemplate.IsMostlyCompatible(aer))
                        {
                            if (aerTemplate == null)
                            {
                                aerTemplate = aer;
                            }
                            if (patterns == null)
                            {
                                patterns = new List <TokenSequencePattern>();
                            }
                            patterns.Add((TokenSequencePattern)aer.pattern);
                            ruleHandled = true;
                        }
                    }
                }
                // Did we handle this rule?
                if (!ruleHandled)
                {
                    if (aerTemplate != null)
                    {
                        SequenceMatchRules.AnnotationExtractRule merged = CreateMergedRule(aerTemplate, patterns);
                        collapsed.Add(merged);
                        aerTemplate = null;
                        patterns    = null;
                    }
                    collapsed.Add(rule);
                }
            }
            if (aerTemplate != null)
            {
                SequenceMatchRules.AnnotationExtractRule merged = CreateMergedRule(aerTemplate, patterns);
                collapsed.Add(merged);
            }
            return(collapsed);
        }
 // used to be INFO but annoyed Chris/users
 private SequenceMatchRules.AnnotationExtractRule CreateMergedRule(SequenceMatchRules.AnnotationExtractRule aerTemplate, IList <TokenSequencePattern> patterns)
 {
     return(SequenceMatchRules.CreateMultiTokenPatternRule(env, aerTemplate, patterns));
 }
 /// <summary>Add specified rules to this extractor.</summary>
 /// <param name="rules"/>
 public virtual void AppendRules(IList <SequenceMatchRules.IRule> rules)
 {
     if (verbose)
     {
         log.Info("Read " + rules.Count + " rules");
     }
     // Put rules into stages
     if (collapseExtractionRules)
     {
         rules = Collapse(rules);
         if (verbose)
         {
             log.Info("Collapsing into " + rules.Count + " rules");
         }
     }
     foreach (SequenceMatchRules.IRule r in rules)
     {
         if (r is SequenceMatchRules.AssignmentRule)
         {
             // Nothing to do
             // Assignments are added to environment as they are parsed
             ((SequenceMatchRules.AssignmentRule)r).Evaluate(env);
         }
         else
         {
             if (r is SequenceMatchRules.AnnotationExtractRule)
             {
                 SequenceMatchRules.AnnotationExtractRule aer   = (SequenceMatchRules.AnnotationExtractRule)r;
                 CoreMapExpressionExtractor.Stage <T>     stage = stages[aer.stage];
                 if (stage == null)
                 {
                     stages[aer.stage] = stage = new CoreMapExpressionExtractor.Stage <T>();
                     stage.stageId     = aer.stage;
                     bool clearMatched = (bool)env.GetDefaults()["stage.clearMatched"];
                     if (clearMatched != null)
                     {
                         stage.clearMatched = clearMatched;
                     }
                     int limitIters = (int)env.GetDefaults()["stage.limitIters"];
                     if (limitIters != null)
                     {
                         stage.limitIters = limitIters;
                     }
                 }
                 if (aer.active)
                 {
                     if (SequenceMatchRules.FilterRuleType.Equals(aer.ruleType))
                     {
                         stage.AddFilterRule(aer);
                     }
                     else
                     {
                         if (aer.isComposite)
                         {
                             //            if (SequenceMatchRules.COMPOSITE_RULE_TYPE.equals(aer.ruleType)) {
                             stage.AddCompositeRule(aer);
                         }
                         else
                         {
                             stage.AddBasicRule(aer);
                         }
                     }
                 }
                 else
                 {
                     log.Debug("Ignoring inactive rule: " + aer.name);
                 }
             }
         }
     }
 }