private static ITripleTransformation newNodeReplacer(Map<Node,Node> replacements, boolean resolvable) { Map<Node,Node> targetReplacements=replacements; if(resolvable) { targetReplacements=compact(replacements); } return newNodeReplacer(targetReplacements); } private static void trace(String format, Object... args) {
private static Node resolve(int i, Node node, Map<Node, Node> original, Set<Node> rewrites, Map<Node, Node> compacted) { Node newNode=original.get(node); if(rewrites.contains(newNode)) { Node tmp=compacted.get(newNode); if(tmp==null) { String prefix=indent(i); trace("%s+ Resolving rewrite '%s' for node '%s'...",prefix,newNode,node); tmp=resolve(i+1,newNode,original,rewrites,compacted); trace("%s+ Rewrite '%s' resolved to '%s'",prefix,newNode,tmp); compacted.put(newNode, tmp); } newNode=tmp; } return newNode; }
@Override public String toString() { return RDFOperations.toString(Collections.unmodifiableSortedSet(triples)); }
public static <T extends Iterable<Triple>> InmutableTripleSet replace(T triples, Map<Node,Node> replacements) { Objects.requireNonNull(replacements,NEW_NODE_PARAM); return transform(triples, newNodeReplacer(replacements,true)); }
public InmutableTripleSet(Triple...triples) { this.triples = RDFOperations.toTripleSet(triples); }
private static Map<Node, Node> compact(Map<Node, Node> replacements) { Set<Node> nodes=replacements.keySet(); Collection<Node> values=replacements.values(); Set<Node> rewrites=new HashSet<Node>(nodes); rewrites.retainAll(values); trace("- Replacements...: "+replacements); trace("- Rewriting nodes: "+rewrites); Map<Node, Node> result=new HashMap<Node,Node>(); for(Node node:nodes) { trace("- Compacting '%s'...",node); Node newNode=resolve(1,node, replacements, rewrites, result); trace("- Compacted '%s' to '%s' from '%s'...",node,newNode,replacements.get(node)); result.put(node, newNode); } return result; }
@Test public void testReplace() throws Exception { Map<Node,Node> replacements=new HashMap<Node, Node>(); replacements.put(i1, blankNode()); replacements.put(i2, uriRef(DATA+"ind2")); System.out.println("After replacing ("+replacements+"):"); System.out.println(replace(sut,replacements)); } @Test
public InmutableTripleSet add(Triple... triples) { if(triples==null) { return this; } return new InmutableTripleSet(RDFOperations.union(this.triples,triples)); }
public <T extends Iterable<Triple>> InmutableTripleSet(T triples) { this.triples = RDFOperations.toTripleSet(triples); }
public static <T extends Iterable<Triple>> InmutableTripleSet replace(T triples, Node oldNode, Node newNode) { Objects.requireNonNull(oldNode,OLD_NODE_PARAM); Objects.requireNonNull(newNode,NEW_NODE_PARAM); return transform(triples, newNodeReplacer(oldNode,newNode)); }
@Test public void testSerialize() throws Exception { InmutableTripleSet toSerialize=replace(sut,i1,uriRef("resources/defects/1")).add(complexLiterals); Namespaces namespaces = new Namespaces(). addPrefix("ex", VOCABULARY). addPrefix("rdf", RDF). addPrefix("xsd", XSD); URI baseURI = URI.create(DATA); Format format = Format.TURTLE; String serialization = serialize(toSerialize, baseURI, namespaces, format); System.out.println("Serialization :"); System.out.println(serialization); InmutableTripleSet parse = deserialize(serialization,baseURI.resolve("new"),format); System.out.println("Deserialization:"); System.out.println(parse); }
public <T extends ITripleSet> InmutableTripleSet add(T triples) { if(triples==null) { return this; } return new InmutableTripleSet(RDFOperations.union(this.triples,triples)); }
public static <T extends Iterable<Triple>> TripleSet union(T original, Triple... triples) { TripleSet result=toTripleSet(original); result.add(triples); return result; }
public static TripleSet union(Triple[] original, Triple... triples) { TripleSet result=toTripleSet(original); result.add(triples); return result; }
public static <T extends Iterable<Triple>> TripleSet union(Triple[] original, T triples) { TripleSet result=toTripleSet(original); result.add(triples); return result; }
public static <T extends Iterable<Triple>, S extends Iterable<Triple>> TripleSet union(T original, S triples) { TripleSet result = toTripleSet(original); result.add(triples); return result; }
public <T extends Iterable<Triple>> InmutableTripleSet remove(T triples) { Objects.requireNonNull(triples, TRIPLES_PARAM); TripleSet result = RDFOperations.toTripleSet(this.triples); result.remove(triples); return new InmutableTripleSet(result); }
public InmutableTripleSet remove(Triple... triples) { Objects.requireNonNull(triples, TRIPLES_PARAM); TripleSet result = RDFOperations.toTripleSet(this.triples); result.remove(triples); return new InmutableTripleSet(result); }