JENA-860 : addInto to also copy prefixes. Reformat.
Project: http://git-wip-us.apache.org/repos/asf/jena/repo Commit: http://git-wip-us.apache.org/repos/asf/jena/commit/508c3911 Tree: http://git-wip-us.apache.org/repos/asf/jena/tree/508c3911 Diff: http://git-wip-us.apache.org/repos/asf/jena/diff/508c3911 Branch: refs/heads/master Commit: 508c39112c8859aa074ae87a88a5e31e82bb15ab Parents: 74fbde4 Author: Andy Seaborne <[email protected]> Authored: Thu Jan 22 19:14:56 2015 +0000 Committer: Andy Seaborne <[email protected]> Committed: Thu Jan 22 19:14:56 2015 +0000 ---------------------------------------------------------------------- .../java/com/hp/hpl/jena/graph/GraphUtil.java | 129 ++++++++----------- 1 file changed, 51 insertions(+), 78 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/jena/blob/508c3911/jena-core/src/main/java/com/hp/hpl/jena/graph/GraphUtil.java ---------------------------------------------------------------------- diff --git a/jena-core/src/main/java/com/hp/hpl/jena/graph/GraphUtil.java b/jena-core/src/main/java/com/hp/hpl/jena/graph/GraphUtil.java index e96cfa4..58b503d 100644 --- a/jena-core/src/main/java/com/hp/hpl/jena/graph/GraphUtil.java +++ b/jena-core/src/main/java/com/hp/hpl/jena/graph/GraphUtil.java @@ -68,8 +68,7 @@ public class GraphUtil * @param o Object - may be Node.ANY * @return ExtendedIterator */ - public static ExtendedIterator<Node> listSubjects(Graph g, Node p, Node o) - { + public static ExtendedIterator<Node> listSubjects(Graph g, Node p, Node o) { // Restore a minimal QueryHandler? ExtendedIterator<Triple> iter = g.find(Node.ANY, p, o) ; Set<Node> nodes = iter.mapWith(mapSubject).toSet() ; @@ -83,8 +82,7 @@ public class GraphUtil * @param o Object - may be Node.ANY * @return ExtendedIterator */ - public static ExtendedIterator<Node> listPredicates(Graph g, Node s, Node o) - { + public static ExtendedIterator<Node> listPredicates(Graph g, Node s, Node o) { ExtendedIterator<Triple> iter = g.find(s,Node.ANY, o) ; Set<Node> nodes = iter.mapWith(mapPredicate).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; @@ -97,16 +95,14 @@ public class GraphUtil * @param p Predicate - may be Node.ANY * @return ExtendedIterator */ - public static ExtendedIterator<Node> listObjects(Graph g, Node s, Node p) - { + public static ExtendedIterator<Node> listObjects(Graph g, Node s, Node p) { ExtendedIterator<Triple> iter = g.find(s, p, Node.ANY) ; Set<Node> nodes = iter.mapWith(mapObject).toSet() ; return WrappedIterator.createNoRemove(nodes.iterator()) ; } /** Does the graph use the node anywhere as a subject, predciate or object? */ - public static boolean containsNode(Graph graph, Node node) - { + public static boolean containsNode(Graph graph, Node node) { return graph.contains(node, Node.ANY, Node.ANY) || graph.contains(Node.ANY, Node.ANY, node) || @@ -123,13 +119,11 @@ public class GraphUtil * the graph from which to extract triples * @return an iterator over all the graph's triples */ - public static ExtendedIterator<Triple> findAll(Graph g) - { + public static ExtendedIterator<Triple> findAll(Graph g) { return g.find(Triple.ANY) ; } - public static void add(Graph graph, Triple[] triples) - { + public static void add(Graph graph, Triple[] triples) { if ( OldStyle && graph instanceof GraphWithPerform ) { GraphWithPerform g = (GraphWithPerform)graph ; @@ -144,8 +138,7 @@ public class GraphUtil } } - public static void add(Graph graph, List<Triple> triples) - { + public static void add(Graph graph, List<Triple> triples) { if ( OldStyle && graph instanceof GraphWithPerform ) { GraphWithPerform g = (GraphWithPerform)graph ; @@ -159,8 +152,7 @@ public class GraphUtil } } - public static void add(Graph graph, Iterator<Triple> it) - { + public static void add(Graph graph, Iterator<Triple> it) { // Materialize to avoid ConcurrentModificationException. List<Triple> s = IteratorCollection.iteratorToList(it) ; if ( OldStyle && graph instanceof GraphWithPerform ) @@ -178,14 +170,13 @@ public class GraphUtil } /** Add triples into the destination (arg 1) from the source (arg 2)*/ - public static void addInto(Graph dstGraph, Graph srcGraph ) - { + public static void addInto(Graph dstGraph, Graph srcGraph ) { + dstGraph.getPrefixMapping().setNsPrefixes(srcGraph.getPrefixMapping()) ; addIteratorWorker(dstGraph, GraphUtil.findAll( srcGraph )); dstGraph.getEventManager().notifyAddGraph( dstGraph, srcGraph ); } - private static void addIteratorWorker( Graph graph, Iterator<Triple> it ) - { + private static void addIteratorWorker( Graph graph, Iterator<Triple> it ) { List<Triple> s = IteratorCollection.iteratorToList( it ); if ( OldStyle && graph instanceof GraphWithPerform ) { @@ -200,35 +191,28 @@ public class GraphUtil } } - public static void delete(Graph graph, Triple[] triples) - { - if ( OldStyle && graph instanceof GraphWithPerform ) - { + public static void delete(Graph graph, Triple[] triples) { + if ( OldStyle && graph instanceof GraphWithPerform ) { GraphWithPerform g = (GraphWithPerform)graph ; - for (Triple t : triples ) + for ( Triple t : triples ) g.performDelete(t) ; graph.getEventManager().notifyDeleteArray(graph, triples) ; - } - else - { - for (Triple t : triples ) - graph.delete(t) ; + } else { + for ( Triple t : triples ) + graph.delete(t) ; } } public static void delete(Graph graph, List<Triple> triples) - { - if ( OldStyle && graph instanceof GraphWithPerform ) - { + { + if ( OldStyle && graph instanceof GraphWithPerform ) { GraphWithPerform g = (GraphWithPerform)graph ; - for (Triple t : triples ) + for ( Triple t : triples ) g.performDelete(t) ; graph.getEventManager().notifyDeleteList(graph, triples) ; - } - else - { - for (Triple t : triples ) - graph.delete(t) ; + } else { + for ( Triple t : triples ) + graph.delete(t) ; } } @@ -236,75 +220,64 @@ public class GraphUtil { // Materialize to avoid ConcurrentModificationException. List<Triple> s = IteratorCollection.iteratorToList(it) ; - if ( OldStyle && graph instanceof GraphWithPerform ) - { + if ( OldStyle && graph instanceof GraphWithPerform ) { GraphWithPerform g = (GraphWithPerform)graph ; - for (Triple t : s) + for ( Triple t : s ) g.performDelete(t) ; graph.getEventManager().notifyDeleteIterator(graph, s) ; - } - else - { - for (Triple t : s) + } else { + for ( Triple t : s ) graph.delete(t) ; } } /** Delete triples the destination (arg 1) as given in the source (arg 2) */ - public static void deleteFrom(Graph dstGraph, Graph srcGraph) - { - deleteIteratorWorker(dstGraph, GraphUtil.findAll( srcGraph )); - dstGraph.getEventManager().notifyDeleteGraph( dstGraph, srcGraph ); + public static void deleteFrom(Graph dstGraph, Graph srcGraph) { + deleteIteratorWorker(dstGraph, GraphUtil.findAll(srcGraph)) ; + dstGraph.getEventManager().notifyDeleteGraph(dstGraph, srcGraph) ; } - - private static void deleteIteratorWorker( Graph graph, Iterator<Triple> it ) - { - List<Triple> s = IteratorCollection.iteratorToList( it ); - if ( OldStyle && graph instanceof GraphWithPerform ) - { + + private static void deleteIteratorWorker(Graph graph, Iterator<Triple> it) { + List<Triple> s = IteratorCollection.iteratorToList(it) ; + if ( OldStyle && graph instanceof GraphWithPerform ) { GraphWithPerform g = (GraphWithPerform)graph ; - for (Triple t : s ) + for ( Triple t : s ) g.performDelete(t) ; - } - else - { - for (Triple t : s ) + } else { + for ( Triple t : s ) graph.delete(t) ; } } - + private static final int sliceSize = 1000 ; /** A safe and cautious remve() function. * To avoid any possible ConcurrentModificationExceptions, * it finds batches of triples, deletes them and tries again until * no change occurs. */ - public static void remove(Graph g, Node s, Node p, Node o) - { + public static void remove(Graph g, Node s, Node p, Node o) { // Beware of ConcurrentModificationExceptions. // Delete in batches. - // That way, there is no active iterator when a delete + // That way, there is no active iterator when a delete // from the indexes happens. - + Triple[] array = new Triple[sliceSize] ; - - while (true) - { + + while (true) { // Convert/cache s,p,o? - // The Node Cache will catch these so don't worry unduely. - ExtendedIterator<Triple> iter = g.find(s,p,o) ; - + // The Node Cache will catch these so don't worry unduely. + ExtendedIterator<Triple> iter = g.find(s, p, o) ; + // Get a slice int len = 0 ; - for ( ; len < sliceSize ; len++ ) - { - if ( !iter.hasNext() ) break ; + for ( ; len < sliceSize ; len++ ) { + if ( !iter.hasNext() ) + break ; array[len] = iter.next() ; } - + // Delete them. - for ( int i = 0 ; i < len ; i++ ) - { + for ( int i = 0 ; i < len ; i++ ) { g.delete(array[i]) ; array[i] = null ; }
