@Override public void add(TriplePath triplePath, V targetState, V sourceState) { Multimap<Node, TriplePath> nodeToPath = getOrCreateStateInfo(targetState); Node node = triplePath.getObject(); nodeToPath.put(node, triplePath); }
public static void addVarsFromTriplePath(Collection<Var> acc, TriplePath tpath) { addVar(acc, tpath.getSubject()); addVar(acc, tpath.getObject()); }
public static QueryIterator execTriplePath(Binding binding, TriplePath triplePath, ExecutionContext execCxt) { if ( triplePath.isTriple() ) { // Fake it. This happens only for API constructed situations. Path path = new P_Link(triplePath.getPredicate()); triplePath = new TriplePath(triplePath.getSubject(), path, triplePath.getObject()); } return execTriplePath(binding, triplePath.getSubject(), triplePath.getPath(), triplePath.getObject(), execCxt) ; }
public PathBlock reduce(TriplePath triplePath) { PathBlock x = new PathBlock() ; reduce(x, varAlloc, triplePath.getSubject(), triplePath.getPath(), triplePath.getObject()) ; return x ; }
@Override public Op transform(OpPath opPath) { TriplePath tp = opPath.getTriplePath() ; Op op = transformPath(opPath, tp.getSubject(), tp.getPath(), tp.getObject() ) ; // And combine adjacent triple patterns. return op ; }
@Override public void visit(OpPath opPath) { addVar(subjAcc, opPath.getTriplePath().getSubject()) ; addVar(objAcc, opPath.getTriplePath().getObject()) ; }
@Override public void visit(OpPath opPath) { addVar(acc, opPath.getTriplePath().getSubject()) ; addVar(acc, opPath.getTriplePath().getObject()) ; }
void reduce(PathBlock x, PathBlock pathBlock, VarAlloc varAlloc ) { for ( TriplePath tp : pathBlock ) { if ( tp.isTriple() ) { x.add(tp) ; continue ; } reduce(x, varAlloc, tp.getSubject(), tp.getPath(), tp.getObject()) ; } }
public static boolean triplePathIso(TriplePath tp1, TriplePath tp2, NodeIsomorphismMap isoMap) { if ( tp1.isTriple() ^ tp2.isTriple() ) return false ; if ( tp1.isTriple() ) return Iso.tripleIso(tp1.asTriple(), tp2.asTriple(), isoMap) ; else return Iso.nodeIso(tp1.getSubject(), tp2.getSubject(), isoMap) && Iso.nodeIso(tp1.getObject(), tp2.getObject(), isoMap) && tp1.getPath().equalTo(tp2.getPath(), isoMap) ; }
public static TriplePath substitute(TriplePath triplePath, Binding binding) { if ( triplePath.isTriple() ) return new TriplePath(Substitute.substitute(triplePath.asTriple(), binding)); Node s = triplePath.getSubject(); Node o = triplePath.getObject(); Node s1 = substitute(s, binding); Node o1 = substitute(o, binding); TriplePath tp = triplePath; if ( s1 != s || o1 != o ) tp = new TriplePath(s1, triplePath.getPath(), o1); return tp; }
/** * Rewrite a triple path. * @param t The triple path to rewrite. * @return the triple path after rewriting. */ protected final TriplePath rewrite(TriplePath t) { if (t.getPath() == null) { return new TriplePath(new Triple(changeNode(t.getSubject()), changeNode(t.getPredicate()), changeNode(t.getObject()))); } else { PathRewriter transform = new PathRewriter(values); t.getPath().visit(transform); return new TriplePath(changeNode(t.getSubject()), transform.getResult(), changeNode(t.getObject())); } }
/** * Rewrite a triple path. * @param t The triple path to rewrite. * @return the triple path after rewriting. */ protected final TriplePath rewrite(TriplePath t) { if (t.getPath() == null) { return new TriplePath(new Triple(changeNode(t.getSubject()), changeNode(t.getPredicate()), changeNode(t.getObject()))); } else { PathRewriter transform = new PathRewriter(values); t.getPath().visit(transform); return new TriplePath(changeNode(t.getSubject()), transform.getResult(), changeNode(t.getObject())); } }
public static void outputPlain(IndentedWriter out, TriplePath tp, SerializationContext naming) { boolean oneLiner = oneLiner(tp.getPath()) ; if ( oneLiner ) { WriterNode.output(out, tp.getSubject(), naming) ; out.print(" ") ; WriterPath.output(out, tp.getPath(), naming) ; out.print(" ") ; WriterNode.output(out, tp.getObject(), naming) ; } else { nl(out, false); WriterNode.output(out, tp.getSubject(), naming) ; nl(out); WriterPath.output(out, tp.getPath(), naming) ; nl(out); WriterNode.output(out, tp.getObject(), naming) ; } }
private TriplePath transform(TriplePath path) { Node s = path.getSubject() ; Node s1 = transform(s) ; Node o = path.getObject() ; Node o1 = transform(o) ; if ( path.isTriple() ) { Node p = path.getPredicate() ; Node p1 = transform(p) ; if ( s == s1 && p == p1 && o == o1 ) return path ; return new TriplePath(Triple.create(s1, p1, o1)) ; } if ( s == s1 && o == o1 ) return path ; return new TriplePath(s1, path.getPath(), o1) ; }
private TriplePath transform(TriplePath path) { Node s = path.getSubject() ; Node s1 = transform(s) ; Node o = path.getObject() ; Node o1 = transform(o) ; if ( path.isTriple() ) { Node p = path.getPredicate() ; Node p1 = transform(p) ; if ( s == s1 && p == p1 && o == o1 ) return path ; return new TriplePath(Triple.create(s1, p1, o1)) ; } if ( s == s1 && o == o1 ) return path ; return new TriplePath(s1, path.getPath(), o1) ; }
@Override public Op transform(OpPath opPath) { TriplePath tp = opPath.getTriplePath(); Node s = tp.getSubject(); Node s1 = transform.apply(s); Node o = tp.getObject(); Node o1 = transform.apply(o); if ( s1 == s && o1 == o ) // No change. return super.transform(opPath); Path path = tp.getPath(); TriplePath tp2; if ( path != null ) tp2 = new TriplePath(s1, path, o1); else { Triple t = new Triple(s1, tp.getPredicate(), o1); tp2 = new TriplePath(t); } return new OpPath(tp2); }
PathWriter.write(out, tp.getPath(), context.getPrologue()); out.print(" "); printObject(tp.getObject()); first = false;