2 files changed, 92 insertions, 79 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java b/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
index 78aced1..9a9d0de 100644
--- a/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
+++ b/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
@@ -16,14 +16,10 @@ import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.StringTokenizer;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 public class AnswerTuple {
         
         public static final String SEPARATOR = "\t";
-        static final Pattern owlLiteralRegex =
-                        Pattern.compile("^\"(?<lexicalForm>[^@]+(@(?<langTag>.+))?)\"(^^<(?<dataType>.+)>)?$");
         String m_str = null;
         GroundTerm[] m_tuple;
         
@@ -158,32 +154,36 @@ public class AnswerTuple {
                         String tuplesString = json.getAsJsonPrimitive().getAsString();
 //                      StringTokenizer tokenizer = new StringTokenizer(tuplesString, SEPARATOR);
                         StringTokenizer tokenizer = new StringTokenizer(tuplesString);
-                        GroundTerm[] terms = new GroundTerm[tokenizer.countTokens()];
+                        int tokensCount = tokenizer.countTokens();
+                        GroundTerm[] terms = new GroundTerm[tokensCount];
 
                         // TODO test parsing
-                        for (int i = 0; i < tokenizer.countTokens(); i++) {
+                        for(int i = 0; i < tokensCount; i++) {
                                 String token = tokenizer.nextToken();
                                 if (token.charAt(0) == '<') {
                                         terms[i] = uk.ac.ox.cs.JRDFox.model.Individual.create(token.substring(1,token.length()-1));
                                 }
                                 else if (token.charAt(0) == '"') {
-                                        Matcher matcher = owlLiteralRegex.matcher(token);
-                                        if(matcher.matches()) {
-                                                String lexicalForm = matcher.group("lexicalForm");
-                                                String dataTypeIRI = matcher.group("dataType");
-                                                Datatype dataType;
-                                                if(dataTypeIRI == null || dataTypeIRI.isEmpty()) dataType = Datatype.RDF_PLAIN_LITERAL;
-                                                else dataType = uk.ac.ox.cs.JRDFox.model.Datatype.value(dataTypeIRI);
-                                                terms[i] = uk.ac.ox.cs.JRDFox.model.Literal.create(lexicalForm, dataType);
+                                        Datatype datatype;
+                                        String lexicalForm;
+                                        if(token.contains("^^")) {
+                                                String[] lexicalFormAndType = token.split("^^");
+                                                lexicalForm = lexicalFormAndType[0];
+                                                datatype = Datatype.value(lexicalFormAndType[1]);
                                         }
                                         else {
-                                                throw new IllegalArgumentException("The given json does not represent a valid AnswerTuple");
+                                                lexicalForm = token.substring(1, token.length() - 1);
+                                                // TODO check
+//                                              datatype = token.contains("@") ? Datatype.RDF_PLAIN_LITERAL : Datatype.XSD_STRING;
+                                                datatype = Datatype.XSD_STRING;
                                         }
+                                        terms[i] = uk.ac.ox.cs.JRDFox.model.Literal.create(lexicalForm, datatype);
                                 }
                                 else {
                                         terms[i] = uk.ac.ox.cs.JRDFox.model.BlankNode.create(token);
                                 }
                         }
+
                         return new AnswerTuple(terms);
                 }
         }
diff --git a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
index 742b7da..516a461 100644
--- a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
+++ b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
@@ -135,74 +135,16 @@ public class QueryRecord extends Disposable {
         return updateUpperBoundAnswers(answerTuples, false);
     }
 
-    public boolean updateUpperBoundAnswers(AnswerTuples answerTuples, boolean toCheckAux) {
+    public boolean checkUpperBoundAnswers(AnswerTuples answerTuples) {
         if(isDisposed()) throw new DisposedException();
 
-        if(!(answerTuples instanceof RDFoxAnswerTuples)) {
-            String msg = "The upper bound must be computed by RDFox!";
-            Utility.logError(msg);
-            throw new IllegalArgumentException(msg);
-        }
-
-        RDFoxAnswerTuples rdfoxAnswerTuples = (RDFoxAnswerTuples) answerTuples;
-
-        Set<AnswerTuple> candidateGapAnswerTuples = new HashSet<AnswerTuple>();
-        AnswerTuple tuple;
-        for(; rdfoxAnswerTuples.isValid(); rdfoxAnswerTuples.moveNext()) {
-            tuple = rdfoxAnswerTuples.getTuple();
-            if(isBottom() || !tuple.hasAnonymousIndividual())
-                if((!toCheckAux || !tuple.hasAuxPredicate()) && !soundAnswerTuples.contains(tuple))
-                    candidateGapAnswerTuples.add(tuple);
-        }
-
-        /*** START: debugging ***/
-        if(PagodaProperties.isDebuggingMode()) {
-            if(rdfoxAnswerTuples.getArity() != getAnswerVariables().length)
-                throw new IllegalArgumentException(
-                        "The arity of answers (" + rdfoxAnswerTuples.getArity() + ") " +
-                                "is different from the number of answer variables (" +
-                                getAnswerVariables().length + ")");
-
-            Set<AnswerTuple> namedAnswerTuples = new HashSet<>();
-            rdfoxAnswerTuples.reset();
-            for(; rdfoxAnswerTuples.isValid(); rdfoxAnswerTuples.moveNext()) {
-                tuple = rdfoxAnswerTuples.getTuple();
-//                              if(isBottom() || !tuple.hasAnonymousIndividual()) {
-                namedAnswerTuples.add(tuple);
-//                              }
-            }
-            HashSet<AnswerTuple> difference = new HashSet<>(soundAnswerTuples);
-            difference.removeAll(namedAnswerTuples);
-            if(!difference.isEmpty())
-                throw new IllegalArgumentException("The upper bound does not contain the lower bound! Missing answers: " + difference
-                        .size());
-        }
-        /*** END: debugging ***/
-
-        boolean update;
-        if(gapAnswerTuples == null) {
-            gapAnswerTuples = candidateGapAnswerTuples;
-            update = true;
-        }
-        else {
-            update = gapAnswerTuples.retainAll(candidateGapAnswerTuples);
-        }
-
-        if(update)
-            Utility.logInfo("Upper bound answers updated: " + getNumberOfAnswers());
-        else
-            Utility.logInfo("Upper bound answers unchanged");
+        return updateUpperBoundAnswers(answerTuples, true, false);
+    }
 
-        return update;
+    public boolean updateUpperBoundAnswers(AnswerTuples answerTuples, boolean toCheckAux) {
+        if(isDisposed()) throw new DisposedException();
 
-//              boolean update = false;
-//              for(Iterator<AnswerTuple> iter = gapAnswerTuples.iterator(); iter.hasNext(); ) {
-//                      tuple = iter.next();
-//                      if(!candidateGapAnswerTuples.contains(tuple)) {
-//                              iter.remove();
-//                              update = true;
-//                      }
-//              }
+        return updateUpperBoundAnswers(answerTuples, toCheckAux, true);
     }
 
     public int getNumberOfAnswers() {
@@ -713,6 +655,77 @@ public class QueryRecord extends Disposable {
         return Objects.hash(queryText, soundAnswerTuples);
     }
 
+    private boolean updateUpperBoundAnswers(AnswerTuples answerTuples, boolean toCheckAux, boolean _check_containment) {
+        if(!(answerTuples instanceof RDFoxAnswerTuples)) {
+            String msg = "The upper bound must be computed by RDFox!";
+            Utility.logError(msg);
+            throw new IllegalArgumentException(msg);
+        }
+
+        RDFoxAnswerTuples rdfoxAnswerTuples = (RDFoxAnswerTuples) answerTuples;
+
+        Set<AnswerTuple> candidateGapAnswerTuples = new HashSet<AnswerTuple>();
+        AnswerTuple tuple;
+        for(; rdfoxAnswerTuples.isValid(); rdfoxAnswerTuples.moveNext()) {
+            tuple = rdfoxAnswerTuples.getTuple();
+            if(isBottom() || !tuple.hasAnonymousIndividual())
+                if((!toCheckAux || !tuple.hasAuxPredicate()) && !soundAnswerTuples.contains(tuple))
+                    candidateGapAnswerTuples.add(tuple);
+        }
+
+        /*** START: debugging ***/
+        if(PagodaProperties.isDebuggingMode() && _check_containment) {
+            if(rdfoxAnswerTuples.getArity() != getAnswerVariables().length)
+                throw new IllegalArgumentException(
+                        "The arity of answers (" + rdfoxAnswerTuples.getArity() + ") " +
+                                "is different from the number of answer variables (" +
+                                getAnswerVariables().length + ")");
+
+            Set<AnswerTuple> namedAnswerTuples = new HashSet<>();
+            rdfoxAnswerTuples.reset();
+            int numberOfAnswers = 0;
+            for(; rdfoxAnswerTuples.isValid(); rdfoxAnswerTuples.moveNext()) {
+                tuple = rdfoxAnswerTuples.getTuple();
+//                              if(isBottom() || !tuple.hasAnonymousIndividual()) {
+                namedAnswerTuples.add(tuple);
+//                              }
+                numberOfAnswers++;
+            }
+            Utility.logDebug("The number of answers returned by an upper bound: " + numberOfAnswers);
+            HashSet<AnswerTuple> difference = new HashSet<>(soundAnswerTuples);
+            difference.removeAll(namedAnswerTuples);
+            if(!difference.isEmpty())
+                throw new IllegalArgumentException("The upper bound does not contain the lower bound! Missing answers: " + difference
+                        .size());
+        }
+        /*** END: debugging ***/
+
+        boolean update;
+        if(gapAnswerTuples == null) {
+            gapAnswerTuples = candidateGapAnswerTuples;
+            update = true;
+        }
+        else {
+            update = gapAnswerTuples.retainAll(candidateGapAnswerTuples);
+        }
+
+        if(update)
+            Utility.logInfo("Upper bound answers updated: " + getNumberOfAnswers());
+        else
+            Utility.logInfo("Upper bound answers unchanged");
+
+        return update;
+
+//              boolean update = false;
+//              for(Iterator<AnswerTuple> iter = gapAnswerTuples.iterator(); iter.hasNext(); ) {
+//                      tuple = iter.next();
+//                      if(!candidateGapAnswerTuples.contains(tuple)) {
+//                              iter.remove();
+//                              update = true;
+//                      }
+//              }
+    }
+
     public enum Step {
         LOWER_BOUND,
         UPPER_BOUND,