Separate out the finding of the matches in a Semgrex from the printing of the matches. Will make it easier to do further operations such as sorting or uniqing the matches

Author: AngledLuffa

src/edu/stanford/nlp/semgraph/semgrex/Alignment.java

@@ -28,6 +28,13 @@ public Alignment(Map<IndexedWord, IndexedWord> map,
     this.justification = justification;
   }
 
+  public Alignment(Alignment other) {
+    // note that we aren't copying the words
+    map = new HashMap<>(other.map);
+    score = other.score;
+    justification = other.justification;
+  }
+
   /*
    * Returns the score for this <code>Alignment</code>.
    */

src/edu/stanford/nlp/semgraph/semgrex/SemgrexMatch.java

@@ -0,0 +1,67 @@
+package edu.stanford.nlp.semgraph.semgrex;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import edu.stanford.nlp.ling.IndexedWord;
+import edu.stanford.nlp.semgraph.SemanticGraph;
+import edu.stanford.nlp.semgraph.SemanticGraphEdge;
+import edu.stanford.nlp.util.VariableStrings;
+
+/**
+ * Stores the results of a single match.
+ *<br>
+ * This is useful for keeping track of a SemgrexMatcher after already processing its result.
+ * In particular, it will be possible to post-process results after coordinating all of the results.
+ * For example, results can be sorted or uniqed by the matching nodes, as long as all of the results
+ * are already compiled
+ */
+
+public class SemgrexMatch implements Serializable  {
+  private static final long serialVersionUID = 978254376856L;
+
+  final SemgrexPattern matchedPattern;
+
+  final SemanticGraph sg;
+  final Map<String, IndexedWord> namesToNodes;
+  final Map<String, String> namesToRelations;
+  final Map<String, SemanticGraphEdge> namesToEdges;
+  final VariableStrings variableStrings;
+
+  final Alignment alignment;
+  final SemanticGraph sg_aligned;
+  final boolean hyp;
+
+  final IndexedWord match;
+
+  public SemgrexMatch(SemgrexPattern pattern, SemgrexMatcher matcher) {
+    matchedPattern = pattern;
+    sg = matcher.sg;
+    namesToNodes = new HashMap<>(matcher.namesToNodes);
+    namesToRelations = new HashMap<>(matcher.namesToRelations);
+    namesToEdges = new HashMap<>(matcher.namesToEdges);
+    variableStrings = new VariableStrings(matcher.variableStrings);
+    if (matcher.alignment != null) {
+      alignment = new Alignment(matcher.alignment);
+    } else {
+      alignment = null;
+    }
+    sg_aligned = matcher.sg_aligned;
+    hyp = matcher.hyp;
+    match = matcher.getMatch();
+  }
+
+  public IndexedWord getMatch() {
+    return match;
+  }
+
+  public IndexedWord getNode(String name) {
+    return namesToNodes.get(name);
+  }
+
+  public Set<String> getNodeNames() {
+    return namesToNodes.keySet();
+  }
+}

src/edu/stanford/nlp/semgraph/semgrex/SemgrexPattern.java

@@ -549,27 +549,38 @@ public static void main(String[] args) throws IOException {
       }
     }
 
+    List<Pair<CoreMap, List<SemgrexMatch>>> matches = new ArrayList<>();
     for (CoreMap sentence : sentences) {
       SemanticGraph graph = sentence.get(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class);
       SemanticGraph enhanced = sentence.get(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation.class);
       SemgrexMatcher matcher = semgrex.matcher(graph);
       if ( ! matcher.find()) {
         continue;
       }
+      matches.add(new Pair<>(sentence, new ArrayList<>()));
+      boolean found = true;
+      while (found) {
+        matches.get(matches.size() - 1).second().add(new SemgrexMatch(semgrex, matcher));
+        found = matcher.find();
+      }
+    }
 
+    for (Pair<CoreMap, List<SemgrexMatch>> sentenceMatches : matches) {
+      CoreMap sentence = sentenceMatches.first();
+      SemanticGraph graph = sentence.get(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation.class);
+      SemanticGraph enhanced = sentence.get(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation.class);
       if (outputFormat == OutputFormat.LIST) {
         log.info("Matched graph:" + System.lineSeparator() + graph.toString(SemanticGraph.OutputFormat.LIST));
-        int i = 1;
-        boolean found = true;
-        while (found) {
+        int i = 0;
+        for (SemgrexMatch matcher : sentenceMatches.second()) {
+          i++;
           log.info("Match " + i + " at: " + matcher.getMatch().toString(CoreLabel.OutputFormat.VALUE_INDEX));
           List<String> nodeNames = Generics.newArrayList();
           nodeNames.addAll(matcher.getNodeNames());
           Collections.sort(nodeNames);
           for (String name : nodeNames) {
             log.info("  " + name + ": " + matcher.getNode(name).toString(CoreLabel.OutputFormat.VALUE_INDEX));
           }
-          found = matcher.find();
         }
       } else if (outputFormat == OutputFormat.OFFSET) {
         if (graph.vertexListSorted().isEmpty()) {
@@ -585,8 +596,7 @@ public static void main(String[] args) throws IOException {
         if (comments.size() == 0) {
           comments.addAll(graph.getComments());
         }
-        boolean found = true;
-        while (found) {
+        for (SemgrexMatch matcher : sentenceMatches.second()) {
           StringBuilder comment = new StringBuilder();
           comment.append("# semgrex pattern |" + semgrexName + "| matched at " + matcher.getMatch().toString(CoreLabel.OutputFormat.VALUE_INDEX));
 
@@ -600,7 +610,6 @@ public static void main(String[] args) throws IOException {
             comment.append(matcher.getNode(name).toString(CoreLabel.OutputFormat.VALUE_INDEX));
           }
           comments.add(comment.toString());
-          found = matcher.find();
         }
         String output = writer.printSemanticGraph(graph, enhanced, false, comments);
         System.out.print(output);