?P?? (YFOQ)

hdt-java-core/src/main/java/org/rdfhdt/hdt/quads/impl/BitmapQuadsIteratorYFOQ.java

@@ -0,0 +1,104 @@
+package org.rdfhdt.hdt.quads.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.rdfhdt.hdt.compact.bitmap.Bitmap;
+import org.rdfhdt.hdt.enums.ResultEstimationType;
+import org.rdfhdt.hdt.enums.TripleComponentOrder;
+import org.rdfhdt.hdt.triples.TripleID;
+import org.rdfhdt.hdt.triples.impl.BitmapTriples;
+import org.rdfhdt.hdt.triples.impl.BitmapTriplesIteratorYFOQ;
+import org.rdfhdt.hdt.iterator.SuppliableIteratorTripleID;
+
+public class BitmapQuadsIteratorYFOQ implements SuppliableIteratorTripleID {
+
+    private final BitmapTriplesIteratorYFOQ inIt;
+    private final List<Bitmap> bitmapGraphs;
+    private List<Long> graphs;
+    private TripleID curTriple;
+
+    public BitmapQuadsIteratorYFOQ(BitmapTriples triples, TripleID pattern) {
+        this.inIt = new BitmapTriplesIteratorYFOQ(
+            triples,
+            pattern
+        );
+        this.bitmapGraphs = triples.getQuadInfoAG();
+        this.graphs = new ArrayList<Long>();
+    }
+
+    private void updateNextTriple() {
+        if (!this.inIt.hasNext())
+            throw new RuntimeException("inIt should have next");
+        this.curTriple = this.inIt.next();
+        this.graphs = bitmapGraphs
+            .stream()
+            .parallel()
+            .filter(graph -> graph.access((int)this.inIt.posZ - 1))
+            .map(graph -> bitmapGraphs.indexOf(graph) + 1L)
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean hasNext() {
+        return this.graphs.size() > 0 || this.inIt.hasNext();
+    }
+
+    @Override
+    public TripleID next() {
+        if (graphs.isEmpty()) {
+            this.updateNextTriple();
+            return this.next();
+        }
+        long curGraph = graphs.remove(0);
+        TripleID curTriple = this.curTriple.clone();
+        curTriple.setGraph(curGraph);
+        return curTriple;
+    }
+
+    @Override
+    public void goToStart() {
+        this.inIt.goToStart();
+    }
+
+    @Override
+    public boolean hasPrevious() {
+        return this.inIt.hasPrevious();
+    }
+
+    @Override
+    public TripleID previous() {
+        return this.inIt.previous();
+    }
+
+    @Override
+    public boolean canGoTo() {
+        return this.inIt.canGoTo();
+    }
+
+    @Override
+    public void goTo(long pos) {
+        this.inIt.goTo(pos);
+    }
+
+    @Override
+    public long estimatedNumResults() {
+        return this.inIt.estimatedNumResults();
+    }
+
+    @Override
+    public ResultEstimationType numResultEstimation() {
+        return this.inIt.numResultEstimation();
+    }
+
+    @Override
+    public TripleComponentOrder getOrder() {
+        return this.inIt.getOrder();
+    }
+
+    @Override
+    public long getLastTriplePosition() {
+        return this.inIt.getLastTriplePosition();
+    }
+}

hdt-java-core/src/main/java/org/rdfhdt/hdt/triples/impl/BitmapQuadTriples.java

@@ -54,6 +54,7 @@
 import org.rdfhdt.hdt.options.HDTOptions;
 import org.rdfhdt.hdt.quads.impl.BitmapQuadsIterator;
 import org.rdfhdt.hdt.quads.impl.BitmapQuadsIteratorG;
+import org.rdfhdt.hdt.quads.impl.BitmapQuadsIteratorYFOQ;
 import org.rdfhdt.hdt.quads.impl.BitmapQuadsIteratorYGFOQ;
 import org.rdfhdt.hdt.quads.impl.BitmapQuadsIteratorZFOQ;
 import org.rdfhdt.hdt.quads.impl.BitmapQuadsIteratorZGFOQ;
@@ -276,28 +277,8 @@ public SuppliableIteratorTripleID search(TripleID pattern) {
 		TripleOrderConvert.swapComponentOrder(reorderedPat, TripleComponentOrder.SPO, order);
 		String patternString = reorderedPat.getPatternString();
 
-		if(patternString.equals("?P?")) {
-			if(this.predicateIndex!=null) {
-				return new BitmapTriplesIteratorYFOQ(this, pattern);
-			} else {
-				return new BitmapTriplesIteratorY(this, pattern);
-			}
-		}
-
-		if(indexZ!=null && bitmapIndexZ!=null) {
-			// USE FOQ
-			if(patternString.equals("?PO") || patternString.equals("??O")) {
-				return new BitmapTriplesIteratorZFOQ(this, pattern);	
-			}			
-		} else {
-			if(patternString.equals("?PO")) {
-				return new SequentialSearchIteratorTripleID(pattern, new BitmapTriplesIteratorZ(this, pattern));
-			}
-
-			if(patternString.equals("??O")) {
-				return new BitmapTriplesIteratorZ(this, pattern);
-			}
-		}
+		if (patternString.equals("?P??"))
+			return new BitmapQuadsIteratorYFOQ(this, pattern);
 
 		if(patternString.equals("?P?G"))
 			return new BitmapQuadsIteratorYGFOQ(this, pattern);