M2 cond

.gitignore

@@ -11,7 +11,6 @@
 .mtj.tmp/
 
 # Package Files #
-*.jar
 *.war
 *.nar
 *.ear

pom.xml

@@ -21,7 +21,7 @@
             <plugin>
                 <groupId>org.antlr</groupId>
                 <artifactId>antlr4-maven-plugin</artifactId>
-                <version>4.7.2</version>
+                <version>4.11.1</version>
                 <executions>
                     <execution>
                         <id>antlr</id>

src/main/java/edu/ucsd/cse232b/Context.java

@@ -2,12 +2,15 @@
 
 import org.w3c.dom.Node;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class Context {
-    private HashMap<String, List<Node>> vars;
+    private HashMap<String, List<Node>> vars = new HashMap<>();
+
+    public Context() {}
 
     public Context(Context c) {
         this.vars = c.getAllVars();
@@ -21,7 +24,7 @@ public List<Node> getVar(String p) {
         return vars.get(p);
     }
 
-    public void putVar(String p, List<Node> nl) {
-        this.vars.put(p, nl);
+    public void putVar(String p, List<Node> vals) {
+        this.vars.put(p, vals);
     }
 }

src/main/java/edu/ucsd/cse232b/conditions/AndC.java

@@ -0,0 +1,26 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+public class AndC implements Condition {
+    private final Condition c1;
+    private final Condition c2;
+
+    public AndC(Condition c1, Condition c2) {
+        this.c1 = c1;
+        this.c2 = c2;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        return c1.solve(c, doc) && c2.solve(c, doc);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s and %s", c1.toString(), c2.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/Condition.java

@@ -0,0 +1,13 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+
+public interface Condition {
+    boolean solve(Stack<Context> c, Document doc) throws Exception;
+
+    String toString();
+}

src/main/java/edu/ucsd/cse232b/conditions/EmptyC.java

@@ -0,0 +1,25 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import edu.ucsd.cse232b.expressions.contextual.ContextExp;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+public class EmptyC implements Condition {
+    private final ContextExp ce;
+
+    public EmptyC(ContextExp ce) {
+        this.ce = ce;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        return this.ce.solve(c, doc).isEmpty();
+    }
+
+    @Override
+    public String toString() {
+        return String.format("not %s", ce.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/NotC.java

@@ -0,0 +1,24 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+public class NotC implements Condition {
+    private final Condition c;
+
+    public NotC(Condition c) {
+        this.c = c;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        return !this.c.solve(c, doc);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("not %s", c.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/OrC.java

@@ -0,0 +1,26 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+public class OrC implements Condition {
+    private final Condition c1;
+    private final Condition c2;
+
+    public OrC(Condition c1, Condition c2) {
+        this.c1 = c1;
+        this.c2 = c2;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        return c1.solve(c, doc) || c2.solve(c, doc);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s and %s", c1.toString(), c2.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/ParenC.java

@@ -0,0 +1,24 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+public class ParenC implements Condition {
+    private final Condition c;
+
+    public ParenC(Condition c) {
+        this.c = c;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        return this.c.solve(c, doc);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("not %s", c.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/SatisfiesC.java

@@ -0,0 +1,24 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import org.w3c.dom.Document;
+
+import java.util.Stack;
+
+public class SatisfiesC implements Condition {
+    private final boolean b;
+
+    public SatisfiesC(boolean b) {
+        this.b = b;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        return b;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Satsifies %s and %s", b);
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/xEqxC.java

@@ -0,0 +1,31 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import edu.ucsd.cse232b.expressions.contextual.ContextExp;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import java.util.List;
+import java.util.Stack;
+
+public class xEqxC implements Condition {
+    final private ContextExp x1;
+    final private ContextExp x2;
+
+    public xEqxC(ContextExp x1, ContextExp x2) {
+        this.x1 = x1;
+        this.x2 = x2;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        List<Node> l1 = x1.solve(c, doc);
+        List<Node> l2 = x2.solve(c, doc);
+        return l1.stream().anyMatch(n1 -> l2.stream().anyMatch(n1::isEqualNode));
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s eq %s", x1.toString(), x2.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/conditions/xIsxC.java

@@ -0,0 +1,31 @@
+package edu.ucsd.cse232b.conditions;
+
+import edu.ucsd.cse232b.Context;
+import edu.ucsd.cse232b.expressions.contextual.ContextExp;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+
+import java.util.List;
+import java.util.Stack;
+
+public class xIsxC implements Condition {
+    final private ContextExp x1;
+    final private ContextExp x2;
+
+    public xIsxC(ContextExp x1, ContextExp x2) {
+        this.x1 = x1;
+        this.x2 = x2;
+    }
+
+    @Override
+    public boolean solve(Stack<Context> c, Document doc) throws Exception {
+        List<Node> l1 = x1.solve(c, doc);
+        List<Node> l2 = x2.solve(c, doc);
+        return l1.stream().anyMatch(n1 -> l2.stream().anyMatch(n1::isSameNode));
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s is %s", x1.toString(), x2.toString());
+    }
+}

src/main/java/edu/ucsd/cse232b/expressions/contextual/Ap.java

@@ -5,8 +5,8 @@
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 
-import java.util.Collections;
 import java.util.List;
+import java.util.Stack;
 
 public class Ap implements ContextExp{
     private final AbsolutePath ap;
@@ -18,7 +18,7 @@ public Ap (AbsolutePath ap, List<Node> ctxList) {
     }
 
     @Override
-    public List<Node> solve(Context ctx, Document doc) throws Exception {
+    public List<Node> solve(Stack<Context> ctx, Document doc) throws Exception {
         return ap.solve(this.ctxList, doc);
     }
 

src/main/java/edu/ucsd/cse232b/expressions/contextual/Comma.java

@@ -1,12 +1,14 @@
 package edu.ucsd.cse232b.expressions.contextual;
 
 import edu.ucsd.cse232b.Context;
-import edu.ucsd.cse232b.expressions.relative.RelativePath;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 
-import javax.print.Doc;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Stack;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class Comma implements ContextExp{
     private final ContextExp ce1;
@@ -18,14 +20,14 @@ public Comma(ContextExp ce1, ContextExp ce2) {
     }
 
     @Override
-    public List<Node> solve(Context c, Document doc) throws Exception {
+    public List<Node> solve(Stack<Context> c, Document doc) throws Exception {
         List<Node> l1 = ce1.solve(c, doc);
-        l1.addAll(ce2.solve(c, doc));
-        return l1;
+        List<Node> l2 = ce2.solve(c, doc);
+        return Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
     }
 
     @Override
     public String toString() {
-        return ce2.toString() + "," + ce2.toString();
+        return ce1.toString() + "," + ce2.toString();
     }
 }

src/main/java/edu/ucsd/cse232b/expressions/contextual/ContextExp.java

@@ -5,8 +5,9 @@
 import org.w3c.dom.Node;
 
 import java.util.List;
+import java.util.Stack;
 
 public interface ContextExp {
-        List<Node> solve(Context c, Document doc) throws Exception;
+        List<Node> solve(Stack<Context> c, Document doc) throws Exception;
         String toString();
 }

src/main/java/edu/ucsd/cse232b/expressions/contextual/DoubleSlash.java

@@ -3,14 +3,13 @@
 import edu.ucsd.cse232b.Context;
 import edu.ucsd.cse232b.expressions.relative.RelativePath;
 import edu.ucsd.cse232b.expressions.relative.Self;
-import edu.ucsd.cse232b.expressions.relative.Slash;
-import edu.ucsd.cse232b.expressions.relative.Star;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Stack;
 import java.util.stream.Collectors;
 
 public class DoubleSlash implements ContextExp{
@@ -24,10 +23,10 @@ public DoubleSlash(RelativePath child, ContextExp ce) {
     }
 
     @Override
-    public List<Node> solve(Context c, Document doc) throws Exception {
+    public List<Node> solve(Stack<Context> c, Document doc) throws Exception {
         return ce.solve(c, doc).stream().map(node -> {
             try {
-                return new edu.ucsd.cse232b.expressions.relative.DoubleSlash(new Self(), child).solve(Collections.singletonList(node));
+                return new edu.ucsd.cse232b.expressions.relative.DoubleSlash(new Self(), child).solve(List.of(node));
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }