Save the edge being matched in the GraphRelation.

- Pass around a map for matching edges
- Setting ~name on a relation in the SemgrexPattern keeps the matched edge in the map
- this only applies to relations which are immediate parent or child relations:
  > >-- >++ < <-- <++
  if set on any other relation, an exception is thrown (test included)
- includes a test of the edge naming and backreferences for the various relations
- document the feature in the SemgrexPattern javadoc

Author: AngledLuffa

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

@@ -5,6 +5,7 @@
 
 import edu.stanford.nlp.ling.IndexedWord;
 import edu.stanford.nlp.semgraph.SemanticGraph;
+import edu.stanford.nlp.semgraph.SemanticGraphEdge;
 
 /** @author Chloe Kiddon */
 public class CoordinationPattern extends SemgrexPattern  {
@@ -102,10 +103,11 @@ public String toString(boolean hasPrecedence) {
   public SemgrexMatcher matcher(SemanticGraph sg, IndexedWord node,
                                 Map<String, IndexedWord> namesToNodes, 
                                 Map<String, String> namesToRelations,
+                                Map<String, SemanticGraphEdge> namesToEdges,
                                 VariableStrings variableStrings, 
                                 boolean ignoreCase) {
     return new CoordinationMatcher(this, sg, null, null, true, node, 
-                                   namesToNodes, namesToRelations,
+                                   namesToNodes, namesToRelations, namesToEdges,
                                    variableStrings, ignoreCase);
   }
 
@@ -115,11 +117,12 @@ public SemgrexMatcher matcher(SemanticGraph sg,
                                 boolean hypToText, IndexedWord node, 
                                 Map<String, IndexedWord> namesToNodes,
                                 Map<String, String> namesToRelations, 
+                                Map<String, SemanticGraphEdge> namesToEdges,
                                 VariableStrings variableStrings, 
                                 boolean ignoreCase) {
     return new CoordinationMatcher(this, sg, alignment, sg_align, 
                                    hypToText, node,
-                                   namesToNodes, namesToRelations, 
+                                   namesToNodes, namesToRelations, namesToEdges,
                                    variableStrings, ignoreCase);
   }
 
@@ -136,16 +139,18 @@ private static class CoordinationMatcher extends SemgrexMatcher {
     public CoordinationMatcher(CoordinationPattern c, SemanticGraph sg, Alignment alignment,
                                SemanticGraph sg_align, boolean hypToText, IndexedWord n,
                                Map<String, IndexedWord> namesToNodes,
-                               Map<String, String> namesToRelations, VariableStrings variableStrings,
+                               Map<String, String> namesToRelations,
+                               Map<String, SemanticGraphEdge> namesToEdges,
+                               VariableStrings variableStrings,
                                boolean ignoreCase) {
-      super(sg, alignment, sg_align, hypToText, n, namesToNodes, namesToRelations, variableStrings);
+      super(sg, alignment, sg_align, hypToText, n, namesToNodes, namesToRelations, namesToEdges, variableStrings);
       myNode = c;
       children = new SemgrexMatcher[myNode.children.size()];
       for (int i = 0; i < children.length; i++) {
         SemgrexPattern node = myNode.children.get(i);
         children[i] = node.matcher(sg, alignment, sg_align, hypToText,
                                    n, namesToNodes,
-                                   namesToRelations, variableStrings, ignoreCase);
+                                   namesToRelations, namesToEdges, variableStrings, ignoreCase);
       }
       currChild = 0;
       considerAll = myNode.isConj ^ myNode.isNegated();

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

@@ -37,6 +37,7 @@ abstract class GraphRelation implements Serializable {
   final String rawType;
 
   final String name;
+  final String edgeName;
 
   //"<" | ">" | ">>" | "<<" | "<#" | ">#" | ":" | "@">
 
@@ -53,11 +54,16 @@ abstract class GraphRelation implements Serializable {
    */
   abstract Iterator<IndexedWord> searchNodeIterator(IndexedWord node, SemanticGraph sg);
 
-  private GraphRelation(String symbol, String type, String name) {
+  private GraphRelation(String symbol, String type, String name, String edgeName) {
     this.symbol = symbol;
     this.type   = getPattern(type);
     this.rawType = type;
     this.name = name;
+    this.edgeName = edgeName;
+  }
+
+  private GraphRelation(String symbol, String type, String name) {
+    this(symbol, type, name, null);
   }
 
   private GraphRelation(String symbol, String type) {
@@ -70,7 +76,7 @@ private GraphRelation(String symbol) {
 
   @Override
   public String toString() {
-    return symbol + ((rawType != null) ? rawType : "") + ((name != null) ? "=" + name : "");
+    return symbol + ((rawType != null) ? rawType : "") + ((name != null) ? "=" + name : "") + ((edgeName != null) ? "~" + edgeName : "");
   }
 
   public Predicate<String> getPattern(String relnType)
@@ -89,6 +95,11 @@ public String getName() {
     return name;
   }
 
+  public String getEdgeName() {
+    if (edgeName == null || edgeName == "") return null;
+    return edgeName;
+  }
+
 
   // ALIGNMENT graph relation: "@" ==============================================
 
@@ -237,8 +248,8 @@ void initialize() {
   // GOVERNOR graph relation: ">" ===============================================
 
   static private class GOVERNOR extends GraphRelation {
-    GOVERNOR(String reln, String name) {
-      super(">", reln, name);
+    GOVERNOR(String reln, String name, String edgeName) {
+      super(">", reln, name, edgeName);
     }
 
     @Override
@@ -274,9 +285,11 @@ public void advance() {
                 continue;
               }
               this.next = edge.getTarget();
+              this.edge = edge;
               return;
             }
             this.next = null;
+            this.edge = null;
           }
       };
     }
@@ -286,8 +299,8 @@ public void advance() {
   };
 
   static private class GOVERNOR_RIGHT extends GraphRelation {
-    GOVERNOR_RIGHT(String reln, String name) {
-      super(">++", reln, name);
+    GOVERNOR_RIGHT(String reln, String name, String edgeName) {
+      super(">++", reln, name, edgeName);
     }
 
 
@@ -326,10 +339,12 @@ public void advance() {
               }
               if (node.index() < edge.getTarget().index()) {
                 this.next = edge.getTarget();
+                this.edge = edge;
                 return;
               }
             }
             this.next = null;
+            this.edge = null;
           }
       };
     }
@@ -339,8 +354,8 @@ public void advance() {
   }
 
   static private class GOVERNOR_LEFT extends GraphRelation {
-    GOVERNOR_LEFT(String reln, String name) {
-      super(">--", reln, name);
+    GOVERNOR_LEFT(String reln, String name, String edgeName) {
+      super(">--", reln, name, edgeName);
     }
 
 
@@ -379,10 +394,12 @@ public void advance() {
               }
               if (node.index() > edge.getTarget().index()) {
                 this.next = edge.getTarget();
+                this.edge = edge;
                 return;
               }
             }
             this.next = null;
+            this.edge = null;
           }
       };
     }
@@ -394,8 +411,8 @@ public void advance() {
   // DEPENDENT graph relation: "<" ===============================================
 
   static private class DEPENDENT extends GraphRelation {
-    DEPENDENT(String reln, String name) {
-      super("<", reln, name);
+    DEPENDENT(String reln, String name, String edgeName) {
+      super("<", reln, name, edgeName);
     }
 
     @Override
@@ -431,11 +448,13 @@ public void advance() {
                 continue;
               }
               this.next = edge.getSource();
+              this.edge = edge;
               return;
             }
             this.next = null;
+            this.edge = null;
           }
-        };
+      };
     }
 
     // automatically generated by Eclipse
@@ -444,8 +463,8 @@ public void advance() {
 
 
   static private class DEPENDENT_RIGHT extends GraphRelation {
-    DEPENDENT_RIGHT(String reln, String name) {
-      super("<++", reln, name);
+    DEPENDENT_RIGHT(String reln, String name, String edgeName) {
+      super("<++", reln, name, edgeName);
     }
 
     @Override
@@ -485,10 +504,12 @@ public void advance() {
               }
               if (node.index() < edge.getSource().index()) {
                 this.next = edge.getSource();
+                this.edge = edge;
                 return;
               }
             }
             this.next = null;
+            this.edge = null;
           }
       };
     }
@@ -499,8 +520,8 @@ public void advance() {
 
 
   static private class DEPENDENT_LEFT extends GraphRelation {
-    DEPENDENT_LEFT(String reln, String name) {
-      super("<--", reln, name);
+    DEPENDENT_LEFT(String reln, String name, String edgeName) {
+      super("<--", reln, name, edgeName);
     }
 
     @Override
@@ -518,6 +539,7 @@ boolean satisfies(IndexedWord l1, IndexedWord l2, SemanticGraph sg) {
       return false;
     }
 
+
     @Override
     Iterator<IndexedWord> searchNodeIterator(final IndexedWord node, final SemanticGraph sg) {
       return new SearchNodeIterator() {
@@ -540,10 +562,12 @@ public void advance() {
               }
               if (node.index() > edge.getSource().index()) {
                 this.next = edge.getSource();
+                this.edge = edge;
                 return;
               }
             }
             this.next = null;
+            this.edge = null;
           }
       };
     }
@@ -1342,25 +1366,31 @@ public static boolean isKnownRelation(String reln) {
 
   public static GraphRelation getRelation(String reln,
                                           String type,
-                                          String name) throws ParseException {
+                                          String name,
+                                          String edgeName) throws ParseException {
     if (reln == null && type == null)
       return null;
     if (!isKnownRelation(reln)) {
       throw new ParseException("Unknown relation " + reln);
     }
     switch (reln) {
       case ">":
-        return new GOVERNOR(type, name);
+        return new GOVERNOR(type, name, edgeName);
       case ">++":
-        return new GOVERNOR_RIGHT(type, name);
+        return new GOVERNOR_RIGHT(type, name, edgeName);
       case ">--":
-        return new GOVERNOR_LEFT(type, name);
+        return new GOVERNOR_LEFT(type, name, edgeName);
       case "<":
-        return new DEPENDENT(type, name);
+        return new DEPENDENT(type, name, edgeName);
       case "<++":
-        return new DEPENDENT_RIGHT(type, name);
+        return new DEPENDENT_RIGHT(type, name, edgeName);
       case "<--":
-        return new DEPENDENT_LEFT(type, name);
+        return new DEPENDENT_LEFT(type, name, edgeName);
+    }
+    if (edgeName != null) {
+      throw new ParseException("Relation " + reln + " does not allow for named edges");
+    }
+    switch (reln) {
       case ">>":
         return new GRANDPARENT(type, name);
       case "<<":
@@ -1386,7 +1416,7 @@ public static GraphRelation getRelation(String reln,
       case "@":
         return new ALIGNMENT();
       default:
-//error
+        //error
         throw new ParseException("Relation " + reln +
             " not handled by getRelation");
     }
@@ -1395,7 +1425,11 @@ public static GraphRelation getRelation(String reln,
   public static GraphRelation getRelation(String reln,
                                           String type,
                                           int num,
-                                          String name) throws ParseException {
+                                          String name,
+                                          String edgeName) throws ParseException {
+    if (edgeName != null) {
+      throw new ParseException("Relation " + reln + " does not allow for named edges");
+    }
     if (reln == null && type == null)
       return null;
     if (reln.equals(">>"))
@@ -1413,7 +1447,11 @@ else if (isKnownRelation(reln))
   public static GraphRelation getRelation(String reln,
                                           String type,
                                           int num, int num2,
-                                          String name) throws ParseException {
+                                          String name,
+                                          String edgeName) throws ParseException {
+    if (edgeName != null) {
+      throw new ParseException("Relation " + reln + " does not allow for named edges");
+    }
     if (reln == null && type == null)
       return null;
     if (reln.equals(">>"))
@@ -1472,6 +1510,12 @@ public SearchNodeIterator() {
      */
     String relation = null;
 
+    /**
+     * If the relation is a type which a single edge, such as dependent or governor,
+     * this variable can store that edge.  Other relations such as grandparent
+     * do not store an edge.
+     */
+    SemanticGraphEdge edge = null;
     /**
      * This method must insure that next points to first item, or null if there
      * are no items.
@@ -1503,6 +1547,12 @@ public IndexedWord next() {
 
     String getReln() {return relation;}
 
+    /**
+     * Return the edge cached by the match - might be null if it was not an appropriate relation type,
+     * even if there was a labeled relation
+     */
+    SemanticGraphEdge getEdge() {return edge;}
+
     public void remove() {
       throw new UnsupportedOperationException("SearchNodeIterator does not support remove().");
     }