Refine search
@Override protected Node[] createNodes(Quad tuple) { return new Node[] { tuple.getGraph(), tuple.getSubject(), tuple.getPredicate(), tuple.getObject() }; }
public Quad createQuad(Node o) { Node g = quad.getGraph(); Node s = quad.getSubject(); Node p = quad.getPredicate(); Quad result = new Quad(g, s, p, o); return result; }
/** * Map quads to a different graph if they are in the default graph. */ public static List<Quad> remapDefaultGraph(List<Quad> quads, final Node dftGraph) { // The fast path is "no change" if ( quads == null || quads.isEmpty() ) return quads ; if ( dftGraph == null || Quad.isDefaultGraph(dftGraph) ) return quads ; Stream<Quad> remappedStream = quads.stream().map(q-> !q.isDefaultGraph() ? q : new Quad(dftGraph, q.getSubject(), q.getPredicate(), q.getObject()) ) ; return remappedStream.collect(Collectors.toList()); }
@Override protected Node[] createNodes(Quad tuple) { return new Node[] { tuple.getGraph(), tuple.getSubject(), tuple.getPredicate(), tuple.getObject() }; }
@Override public void quad(Quad quad) { if ( quad.isTriple() ) dsg.add(Quad.defaultGraphNodeGenerated, quad.getSubject(), quad.getPredicate(), quad.getObject()) ; else dsg.add(quad) ; }
public static Node[] quadToArray(Quad quad) { return new Node[] { quad.getGraph(), quad.getSubject(), quad.getPredicate(), quad.getObject() }; }
@Override public void delete(Quad arg0) { getGraphFor(arg0).delete(new Triple(arg0.getSubject(), arg0.getPredicate(), arg0.getObject())); }
@Override public void add(Quad quad) { store.computeIfAbsent(quad.getGraph(), g -> new LinkedHashMap<>()) .computeIfAbsent(quad.getSubject(), s -> new LinkedHashMap<>()) .computeIfAbsent(quad.getPredicate(), p -> new LinkedHashMap<>()) .computeIfAbsent(quad.getObject(), o -> quad); }
@Override public void add(Quad arg0) { getGraphFor(arg0).add(new Triple(arg0.getSubject(), arg0.getPredicate(), arg0.getObject())); }
public static List<Node> quadToList(Quad quad) { List<Node> result = new ArrayList<Node>(); result.add(quad.getGraph()); result.add(quad.getSubject()); result.add(quad.getPredicate()); result.add(quad.getObject()); return result; }
@Override public void quad(Quad quad) { triple.setAll( JenaNodeFormatter.format(quad.getSubject()), JenaNodeFormatter.format(quad.getPredicate()), JenaNodeFormatter.format(quad.getObject())); callback.processTriple(triple, 0); }
@Override public void delete(Quad quad) { Map<Node, Map<Node, Map<Node, Quad>>> sm = store.getOrDefault(quad.getGraph(), Collections.emptyMap()); Map<Node, Map<Node, Quad>> pm = sm.getOrDefault(quad.getSubject(), Collections.emptyMap()); Map<Node, Quad> om = pm.getOrDefault(quad.getPredicate(), Collections.emptyMap()); if(om.containsKey(quad.getObject())) { om.remove(quad.getObject()); if(om.isEmpty()) { pm.remove(quad.getPredicate()); } if(pm.isEmpty()) { sm.remove(quad.getSubject()); } if(sm.isEmpty()) { store.remove(quad.getGraph()); } } }
public static String askForQuad(Quad quad) { return "Ask { ?s ?p ?o . " + wrapFilter(compileFilter(quad.getSubject(), "?s"))+ wrapFilter(compileFilter(quad.getPredicate(), "?p")) + wrapFilter(compileFilter(quad.getObject(), "?o")) + "}"; }
public static Node getNode(Quad quad, int index) { switch (index) { case 0: return quad.getGraph(); case 1: return quad.getSubject(); case 2: return quad.getPredicate(); case 3: return quad.getObject(); default: throw new IndexOutOfBoundsException( "Index: " + index + " Size: " + 4); } }
public void addTriplesToMetadata(Quad quad){ Property p = metadataModel.createProperty(quad.getPredicate().getURI()); metadataModel.add(ResourceCommons.asRDFNode(quad.getSubject()).asResource(), p, ResourceCommons.asRDFNode(quad.getObject())); }
/** Delete a quad - return true if it was deleted, false if it didn't exist */ public boolean delete( Quad quad ) { return delete(quad.getGraph(), quad.getSubject(), quad.getPredicate(), quad.getObject()) ; }
@Test public void serialize_quad_04() throws Exception { Quad q = SSE.parseQuad("(<_:abc> <_:abc> <_:def> <_:abc>)"); Quad q1 = roundTrip(q); assertEquals(q, q1); assertEquals(q.getSubject(), q1.getObject()); assertNotEquals(q.getSubject(), q1.getPredicate()); } }
@Override protected Node[] getNodes(QuadWritable tuple) { Quad q = tuple.get(); if (q.isDefaultGraph()) { return new Node[] { q.getSubject(), q.getPredicate(), q.getObject() }; } else { return new Node[] { q.getSubject(), q.getPredicate(), q.getObject(), q.getGraph() }; } }
private static List<Tuple<Node>> tuplesQuads(Iterator<Quad> iter) { List<Tuple<Node>> tuples = new ArrayList<>() ; for ( ; iter.hasNext() ; ) { Quad q = iter.next() ; Tuple<Node> tuple = tuple(q.getGraph(), q.getSubject(), q.getPredicate(), q.getObject()) ; tuples.add(tuple) ; } return tuples ; }
/** Create an Entity from a quad. * Returns null if the quad is not a candidate for indexing. */ public static Entity entityFromQuad(EntityDefinition defn , Quad quad ) { return entityFromQuad(defn, quad.getGraph(), quad.getSubject(), quad.getPredicate(), quad.getObject()) ; }