private static BasicPattern tripleNode(BasicPattern pattern) { List<Triple> triples = new ArrayList<>(); for (Triple triple: pattern){ triples.add( tripleNode(triple) ); } return BasicPattern.wrap(triples); }
private static BasicPattern substitute(BasicPattern pattern , Binding binding) { List<Triple> triples = new ArrayList<>(); for (Triple triple: pattern){ triples.add( substitute(triple,binding) ); } return BasicPattern.wrap(triples); }
public static BasicPattern deduplicate(BasicPattern pattern) { return BasicPattern.wrap(new ArrayList<>(new LinkedHashSet<>(pattern.getList()))); }
public static BasicPattern deduplicate(BasicPattern pattern) { return BasicPattern.wrap(new ArrayList<>(new LinkedHashSet<>(pattern.getList()))); }
/** * Add a triple to the construct statement. * @param t The triple to add. */ public void addConstruct(Triple t) { constructs.add(t); query.setConstructTemplate(new Template(BasicPattern.wrap(constructs))); }
/** * Add all the construct handlers from the handler argument to this construct. * @param handler The construct handler to copy from. */ public void addAll(ConstructHandler handler) { constructs.addAll(handler.constructs); query.setConstructTemplate(new Template(BasicPattern.wrap(constructs))); }
/** * Add a triple to the construct statement. * @param t The triple to add. */ public void addConstruct(Triple t) { constructs.add(t); query.setConstructTemplate(new Template(BasicPattern.wrap(constructs))); }
/** * Add all the construct handlers from the handler argument to this construct. * @param handler The construct handler to copy from. */ public void addAll(ConstructHandler handler) { constructs.addAll(handler.constructs); query.setConstructTemplate(new Template(BasicPattern.wrap(constructs))); }
private Collection<BasicPattern> sort(BasicPattern pattern) { HashMap<Node, BasicPattern> map = new HashMap<>(); for (Triple triple : pattern.getList()) { Node subject = triple.getSubject(); if (!map.containsKey(subject)) { List<Triple> triples = new ArrayList<>(); BasicPattern p = BasicPattern.wrap(triples); map.put(subject, p); p.add(triple); } else { map.get(subject).add(triple); } } return map.values(); }
private BasicPattern rewrite(BasicPattern pattern) { return BasicPattern.wrap(rewrite(pattern.getList())); }
@Override public void setVars(Map<Var, Node> values) { if (values.isEmpty()) { return; } AbstractRewriter<Node> rw = new AbstractRewriter<Node>(values) { }; query.setConstructTemplate(new Template(BasicPattern.wrap(rw .rewrite(constructs)))); }
private BasicPattern rewrite(BasicPattern pattern) { return BasicPattern.wrap(rewrite(pattern.getList())); }
@Override public void setVars(Map<Var, Node> values) { if (values.isEmpty()) { return; } AbstractRewriter<Node> rw = new AbstractRewriter<Node>(values) { }; query.setConstructTemplate(new Template(BasicPattern.wrap(rw .rewrite(constructs)))); }
/** * Deprecated, because with the construct approach we cannot get a tripe's context resource * * @param concepts * @param filter * @return */ @Deprecated public static Query createQueryConstruct(List<Concept> concepts, Concept filter) { Template template = new Template(BasicPattern.wrap(Collections.singletonList(Triples.spo))); List<Concept> tmps = new ArrayList<Concept>(); for(Concept concept : concepts) { Concept tmp = ConceptOps.intersect(concept, filter, null); tmps.add(tmp); } List<Element> elements = new ArrayList<Element>(); for(Concept concept : tmps) { Element e = concept.getElement(); elements.add(e); } Element element = ElementUtils.union(elements); Query result = new Query(); result.setQueryConstructType(); result.setConstructTemplate(template); result.setQueryPattern(element); return result; }
new OpBGP(BasicPattern.wrap(newBGP)));
createQueryBackward(model, concept.getVar(), VocabPath.start, result); BasicPattern bgp = BasicPattern.wrap(new ArrayList<Triple>(result)); ElementTriplesBlock triplesBlock = new ElementTriplesBlock(bgp);
BasicPattern bgp = BasicPattern.wrap(new ArrayList<Triple>(result)); ElementTriplesBlock triplesBlock = new ElementTriplesBlock(bgp);
BasicPattern bgp = BasicPattern.wrap(new ArrayList<Triple>(result)); ElementTriplesBlock triplesBlock = new ElementTriplesBlock(bgp);
@Test public void testBGPNoReadAccess() { SecurityEvaluator securityEvaluator = new MockSecurityEvaluator(true, true, false, true, true, true); rewriter = new OpRewriter(securityEvaluator, "http://example.com/dummy"); Triple[] triples = { new Triple(NodeFactory.createVariable("foo"), RDF.type.asNode(), NodeFactory.createURI("http://example.com/class")), new Triple(NodeFactory.createVariable("foo"), NodeFactory.createBlankNode(), NodeFactory.createVariable("bar")), new Triple(NodeFactory.createVariable("bar"), NodeFactory.createBlankNode(), NodeFactory.createVariable("baz")), }; try { rewriter.visit(new OpBGP(BasicPattern.wrap(Arrays.asList(triples)))); Assert.fail("Should have thrown AccessDeniedException"); } catch (ReadDeniedException e) { // expected } }
rewriter = new OpRewriter(securityEvaluator, "http://example.com/dummy"); rewriter.visit(new OpBGP(BasicPattern.wrap(Arrays.asList(triples)))); Op op = rewriter.getResult(); Assert.assertTrue("Should have been an OpFilter",