2 files changed, 284 insertions, 289 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java b/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
index cd86282..7220533 100644
--- a/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
+++ b/src/uk/ac/ox/cs/pagoda/query/AnswerTuple.java
@@ -22,10 +22,11 @@ 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;
         
-        String m_str = null; 
-        GroundTerm[] m_tuple; 
-
         public AnswerTuple(TupleIterator iter, int arity) {
                 m_tuple = new GroundTerm[arity];
                 try {
@@ -33,24 +34,29 @@ public class AnswerTuple {
                                 m_tuple[i] = iter.getGroundTerm(i);
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                } 
+                }
         }
         
         public AnswerTuple(GroundTerm[] terms) {
-                m_tuple = terms; 
-        }
-        
-        private AnswerTuple(AnswerTuple sup, int arity) {
-                m_tuple = new GroundTerm[arity]; 
-                for (int i = 0; i < arity; ++i) m_tuple[i] = sup.m_tuple[i]; 
+                m_tuple = terms;
         }
 
 //      private AnswerTuple(String m_str) {
 //              this.m_str = m_str;
 //      }
+
+        private AnswerTuple(AnswerTuple sup, int arity) {
+                m_tuple = new GroundTerm[arity];
+                for(int i = 0; i < arity; ++i) m_tuple[i] = sup.m_tuple[i];
+        }
+
+        public static AnswerTuple create(AnswerTuple extendedTuple, int length) {
+                if(length == extendedTuple.getArity()) return extendedTuple;
+                else return new AnswerTuple(extendedTuple, length);
+        }
         
         public int getArity() {
-                return m_tuple.length; 
+                return m_tuple.length;
         }
 
         public int hashCode() {
@@ -60,7 +66,7 @@ public class AnswerTuple {
                         code = code * 1997 + m_tuple[i].hashCode();
                 return code;
         }
-        
+
         public boolean equals(Object obj) {
                 if (!(obj instanceof AnswerTuple)) return false;
                 AnswerTuple that = (AnswerTuple) obj;
@@ -73,8 +79,8 @@ public class AnswerTuple {
         }
         
         public String toString() {
-                if (m_str != null) return m_str; 
-                StringBuilder sb = new StringBuilder();  
+                if(m_str != null) return m_str;
+                StringBuilder sb = new StringBuilder();
                 for (int i = 0; i < m_tuple.length; ++i) {
                         if (sb.length() != 0) sb.append(SEPARATOR);
                         if (m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)
@@ -83,64 +89,58 @@ public class AnswerTuple {
                                 sb.append(m_tuple[i].toString());
                         }
                         else {
-                                Literal l = (Literal) m_tuple[i]; 
+                                Literal l = (Literal) m_tuple[i];
                                 sb.append('"').append(l.getLexicalForm()).append("\"");
                                 if (!l.getDatatype().equals(Datatype.XSD_STRING) && !l.getDatatype().equals(Datatype.RDF_PLAIN_LITERAL))
-                                        sb.append("^^<").append(l.getDatatype().getIRI()).append(">"); 
+                                        sb.append("^^<").append(l.getDatatype().getIRI()).append(">");
                         }
                 }
-                return m_str = sb.toString();  
+                return m_str = sb.toString();
         }
 
         public GroundTerm getGroundTerm(int i) {
-                return m_tuple[i]; 
+                return m_tuple[i];
         }
         
         public Map<Variable, Term> getAssignment(String[] vars) {
-                Map<Variable, Term> map = new HashMap<Variable, Term>(); 
-                int index = 0; 
-                Term t; 
+                Map<Variable, Term> map = new HashMap<Variable, Term>();
+                int index = 0;
+                Term t;
                 for (String var: vars) {
-                        if (m_tuple[index] instanceof uk.ac.ox.cs.JRDFox.model.Individual) 
-                                t = Individual.create((((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[index]).getIRI())); 
+                        if(m_tuple[index] instanceof uk.ac.ox.cs.JRDFox.model.Individual)
+                                t = Individual.create((((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[index]).getIRI()));
                         else {
-                                uk.ac.ox.cs.JRDFox.model.Literal l = (uk.ac.ox.cs.JRDFox.model.Literal) m_tuple[index]; 
-                                t = Constant.create(l.getLexicalForm(), l.getDatatype().getIRI()); 
+                                uk.ac.ox.cs.JRDFox.model.Literal l = (uk.ac.ox.cs.JRDFox.model.Literal) m_tuple[index];
+                                t = Constant.create(l.getLexicalForm(), l.getDatatype().getIRI());
                         }
-                        map.put(Variable.create(var), t); 
-                        ++index; 
+                        map.put(Variable.create(var), t);
+                        ++index;
                 }
-                return map; 
+                return map;
         }
 
         public boolean hasAuxPredicate() {
-                String iri; 
+                String iri;
                 for (int i = 0; i < m_tuple.length; ++i)
                         if ((m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)) {
                                 iri = ((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[i]).getIRI();
-                                if ( iri.startsWith(Namespace.PAGODA_AUX) || iri.contains("_AUX") || iri.contains("_neg") || iri.contains("internal:def"))
-                                        return true; 
+                                if(iri.startsWith(Namespace.PAGODA_AUX) || iri.contains("_AUX") || iri.contains("_neg") || iri.contains("internal:def"))
+                                        return true;
                         }
-                return false; 
+                return false;
         }
-        
-        public boolean hasAnonyIndividual() {
-                String iri; 
-                for (int i = 0; i < m_tuple.length; ++i)
-                        if ((m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)) {
+
+        public boolean hasAnonymousIndividual() {
+                String iri;
+                for(int i = 0; i < m_tuple.length; ++i)
+                        if((m_tuple[i] instanceof uk.ac.ox.cs.JRDFox.model.Individual)) {
                                 iri = ((uk.ac.ox.cs.JRDFox.model.Individual) m_tuple[i]).getIRI();
-                                if (iri.startsWith(Namespace.PAGODA_ANONY) || iri.startsWith(Namespace.KARMA_ANONY))
-                                        return true; 
+                                if(iri.startsWith(Namespace.PAGODA_ANONY) || iri.startsWith(Namespace.KARMA_ANONY))
+                                        return true;
                         }
-                return false; 
+                return false;
         }
 
-        public static AnswerTuple create(AnswerTuple extendedTuple, int length) {
-                if (length == extendedTuple.getArity()) return extendedTuple;
-                else return new AnswerTuple(extendedTuple, length); 
-        }
-
-
         public static class AnswerTupleSerializer implements JsonSerializer<AnswerTuple> {
 
                 public JsonElement serialize(AnswerTuple src, Type typeOfSrc, JsonSerializationContext context) {
@@ -149,8 +149,6 @@ public class AnswerTuple {
 
         }
 
-        static final Pattern owlLiteralRegex = Pattern.compile("^\"(?<lexicalForm>[^@]+(@(?<langTag>.+))?)\"(^^<(?<dataType>.+)>)?$");
-
         public static class AnswerTupleDeserializer implements JsonDeserializer<AnswerTuple> {
                 public AnswerTuple deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
                                 throws JsonParseException {
diff --git a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
index 15b2c01..4998a19 100644
--- a/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
+++ b/src/uk/ac/ox/cs/pagoda/query/QueryRecord.java
@@ -10,6 +10,8 @@ import uk.ac.ox.cs.pagoda.rules.GeneralProgram;
 import uk.ac.ox.cs.pagoda.util.ConjunctiveQueryHelper;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
+import uk.ac.ox.cs.pagoda.util.tuples.Tuple;
+import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder;
 
 import java.io.*;
 import java.lang.reflect.Type;
@@ -18,199 +20,204 @@ import java.util.*;
 public class QueryRecord {
         
         public static final String botQueryText = "SELECT ?X WHERE { ?X <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#Nothing> }";
-
+        public static final String SEPARATOR = "----------------------------------------";
+        boolean processed = false;
+        String stringQueryID = null;
+        OWLOntology relevantOntology = null;
+        Set<DLClause> relevantClauses = new HashSet<DLClause>();
+        double[] timer;
+        int subID;
+        DLClause queryClause = null;
         private Step difficulty;
-        
-        private String queryText; 
-        private int queryID = -1; 
-
+        private String queryText;
+        private int queryID = -1;
         private String[][] answerVariables = null;
         private Set<AnswerTuple> soundAnswerTuples = new HashSet<AnswerTuple>();
         private Set<AnswerTuple> gapAnswerTuples = null;
-        
         private QueryManager m_manager;
+
+        private QueryRecord() {
+        }
         
         public QueryRecord(QueryManager manager, String text, int id, int subID) {
-                m_manager =manager; 
+                m_manager = manager;
                 resetInfo(text, id, subID);
-                resetTimer(); 
+                resetTimer();
         }
-        
+
+//      private boolean containsAuxPredicate(String str) {
+//              return  str.contains(Namespace.PAGODA_AUX) || str.contains("_AUX") || str.contains("owl#Nothing") ||
+//                              str.contains("internal:def"); 
+//      }
+
+        public static Collection<String> collectQueryTexts(Collection<QueryRecord> queryRecords) {
+                Collection<String> texts = new LinkedList<String>();
+                for(QueryRecord record : queryRecords)
+                        texts.add(record.queryText);
+                return texts;
+        }
+
         public void resetInfo(String text, int id, int subid) {
                 queryID = id;
-                subID = subid; 
+                subID = subid;
                 stringQueryID = id + (subID == 0 ? "" : "_" + subID);
-                m_manager.remove(queryText); 
-                m_manager.put(text, this); 
+                m_manager.remove(queryText);
+                m_manager.put(text, this);
                 queryClause = null;
                 answerVariables = ConjunctiveQueryHelper.getAnswerVariables(text);
-                queryText = text; // .replace("_:", "?"); 
+                queryText = text; // .replace("_:", "?");
         }
 
         public void resetTimer() {
-                int length = Step.values().length; 
-                timer = new double[length]; 
-                for (int i = 0; i < length; ++i) timer[i] = 0; 
+                int length = Step.values().length;
+                timer = new double[length];
+                for(int i = 0; i < length; ++i) timer[i] = 0;
         }
-        
+
         public AnswerTuples getAnswers() {
-                if (processed())
+                if(processed())
                         return getLowerBoundAnswers();
-                
-                return getUpperBoundAnswers(); 
+
+                return getUpperBoundAnswers();
         }
-        
+
         public AnswerTuples getLowerBoundAnswers() {
-                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples); 
+                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples);
         }
-        
+
         public AnswerTuples getUpperBoundAnswers() {
-                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples, gapAnswerTuples); 
+                return new AnswerTuplesImp(answerVariables[0], soundAnswerTuples, gapAnswerTuples);
         }
-        
+
         public boolean updateLowerBoundAnswers(AnswerTuples answerTuples) {
-                if (answerTuples == null) return false;
+                if(answerTuples == null) return false;
                 boolean update = false;
-                for (AnswerTuple tuple; answerTuples.isValid(); answerTuples.moveNext()) {
+                for(AnswerTuple tuple; answerTuples.isValid(); answerTuples.moveNext()) {
                         tuple = answerTuples.getTuple();
-                        if (!soundAnswerTuples.contains(tuple) && (gapAnswerTuples == null || gapAnswerTuples.contains(tuple))) {
+                        if(!soundAnswerTuples.contains(tuple) && (gapAnswerTuples == null || gapAnswerTuples.contains(tuple))) {
                                 soundAnswerTuples.add(tuple);
-                                if (gapAnswerTuples != null)
+                                if(gapAnswerTuples != null)
                                         gapAnswerTuples.remove(tuple);
                                 update = true;
                         }
-                        // TODO could be wrong, but if possible add the check
-//                      else if (! gapAnswerTuples.contains(tuple)) {
-//                              throw new IllegalArgumentException("The lower bound answers must be contained in the upper ones!");
-//                      }
                 }
-                Utility.logInfo("The number of answers in the lower bound: " + soundAnswerTuples.size()); 
+                Utility.logInfo("The number of answers in the lower bound: " + soundAnswerTuples.size());
 
-                return update; 
+                return update;
         }
-        
+
         public boolean updateUpperBoundAnswers(AnswerTuples answerTuples) {
-                return updateUpperBoundAnswers(answerTuples, false); 
+                return updateUpperBoundAnswers(answerTuples, false);
         }
-        
+
         public boolean updateUpperBoundAnswers(AnswerTuples answerTuples, boolean toCheckAux) {
                 RDFoxAnswerTuples rdfAnswerTuples;
-                if (answerTuples instanceof RDFoxAnswerTuples)
-                        rdfAnswerTuples = (RDFoxAnswerTuples) answerTuples; 
+                if(answerTuples instanceof RDFoxAnswerTuples)
+                        rdfAnswerTuples = (RDFoxAnswerTuples) answerTuples;
                 else {
                         Utility.logError("The upper bound must be computed by RDFox!");
                         return false;
                 }
-                
-                if (soundAnswerTuples.size() > 0) {
-                        int number = 0; 
-                        for (; answerTuples.isValid(); answerTuples.moveNext()) {
-                                ++number; 
+
+                if(soundAnswerTuples.size() > 0) {
+                        int number = 0;
+                        for(; rdfAnswerTuples.isValid(); rdfAnswerTuples.moveNext()) {
+                                ++number;
                         }
                         Utility.logInfo("The number of answers returned by an upper bound: " + number);
-                        if (number <= soundAnswerTuples.size()) {
-                                if (gapAnswerTuples != null) gapAnswerTuples.clear(); 
+                        if(number == soundAnswerTuples.size()) {
+                                if(gapAnswerTuples != null) gapAnswerTuples.clear();
                                 else gapAnswerTuples = new HashSet<AnswerTuple>();
-                                        
+
                                 Utility.logInfo("The number of upper bound answers: " + (soundAnswerTuples.size() + gapAnswerTuples.size()));
                                 return false;
-                        }
-                        else if (number < soundAnswerTuples.size())
+                        } else if(number < soundAnswerTuples.size())
                                 throw new IllegalArgumentException("The upper bound answers must contain all the lower bound ones!");
-                        answerTuples.reset();
+                        rdfAnswerTuples.reset();
                 }
-                        
-                boolean justCheck = (answerTuples.getArity() != answerVariables[1].length);
-        
+
+                boolean justCheck = (rdfAnswerTuples.getArity() != answerVariables[1].length);
+
                 Set<AnswerTuple> tupleSet = new HashSet<AnswerTuple>();
                 AnswerTuple tuple, extendedTuple;
-                for (; answerTuples.isValid(); answerTuples.moveNext()) {
-                        extendedTuple = rdfAnswerTuples.getTuple(); 
-                        if (isBottom() || !extendedTuple.hasAnonyIndividual()) {
-                                tuple = AnswerTuple.create(extendedTuple, answerVariables[0].length); 
-                                if ((!toCheckAux || !tuple.hasAuxPredicate()) && !soundAnswerTuples.contains(tuple)) {
-                                        if (!toCheckAux && justCheck) return false; 
-                                        tupleSet.add(extendedTuple);
+                for(; rdfAnswerTuples.isValid(); rdfAnswerTuples.moveNext()) {
+                        extendedTuple = rdfAnswerTuples.getTuple();
+                        if(isBottom() || !extendedTuple.hasAnonymousIndividual()) {
+                                tuple = AnswerTuple.create(extendedTuple, answerVariables[0].length);
+                                if((!toCheckAux || !tuple.hasAuxPredicate()) && !soundAnswerTuples.contains(tuple)) {
+                                        if(!toCheckAux && justCheck) return false;
+                                        // TODO check
+//                                      tupleSet.add(extendedTuple);
+                                        tupleSet.add(tuple);
                                 }
                         }
                 }
-                
-                if (gapAnswerTuples == null) {
-                        gapAnswerTuples = tupleSet; 
-                        
+
+                if(gapAnswerTuples == null) {
+                        gapAnswerTuples = tupleSet;
+
                         Utility.logInfo("The number of answers in the upper bound: " + (soundAnswerTuples.size() + gapAnswerTuples.size()));
-                        return true; 
+                        return true;
                 }
-                
-                boolean update = false; 
-                for (Iterator<AnswerTuple> iter = gapAnswerTuples.iterator(); iter.hasNext(); ) {
-                        tuple = iter.next(); 
-                        if (!tupleSet.contains(tuple)) {
-                                iter.remove(); 
-                                update = true; 
+
+                boolean update = false;
+                for(Iterator<AnswerTuple> iter = gapAnswerTuples.iterator(); iter.hasNext(); ) {
+                        tuple = iter.next();
+                        if(!tupleSet.contains(tuple)) {
+                                iter.remove();
+                                update = true;
                         }
                 }
-                
+
                 Utility.logInfo("The number of answers in the upper bound: " + (soundAnswerTuples.size() + gapAnswerTuples.size()));
 
-                return update; 
+                return update;
         }
         
-//      private boolean containsAuxPredicate(String str) {
-//              return  str.contains(Namespace.PAGODA_AUX) || str.contains("_AUX") || str.contains("owl#Nothing") ||
-//                              str.contains("internal:def"); 
-//      }
-
-        boolean processed = false;
-
         public void markAsProcessed() {
-                processed = true; 
+                processed = true;
         }
 
         public boolean processed() {
-                if (gapAnswerTuples != null && gapAnswerTuples.isEmpty()) processed = true; 
-                return processed; 
+                if(gapAnswerTuples != null && gapAnswerTuples.isEmpty()) processed = true;
+                return processed;
         }
         
         public String[] getDistinguishedVariables() {
-                return answerVariables[1]; 
+                return answerVariables[1];
         }
-        
+
         public String[] getAnswerVariables() {
-                return answerVariables[0]; 
+                return answerVariables[0];
         }
-        
+
         public String[][] getVariables() {
-                return answerVariables; 
+                return answerVariables;
         }
         
         public String getQueryText() {
-                return queryText; 
+                return queryText;
         }
         
-        String stringQueryID = null;
-        
         public String getQueryID() {
-                return stringQueryID; 
+                return stringQueryID;
         }
         
         public AnswerTuples getGapAnswers() {
-                return new AnswerTuplesImp(answerVariables[0], gapAnswerTuples); 
+                return new AnswerTuplesImp(answerVariables[0], gapAnswerTuples);
         }
 
         public String toString() {
-                return queryText; 
+                return queryText;
         }
-        
-        public static final String SEPARATOR = "----------------------------------------"; 
 
         public void outputAnswers(BufferedWriter writer) throws IOException {
-                
-                int answerCounter = soundAnswerTuples.size(); 
-                if (!processed()) answerCounter += gapAnswerTuples.size(); 
-                
+
+                int answerCounter = soundAnswerTuples.size();
+                if(!processed()) answerCounter += gapAnswerTuples.size();
+
                 Utility.logInfo("The number of answer tuples: " + answerCounter);
-                
+
                 if (writer != null) {
                         writer.write("-------------- Query " + queryID + " ---------------------");
                         writer.newLine();
@@ -242,7 +249,7 @@ public class QueryRecord {
 //                      writer.write(SEPARATOR);
                         writer.newLine();
                 }
-                
+
         }
 
         public void outputAnswerStatistics() {
@@ -276,51 +283,48 @@ public class QueryRecord {
 //                      jsonAnswers.put(Integer.toString(queryID), jsonAnswer);
 //              }
         }
-        
+
         public void outputTimes() {
                 for (Step step: Step.values()) {
-                        Utility.logDebug("time for " + step + ": " + timer[step.ordinal()]); 
+                        Utility.logDebug("time for " + step + ": " + timer[step.ordinal()]);
                 }
         }
-        
+
         public String outputSoundAnswerTuple() {
-                StringBuilder builder = new StringBuilder(); 
+                StringBuilder builder = new StringBuilder();
                 for (AnswerTuple tuple: soundAnswerTuples)
                         builder.append(tuple.toString()).append(Utility.LINE_SEPARATOR);
-                return builder.toString(); 
+                return builder.toString();
         }
-        
+
         public String outputGapAnswerTuple() {
-                StringBuilder builder = new StringBuilder(); 
-                for (AnswerTuple tuple: gapAnswerTuples)
+                StringBuilder builder = new StringBuilder();
+                for(AnswerTuple tuple : gapAnswerTuples)
                         builder.append(tuple.toString()).append(Utility.LINE_SEPARATOR);
-                return builder.toString(); 
-        }
-        
-        public void setDifficulty(Step step) {
-                this.difficulty = step;
+                return builder.toString();
         }
 
         public Step getDifficulty() {
                 return difficulty;
         }
 
-        OWLOntology relevantOntology = null;
-        Set<DLClause> relevantClauses = new HashSet<DLClause>();
-
-        public void setRelevantOntology(OWLOntology knowledgebase) {
-                relevantOntology = knowledgebase; 
+        public void setDifficulty(Step step) {
+                this.difficulty = step;
         }
-        
+
         public OWLOntology getRelevantOntology() {
-                return relevantOntology; 
+                return relevantOntology;
         }
 
+        public void setRelevantOntology(OWLOntology knowledgebase) {
+                relevantOntology = knowledgebase;
+        }
+        
         public void saveRelevantOntology(String filename) {
-                if (relevantOntology == null) return ; 
-                OWLOntologyManager manager = relevantOntology.getOWLOntologyManager(); 
+                if(relevantOntology == null) return;
+                OWLOntologyManager manager = relevantOntology.getOWLOntologyManager();
                 try {
-                        FileOutputStream outputStream = new FileOutputStream(filename); 
+                        FileOutputStream outputStream = new FileOutputStream(filename);
                         manager.saveOntology(relevantOntology, outputStream);
                         outputStream.close();
                 } catch (OWLOntologyStorageException e) {
@@ -333,12 +337,11 @@ public class QueryRecord {
         }
 
         public void saveRelevantClause() {
-                if (relevantClauses == null) return ; 
+                if(relevantClauses == null) return;
                 GeneralProgram p = new GeneralProgram(relevantClauses, relevantOntology);
                 p.save();
         }
 
-
         public void removeUpperBoundAnswers(Collection<AnswerTuple> answers) {
                 for (AnswerTuple answer: answers) {
 //                      if (soundAnswerTuples.contains(answer))
@@ -349,50 +352,37 @@ public class QueryRecord {
                 }
         }
 
-
         public void addLowerBoundAnswers(Collection<AnswerTuple> answers) {
                 for (AnswerTuple answer: answers) {
                         if (!gapAnswerTuples.contains(answer))
                                 Utility.logError("The answer (" + answer + ") cannot be added, because it is not in the upper bound.");
                         gapAnswerTuples.remove(answer);
-                        
-                        answer = AnswerTuple.create(answer, answerVariables[0].length); 
+
+                        answer = AnswerTuple.create(answer, answerVariables[0].length);
 //                      if (soundAnswerTuples.contains(answer))
 //                              Utility.logError("The answer (" + answer + ") cannot be added, because it is in the lower bound.");
-                        soundAnswerTuples.add(answer); 
+                        soundAnswerTuples.add(answer);
                 }
         }
-        
+
         public int getNoOfSoundAnswers() {
-                return soundAnswerTuples.size(); 
+                return soundAnswerTuples.size();
         }
-        
-        public enum Step {LowerBound, UpperBound, ELLowerBound, 
-                Fragment, FragmentRefinement, Summarisation, Dependency, FullReasoning}
-
-        double[] timer;
 
         public void addProcessingTime(Step step, double time) {
-                timer[step.ordinal()] += time; 
+                timer[step.ordinal()] += time;
         }
 
         public int getArity() {
                 return answerVariables[0].length;
         }
         
-        public static Collection<String> collectQueryTexts(Collection<QueryRecord> queryRecords) {
-                Collection<String> texts = new LinkedList<String>(); 
-                for (QueryRecord record: queryRecords)
-                        texts.add(record.queryText); 
-                return texts;
-        }
-
         public void addRelevantClauses(DLClause clause) {
-                relevantClauses.add(clause);            
+                relevantClauses.add(clause);
         }
-        
+
         public Set<DLClause> getRelevantClauses() {
-                return relevantClauses; 
+                return relevantClauses;
         }
 
         public void clearClauses() {
@@ -403,36 +393,40 @@ public class QueryRecord {
                 for (DLClause clause: relevantClauses)
                         if (clause.getHeadLength() > 1)
                                 return false;
-                return true; 
+                return true;
         }
 
         public void saveABoxInTurtle(String filename) {
                 try {
                         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename)));
                         OWLIndividual a, b;
-                        StringBuilder builder = new StringBuilder(); 
+                        StringBuilder builder = new StringBuilder();
                         for (OWLAxiom axiom: relevantOntology.getABoxAxioms(true)) {
                                 if (axiom instanceof OWLClassAssertionAxiom) {
-                                        OWLClassAssertionAxiom classAssertion = (OWLClassAssertionAxiom) axiom; 
-                                        OWLClass c = (OWLClass) classAssertion.getClassExpression(); 
+                                        OWLClassAssertionAxiom classAssertion = (OWLClassAssertionAxiom) axiom;
+                                        OWLClass c = (OWLClass) classAssertion.getClassExpression();
                                         a = classAssertion.getIndividual();
-                                        builder.append(a.toString()).append(" <").append(Namespace.RDF_TYPE).append("> ").append(c.toString()); 
+                                        builder.append(a.toString())
+                                                   .append(" <")
+                                                   .append(Namespace.RDF_TYPE)
+                                                   .append("> ")
+                                                   .append(c.toString());
                                 }
                                 else if (axiom instanceof OWLObjectPropertyAssertionAxiom) {
-                                        OWLObjectPropertyAssertionAxiom propertyAssertion = (OWLObjectPropertyAssertionAxiom) axiom; 
-                                        OWLObjectProperty p = (OWLObjectProperty) propertyAssertion.getProperty(); 
-                                        a = propertyAssertion.getSubject(); 
-                                        b = propertyAssertion.getObject(); 
-                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(b.toString()); 
+                                        OWLObjectPropertyAssertionAxiom propertyAssertion = (OWLObjectPropertyAssertionAxiom) axiom;
+                                        OWLObjectProperty p = (OWLObjectProperty) propertyAssertion.getProperty();
+                                        a = propertyAssertion.getSubject();
+                                        b = propertyAssertion.getObject();
+                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(b.toString());
                                 }
                                 else if (axiom instanceof OWLDataPropertyAssertionAxiom) {
-                                        OWLDataPropertyAssertionAxiom propertyAssertion = (OWLDataPropertyAssertionAxiom) axiom; 
-                                        OWLDataProperty p = (OWLDataProperty) propertyAssertion.getProperty(); 
-                                        a = propertyAssertion.getSubject(); 
-                                        OWLLiteral l = propertyAssertion.getObject(); 
-                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(l.toString()); 
+                                        OWLDataPropertyAssertionAxiom propertyAssertion = (OWLDataPropertyAssertionAxiom) axiom;
+                                        OWLDataProperty p = (OWLDataProperty) propertyAssertion.getProperty();
+                                        a = propertyAssertion.getSubject();
+                                        OWLLiteral l = propertyAssertion.getObject();
+                                        builder.append(a.toString()).append(" ").append(p.toString()).append(" ").append(l.toString());
                                 }
-                                
+
                                 writer.write(builder.toString());
                                 writer.write(" .");
                                 writer.newLine();
@@ -442,23 +436,19 @@ public class QueryRecord {
                 } catch (IOException e) {
                         e.printStackTrace();
                 } finally {
-                        
+
                 }
         }
-
-        int subID;
         
         public void updateSubID() {
                 ++subID; 
                 stringQueryID = String.valueOf(queryID) + "_" + subID;
         }
         
-        DLClause queryClause = null;
-
         public DLClause getClause() {
                 if (queryClause != null)
-                        return queryClause; 
-                return queryClause = DLClauseHelper.getQuery(queryText, null); 
+                        return queryClause;
+                return queryClause = DLClauseHelper.getQuery(queryText, null);
         }
 
         public boolean isBottom() {
@@ -468,19 +458,19 @@ public class QueryRecord {
         public int getNoOfCompleteAnswers() {
                 return soundAnswerTuples.size() + gapAnswerTuples.size();
         }
-        
+
         public int getSubID() {
-                return subID; 
+                return subID;
         }
         
         public boolean hasSameGapAnswers(QueryRecord that) {
-                return gapAnswerTuples.containsAll(that.gapAnswerTuples) && that.gapAnswerTuples.containsAll(gapAnswerTuples); 
+                return gapAnswerTuples.containsAll(that.gapAnswerTuples) && that.gapAnswerTuples.containsAll(gapAnswerTuples);
         }
 
         public void dispose() {
-                m_manager.remove(queryText); 
-                if (gapAnswerTuples != null) gapAnswerTuples = null; 
-                if (soundAnswerTuples != null) soundAnswerTuples = null; 
+                m_manager.remove(queryText);
+                if(gapAnswerTuples != null) gapAnswerTuples = null;
+                if(soundAnswerTuples != null) soundAnswerTuples = null;
                 if (relevantClauses != null) relevantClauses.clear();
                 if (relevantOntology != null)
                         relevantOntology.getOWLOntologyManager().removeOntology(relevantOntology);
@@ -488,53 +478,53 @@ public class QueryRecord {
         }
 
         public boolean canBeEncodedIntoAtom() {
-                // FIXME 
-                return true; 
+                // FIXME
+                return true;
 //              return false;
         }
-        
+
         public boolean isPredicate(AnswerTuple a, int i) {
-                Atom[] atoms = getClause().getBodyAtoms(); 
-                Variable v = Variable.create(answerVariables[1][i]); 
-                String iri; 
-                for (Atom atom: atoms) { 
+                Atom[] atoms = getClause().getBodyAtoms();
+                Variable v = Variable.create(answerVariables[1][i]);
+                String iri;
+                for(Atom atom : atoms) {
                         DLPredicate p = atom.getDLPredicate();
                         if (p instanceof AtomicConcept) {
-                                if (((AtomicConcept) p).getIRI().equals(v.toString())) return true; 
+                                if(((AtomicConcept) p).getIRI().equals(v.toString())) return true;
                         }
                         else if (p instanceof AtomicRole) {
-                                iri = ((AtomicRole) p).getIRI(); 
+                                iri = ((AtomicRole) p).getIRI();
                                 if (iri.equals(v.toString())) return true;
-                                if (iri.startsWith("?")) 
-                                        iri = a.getGroundTerm(i).toString(); 
-                                if (iri.equals(Namespace.RDF_TYPE) && atom.getArgument(1).equals(v)) return true; 
+                                if(iri.startsWith("?"))
+                                        iri = a.getGroundTerm(i).toString();
+                                if(iri.equals(Namespace.RDF_TYPE) && atom.getArgument(1).equals(v)) return true;
                         }
                 }
                 return false;
         }
-        
-        public String[] getExtendedQueryText() {
-                String[] ret = new String[2]; 
-                int index = queryText.toUpperCase().indexOf(" WHERE"); 
-                String extendedSelect = queryText.substring(0, index); 
+
+        public Tuple<String> getExtendedQueryText() {
+//              String[] ret = new String[2];
+                int index = queryText.toUpperCase().indexOf(" WHERE");
+                String extendedSelect = queryText.substring(0, index);
                 String extendedWhere= queryText.substring(index + 1), fullyExtendedWhere = queryText.substring(index + 1);
-                
-                String sub, obj; 
+
+                String sub, obj;
                 Map<String, Set<String>> links = new HashMap<String, Set<String>>();
-                Set<String> list; 
+                Set<String> list;
                 for (Atom atom: getClause().getBodyAtoms())
                         if (atom.getDLPredicate() instanceof AtomicRole && atom.getArgument(0) instanceof Variable && atom.getArgument(1) instanceof Variable) {
-                                sub = atom.getArgumentVariable(0).getName(); 
+                                sub = atom.getArgumentVariable(0).getName();
                                 obj = atom.getArgumentVariable(1).getName();
-                                if ((list = links.get(sub)) == null) 
-                                        links.put(sub, list = new HashSet<String>()); 
-                                list.add(obj); 
-                                if ((list = links.get(obj)) == null) 
-                                        links.put(obj, list = new HashSet<String>()); 
-                                list.add(sub); 
+                                if((list = links.get(sub)) == null)
+                                        links.put(sub, list = new HashSet<String>());
+                                list.add(obj);
+                                if((list = links.get(obj)) == null)
+                                        links.put(obj, list = new HashSet<String>());
+                                list.add(sub);
                         }
-                
-                StringBuilder extra = new StringBuilder(), fullyExtra = new StringBuilder(); 
+
+                StringBuilder extra = new StringBuilder(), fullyExtra = new StringBuilder();
 //              if (answerVariables[0] != answerVariables[1]) {
                         for (int i = answerVariables[0].length; i < answerVariables[1].length; ++i) {
 //                      for (int i = 0; i < answerVariables[1].length; ++i) {
@@ -542,21 +532,22 @@ public class QueryRecord {
                                 if ((list = links.get(answerVariables[1][i])) == null || list.size() < 2) ;
                                 else {
                                         extra.append(" . ?").append(answerVariables[1][i]).append(" a <").append(Namespace.PAGODA_ORIGINAL).append(">");
-                                }                               
+                                }
                         }
-                        
-                        if (extra.length() > 0) {
-                                extra.append(" }"); 
+
+                if(extra.length() > 0) {
+                        extra.append(" }");
                                 extendedWhere = extendedWhere.replace(" }", extendedWhere.contains(". }") ? extra.substring(2) : extra.toString());
                         }
-                        
-                        if (fullyExtra.length() > 0) {
-                                fullyExtra.append(" }"); 
+
+                if(fullyExtra.length() > 0) {
+                        fullyExtra.append(" }");
                                 fullyExtendedWhere = fullyExtendedWhere.replace(" }", fullyExtendedWhere.contains(". }") ? fullyExtra.substring(2) : fullyExtra.toString());
                         }
 //              }
-                
-                ret[0] = extendedSelect + " " + fullyExtendedWhere; 
+
+                TupleBuilder result = new TupleBuilder();
+                result.append(extendedSelect + " " + fullyExtendedWhere);
 
                 extra.setLength(0);
                 if (answerVariables[0] != answerVariables[1]) {
@@ -564,9 +555,9 @@ public class QueryRecord {
                                 extra.append(" ?").append(answerVariables[1][i]);
                         extendedSelect = extendedSelect + extra.toString();
                 }
-                ret[1] = extendedSelect + " " + extendedWhere; 
-                
-                return ret; 
+                result.append(extendedSelect + " " + extendedWhere);
+
+                return result.build();
         }
 
         public boolean hasNonAnsDistinguishedVariables() {
@@ -574,6 +565,31 @@ public class QueryRecord {
         }
 
         /**
+         * Two <tt>QueryRecords</tt> are equal iff
+         * they have the same <tt>queryText</tt>,
+         * <tt>soundAnswerTuples</tt>
+         * and <tt>gapAnswerTuples</tt>.
+         */
+        @Override
+        public boolean equals(Object o) {
+                if(!o.getClass().equals(getClass())) return false;
+                QueryRecord that = (QueryRecord) o;
+                return this.queryText.equals(that.queryText)
+                                && soundAnswerTuples.equals(that.soundAnswerTuples)
+                                && gapAnswerTuples.equals(that.gapAnswerTuples);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(queryText, soundAnswerTuples, gapAnswerTuples);
+        }
+
+        public enum Step {
+                LowerBound, UpperBound, ELLowerBound,
+                Fragment, FragmentRefinement, Summarisation, Dependency, FullReasoning
+        }
+
+        /**
          * A Json serializer, which considers the main attributes.
          */
         public static class QueryRecordSerializer implements JsonSerializer<QueryRecord> {
@@ -592,8 +608,6 @@ public class QueryRecord {
                 }
         }
 
-        private QueryRecord() { }
-
         /**
          * A Json deserializer, compliant to the output of the serializer defined above.
          */
@@ -628,25 +642,8 @@ public class QueryRecord {
         }
 
         /**
-         * Two <tt>QueryRecords</tt> are equal iff
-         * they have the same <tt>queryText</tt>,
-         * <tt>soundAnswerTuples</tt>
-         * and <tt>gapAnswerTuples</tt>.
+         * Provides an instance (singleton) of Gson, having a specific configuration.
          * */
-        @Override
-        public boolean equals(Object o) {
-                if(!o.getClass().equals(getClass())) return false;
-                QueryRecord that = (QueryRecord) o;
-                return this.queryText.equals(that.queryText)
-                                && soundAnswerTuples.equals(that.soundAnswerTuples)
-                                && gapAnswerTuples.equals(that.gapAnswerTuples);
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(queryText, soundAnswerTuples, gapAnswerTuples);
-        }
-
         public static class GsonCreator {
 
                 private static Gson gson;