You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2013/06/19 12:19:04 UTC

svn commit: r1494535 - in /jena/trunk/jena-arq/src: main/java/org/apache/jena/riot/lang/ main/java/org/apache/jena/riot/out/ main/java/org/apache/jena/riot/system/ test/java/org/apache/jena/riot/lang/

Author: andy
Date: Wed Jun 19 10:19:03 2013
New Revision: 1494535

URL: http://svn.apache.org/r1494535
Log:
Clean label to node allocation.

1/ Always use the parse profile blank node allocation policy.
2/ DRY - use a BlockNodeAllocators whetre possible.
3/ Tidy and reformat in passing.

Added:
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabel.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabelEncoded.java
Modified:
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocator.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorHash.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorTraditional.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LabelToNode.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangRDFJSON.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTriG.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTurtleBase.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/out/NodeToLabel.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/MapWithScope.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfile.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileBase.java
    jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileChecker.java
    jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestLabelToNode.java
    jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestNodeAllocator.java

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocator.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocator.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocator.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocator.java Wed Jun 19 10:19:03 2013
@@ -29,7 +29,7 @@ public interface BlankNodeAllocator
      */
     public Node alloc(String label) ;
     
-    /** Create a fresh blank node, different from anythign generated so far.
+    /** Create a fresh blank node, different from anything generated so far.
      *  Will not clash with a node allocated by {@linkplain #alloc}
      */
     public Node create() ;

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorHash.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorHash.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorHash.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorHash.java Wed Jun 19 10:19:03 2013
@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-package org.apache.jena.riot.lang;
+package org.apache.jena.riot.lang ;
 
 import java.security.MessageDigest ;
 import java.security.NoSuchAlgorithmException ;
@@ -32,64 +32,65 @@ import com.hp.hpl.jena.graph.Node ;
 import com.hp.hpl.jena.graph.NodeFactory ;
 import com.hp.hpl.jena.rdf.model.AnonId ;
 
-/** Allocate bnode labels using a per-run seed and the label presented.
+/**
+ * Allocate bnode labels using a per-run seed and the label presented.
  * <p>
  * This is the most scalable, always legal allocator.
  * <p>
- * New allocators must be created per parser run, or .reset() called.
- * These are fed to a digest to gve a bit string, (currently MD5, to get a 128bit bit string)
- * that is used to form a bNode AnonId of hex digits.
- * <p>  
- * In addition there is a cache of label->node allocations,
- * using the natural tendendency to locality in a database dump.
- * (subject bNodes, bNodes in lists and other datavalues structures like
- * unit values).
+ * New allocators must be created per parser run, or .reset() called. These are
+ * fed to a digest to gve a bit string, (currently MD5, to get a 128bit bit
+ * string) that is used to form a bNode AnonId of hex digits.
  * <p>
- * Not thread safe. 
+ * In addition there is a cache of label->node allocations, using the natural
+ * tendendency to locality in a database dump. (subject bNodes, bNodes in lists
+ * and other datavalues structures like unit values).
+ * <p>
+ * Not thread safe.
  */
 
-public class BlankNodeAllocatorHash implements BlankNodeAllocator
-{
-    private static String DigestAlgorithm = "MD5" ;
-    private static int CacheSize = 1000 ;
-    private MessageDigest mDigest ;
-    private byte[] seedBytes ;
-    private byte[] counterBytes = new byte[10] ;    // long+2 bytes to distinguish from UTF-8 bytes.   
+public class BlankNodeAllocatorHash implements BlankNodeAllocator {
+    private static String       DigestAlgorithm = "MD5" ;
+    private static int          CacheSize       = 1000 ;
+    private MessageDigest       mDigest ;
+    private byte[]              seedBytes ;
+    // long+2 bytes to distinguish from UTF-8 bytes.
+    private byte[]              counterBytes    = new byte[10] ; 
     private Cache<String, Node> cache ;
-    private long counter = 0 ;
-    
-    public BlankNodeAllocatorHash()
-    {
+    private long                counter         = 0 ;
+
+    public BlankNodeAllocatorHash() {
         reset() ;
-        try { mDigest = MessageDigest.getInstance(DigestAlgorithm) ; }
-        catch (NoSuchAlgorithmException e) { throw new InternalErrorException("failed to create message digest", e) ; }
-        
+        try {
+            mDigest = MessageDigest.getInstance(DigestAlgorithm) ;
+        } catch (NoSuchAlgorithmException e) {
+            throw new InternalErrorException("failed to create message digest", e) ;
+        }
+
         Getter<String, Node> getter = new Getter<String, Node>() {
-            @Override public Node get(String key) { return alloc(key) ; }
+            @Override
+            public Node get(String key) {
+                return alloc(key) ;
+            }
         } ;
         Cache<String, Node> cache1 = CacheFactory.createCache(CacheSize) ;
         cache = CacheFactory.createCacheWithGetter(cache1, getter) ;
-    }                                       
+    }
 
     @Override
-    public void reset()
-    {
+    public void reset() {
         UUID seed = UUID.randomUUID() ;
-        seedBytes = new byte[128/8] ;
+        seedBytes = new byte[128 / 8] ;
         Bytes.setLong(seed.getMostSignificantBits(), seedBytes, 0) ;
         Bytes.setLong(seed.getLeastSignificantBits(), seedBytes, 8) ;
     }
 
     @Override
-    public Node alloc(String label)
-    {
+    public Node alloc(String label) {
         return alloc(Bytes.string2bytes(label)) ;
     }
-    
-    
+
     @Override
-    public Node create()
-    {
+    public Node create() {
         counter++ ;
         // Make illegal string bytes so can't clash with alloc(String)
         counterBytes[0] = 0 ;
@@ -98,11 +99,10 @@ public class BlankNodeAllocatorHash impl
         return alloc(counterBytes) ;
     }
 
-    private Node alloc(byte[] labelBytes)
-    {
+    private Node alloc(byte[] labelBytes) {
         mDigest.update(seedBytes) ;
         mDigest.update(labelBytes) ;
-        byte[] bytes = mDigest.digest() ;   // resets
+        byte[] bytes = mDigest.digest() ; // resets
         String hexString = Bytes.asHexLC(bytes) ;
         return NodeFactory.createAnon(new AnonId(hexString)) ;
     }

Added: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabel.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabel.java?rev=1494535&view=auto
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabel.java (added)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabel.java Wed Jun 19 10:19:03 2013
@@ -0,0 +1,59 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.riot.lang;
+
+import java.util.concurrent.atomic.AtomicLong ;
+
+import org.apache.jena.riot.out.NodeToLabel ;
+
+import com.hp.hpl.jena.graph.Node ;
+import com.hp.hpl.jena.graph.NodeFactory ;
+import com.hp.hpl.jena.rdf.model.AnonId ;
+
+/** Allocate blank nodes according to the label given.
+ *  The reverse operation is {@link NodeToLabel#createBNodeByLabelAsGiven()}
+ *  but it is unsafe in general.
+ *  
+ *  Use {@linkplain BlankNodeAllocatorLabelEncoded} and {@linkplain NodeToLabel#createBNodeByLabelEncoded()}
+ *  for round-tripping output-input.
+ */
+
+public class BlankNodeAllocatorLabel implements BlankNodeAllocator
+{
+    private AtomicLong counter = new AtomicLong(0) ;
+    
+    public BlankNodeAllocatorLabel()  {}
+
+    @Override
+    public void reset()         { counter = new AtomicLong(0) ; }
+
+    @Override
+    public Node alloc(String label) { return create(label) ; }
+    
+    @Override
+    public Node create() {
+        long x = counter.getAndIncrement() ;
+        Node n = create("@" + x) ;
+        return n ;
+    }
+    
+    private Node create(String label) {
+        return NodeFactory.createAnon(new AnonId(label)) ;
+    }
+}

Added: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabelEncoded.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabelEncoded.java?rev=1494535&view=auto
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabelEncoded.java (added)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorLabelEncoded.java Wed Jun 19 10:19:03 2013
@@ -0,0 +1,55 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.jena.riot.lang ;
+
+import java.util.concurrent.atomic.AtomicLong ;
+
+import org.apache.jena.riot.SysRIOT ;
+import org.apache.jena.riot.out.NodeFmtLib ;
+import org.apache.jena.riot.out.NodeToLabel ;
+
+import com.hp.hpl.jena.graph.Node ;
+import com.hp.hpl.jena.graph.NodeFactory ;
+import com.hp.hpl.jena.rdf.model.AnonId ;
+
+/**
+ * Allocate blank nodes according to the label given. 
+ * This alloctor reconstructs labels made by
+ * {@linkplain NodeToLabel#createBNodeByLabelEncoded()}
+ */
+
+public class BlankNodeAllocatorLabelEncoded implements BlankNodeAllocator {
+    private AtomicLong counter = new AtomicLong(0) ;
+
+    public BlankNodeAllocatorLabelEncoded() {}
+
+    @Override
+    public void reset() {}
+
+    @Override
+    public Node alloc(String label) {
+        return NodeFactory.createAnon(new AnonId(NodeFmtLib.decodeBNodeLabel(label))) ;
+    }
+
+    @Override
+    public Node create() {
+        String label = SysRIOT.BNodeGenIdPrefix + (counter.getAndIncrement()) ;
+        return NodeFactory.createAnon(new AnonId(label)) ;
+    }
+}

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorTraditional.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorTraditional.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorTraditional.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/BlankNodeAllocatorTraditional.java Wed Jun 19 10:19:03 2013
@@ -24,7 +24,7 @@ import java.util.Map ;
 import com.hp.hpl.jena.graph.Node ;
 import com.hp.hpl.jena.graph.NodeFactory ;
 
-/** Allocate blank ndoes according to the traditional policy (to jena 2.10.0)
+/** Allocate blank ndoes according to the traditional policy (up to jena 2.10.0)
  *  This allocator has arbitrary sized state. 
  *  Create a fresh one for each parser run.
  */

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LabelToNode.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LabelToNode.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LabelToNode.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LabelToNode.java Wed Jun 19 10:19:03 2013
@@ -17,58 +17,97 @@
  */
 
 package org.apache.jena.riot.lang;
-import static java.lang.String.format ;
-
 import java.util.HashMap ;
 import java.util.Map ;
-import java.util.concurrent.atomic.AtomicLong ;
 
-import org.apache.jena.riot.SysRIOT ;
 import org.apache.jena.riot.out.NodeFmtLib ;
 import org.apache.jena.riot.out.NodeToLabel ;
 import org.apache.jena.riot.system.MapWithScope ;
 import org.apache.jena.riot.system.SyntaxLabels ;
 
 import com.hp.hpl.jena.graph.Node ;
-import com.hp.hpl.jena.graph.NodeFactory ;
-import com.hp.hpl.jena.rdf.model.AnonId ;
 
 /** Allocation Nodes (Bnodes usually) based on the graph and label 
  * Various different policies.
- * See {@link SyntaxLabels#createLabelToNode} for getting a default setup.
+ * See {@link SyntaxLabels#createLabelToNode} for getting a default setup; 
+ * some of the others are for testing and debugging and may not generate
+ * legal RDF overall (e.g. reparsign the same file gets the same bNodes) 
  */  
 
 public class LabelToNode extends MapWithScope<String, Node, Node>
 {
-    /** Allocation from a single scope; just the label matters. */
-    public static LabelToNode createScopeByDocument()
-    { return new LabelToNode(new SingleScopePolicy(), nodeMaker) ; }
-
+    /** Allocation from a single scope; just the label matters. 
+     *  This is the RDF syntax correct policy.
+     */
     public static LabelToNode createScopeByDocumentHash()
-    { return new LabelToNode(new AllocScopePolicy(), new AllocNodeHash()) ; }
+    { return new LabelToNode(new AllocScopePolicy(), nodeAllocatorHash()) ; }
     
+    public static LabelToNode createScopeByDocumentOld()
+    { return new LabelToNode(new SingleScopePolicy(), nodeAllocatorTraditional()) ; }
+
     /** Allocation scoped by graph and label. */
-    public static LabelToNode createScopeByGraph()
-    { return new LabelToNode(new GraphScopePolicy(), nodeMaker) ; }
+    public static LabelToNode createScopeByGraph() {
+        // Not AllocNodeHash here - that is unique per run, not per graph-in-run.
+        // Must use an unconditionally unique allocator.
+        return new LabelToNode(new GraphScopePolicy(), nodeAllocatorByGraph()) ;
+    }
 
     /** Allocation using syntax label; output is unsafe for reading (use 
      * {@link #createUseLabelEncoded()} for output-input).
-     * The reverse operation is provided by {@link NodeToLabel#createBNodeByLabelAsGiven()} */
+     * 
+     * The reverse operation is provided by {@link NodeToLabel#createBNodeByLabelAsGiven()}
+     * but the pair is <em>unsafe</em> for output-input.  Use encoded labels for that.
+     * 
+     * The main pupose of this LabelToNode is to repserve the used label for debugging. 
+     */
     public static LabelToNode createUseLabelAsGiven()
-    { return new LabelToNode(new AllocScopePolicy(), nodeMakerByLabel) ; }
+    { return new LabelToNode(new AllocScopePolicy(), nodeAllocatorRawLabel()) ; }
     
     /** Allocation using an encoded syntax label 
      * (i.e. _:B&lt;encoded&gt; format from {@link NodeFmtLib#encodeBNodeLabel}).
-     * The reverse operation is provided by {@link NodeToLabel#createBNodeByLabelEncoded()}
+     * 
+     * The reverse operation is provided by {@link NodeToLabel#createBNodeByLabelEncoded()}.
+     * This pair should be used to write out and recover blank node by internal id. 
      */
     public static LabelToNode createUseLabelEncoded()
-    { return new LabelToNode(new AllocScopePolicy(), nodeMakerByLabelEncoded) ; }
+    { return new LabelToNode(new AllocScopePolicy(), nodeAllocatorEncoded()) ; }
 
     /** Allocation, globally scoped, that uses a incrementing field to create new nodes */  
     public static LabelToNode createIncremental()
-    { return new LabelToNode(new SingleScopePolicy(), nodeMakerDeterministic) ; } 
+    { return new LabelToNode(new SingleScopePolicy(), nodeAllocatorDeterministic()) ; } 
+
+    // ---- Create fresh allocators per call
+    
+    // The preferred node allocator - completely scalable.
+    // Nodes are unique-per-run.
+    
+    private static Allocator<String, Node, Node> nodeAllocatorHash() { 
+        return new Alloc(new BlankNodeAllocatorHash()) ; 
+    } 
+    
+    private static Allocator<String, Node, Node> nodeAllocatorDeterministic() { 
+        return new Alloc(new BlankNodeAllocatorLabel()) ; 
+    } 
+    
+    private static Allocator<String, Node, Node> nodeAllocatorTraditional() { 
+        return new Alloc(new BlankNodeAllocatorTraditional()) ; 
+    } 
+    
+    private static Allocator<String, Node, Node> nodeAllocatorEncoded() { 
+        return new Alloc(new BlankNodeAllocatorLabelEncoded()) ; 
+    } 
+    
+    private static Allocator<String, Node, Node> nodeAllocatorRawLabel() { 
+        return new Alloc(new BlankNodeAllocatorLabel()) ; 
+    } 
+
+    private static Allocator<String, Node, Node> nodeAllocatorByGraph() { 
+        return new AllocByGraph() ;
+    } 
+
+    // ---- The class
     
-    public LabelToNode(ScopePolicy<String, Node, Node> scopePolicy, Allocator<String, Node> allocator)
+    public LabelToNode(ScopePolicy<String, Node, Node> scopePolicy, Allocator<String, Node, Node> allocator)
     {
         super(scopePolicy, allocator) ;
     }
@@ -86,7 +125,7 @@ public class LabelToNode extends MapWith
     }
     
     /** One scope for labels per graph */
-    private static class GraphScopePolicy  implements ScopePolicy<String, Node, Node>
+    private static class GraphScopePolicy implements ScopePolicy<String, Node, Node>
     { 
         private Map<String, Node> dftMap = new HashMap<String, Node>() ;
         private Map<Node, Map<String, Node>> map = new HashMap<Node, Map<String, Node>>() ;
@@ -121,85 +160,123 @@ public class LabelToNode extends MapWith
 
     
     // ======== Node Allocators
+    // Adapter class from  MapWithScope.Allocator to BlankNodeAllocator
+    // This does not take scope into account when creating nodes.
     
-    // TODO Switch to BlankNodeAllocator and a singel wrapper.
-    // variables if the allocator is reusable across runs
-    // classes if a new one is needed each time.
-    // Shared ones must be thread-safe.
-    
-
-    /** Allocate bnode labels using a per-run see and the label presented.
-     *  This is the most scalable, always legal allocator.
-     *  Not thread safe - not reusable.
-     *  Create a new allocator for each parser run. 
-     */  
-    private static class AllocNodeHash implements Allocator<String, Node> {
-        private BlankNodeAllocator alloc = new BlankNodeAllocatorHash() ;
+    private static class Alloc implements Allocator<String, Node, Node> {
+        final BlankNodeAllocator alloc ;
         
-        @Override public Node alloc(String label)   { return alloc.alloc(label) ; }
-        @Override public Node create()              { return alloc.create() ; }
-        @Override public void reset()               { alloc.reset() ; }
-    } ;
-    
-    private static Allocator<String, Node> nodeMaker = new Allocator<String, Node>()
-    {
-        @Override public Node alloc(String label)       { return create() ;}
-
-        @Override public Node create()                  { return NodeFactory.createAnon() ; }
-
-        @Override public void reset()                   {}
-    } ;
-
-    private static Allocator<String, Node> nodeMakerDeterministic = new Allocator<String, Node>()
-    {
-        private AtomicLong counter = new AtomicLong(0) ;
-
-        @Override
-        public Node alloc(String label)
-        {
-            return create() ;
-        }
+        Alloc(BlankNodeAllocator alloc)     { this.alloc = alloc ; }
         
-        @Override public Node create()
-        {
-            String $ = format("B0x%04X", counter.incrementAndGet()) ;
-            return NodeFactory.createAnon(new AnonId($)) ;
-        }
+        @Override
+        public Node alloc(Node scope, String label)     { return alloc.alloc(label) ; }
 
+        @Override
+        public Node create()                { return alloc.create() ; }
 
         @Override
-        public void reset()     {}
-    } ;
+        public void reset()                 { alloc.reset() ; }
+    }
     
-    private static Allocator<String, Node> nodeMakerByLabel = new Allocator<String, Node>()
-    {
-        private AtomicLong counter = new AtomicLong(0) ;
+    /** Allocate a fresh blank node each time. */
+    private static class AllocByGraph implements Allocator<String, Node, Node> {
+        BlankNodeAllocator dft = make() ;
+        Map<Node, BlankNodeAllocator> graphs = new HashMap<Node, BlankNodeAllocator>() ;
         
-        @Override
-        public Node alloc(String label)
-        {
-            return NodeFactory.createAnon(new AnonId(label)) ;
+        @Override public Node alloc(Node scope, String label)
+        { 
+            if ( scope == null)
+                return dft.alloc(label) ;
+            
+            BlankNodeAllocator alloc = graphs.get(scope) ;
+            if ( alloc == null ) {
+                alloc = make() ;
+                graphs.put(scope, alloc) ;
+            }
+            return alloc.alloc(label) ;
         }
-
-        @Override public Node create()      { return alloc(SysRIOT.BNodeGenIdPrefix+(counter.getAndIncrement())) ; } 
-        
-        @Override
-        public void reset()     {}
-    } ;
-    
-    private static Allocator<String, Node> nodeMakerByLabelEncoded = new Allocator<String, Node>()
-    {
-        private AtomicLong counter = new AtomicLong(0) ;
         
-        @Override
-        public Node alloc(String label)
-        {
-            return NodeFactory.createAnon(new AnonId(NodeFmtLib.decodeBNodeLabel(label))) ;
+        @Override public Node create()                  { return dft.create() ; }
+        @Override public void reset()                   
+        { 
+            graphs.clear() ;
+            dft.reset() ;
         }
-
-        @Override public Node create()      { return alloc(SysRIOT.BNodeGenIdPrefix+(counter.getAndIncrement())) ; }
-        @Override
         
-        public void reset()     {}
+        private BlankNodeAllocator make() { return new BlankNodeAllocatorHash() ; }
     } ;
+
+    
+    // TODO Switch to BlankNodeAllocator and a single wrapper.
+    // variables if the allocator is reusable across runs
+    // classes if a new one is needed each time.
+    // Shared ones must be thread-safe.
+    
+
+//    /** Allocate bnode using a per-run seed and the label presented.
+//     *  This is the most scalable, always legal allocator.
+//     *  Not thread safe - not reusable.
+//     *  Create a new allocator for each parser run. 
+//     */  
+//    private static class AllocNodeHash implements Allocator<String, Node> {
+//        private BlankNodeAllocator alloc = new BlankNodeAllocatorHash() ;
+//        
+//        @Override public Node alloc(String label)   { return alloc.alloc(label) ; }
+//        @Override public Node create()              { return alloc.create() ; }
+//        @Override public void reset()               { alloc.reset() ; }
+//    } ;
+//    
+//    
+//
+//    /** Allocate bnodes using an incremental counter - deterministic for parsing a given file */ 
+//    private static Allocator<String, Node> nodeMakerDeterministic  = new Allocator<String, Node>()
+//    {
+//        private AtomicLong counter = new AtomicLong(0) ;
+//
+//        @Override
+//        public Node alloc(Node scope, String label) {
+//            return create() ;
+//        }
+//
+//        @Override
+//        public Node create() {
+//            String $ = format("B0x%04X", counter.incrementAndGet()) ;
+//            return NodeFactory.createAnon(new AnonId($)) ;
+//        }
+//
+//        @Override
+//        public void reset()     {}
+//    } ;
+//    
+//    private static Allocator<String, Node> nodeMakerByLabel = new Allocator<String, Node>()
+//    {
+//        private AtomicLong counter = new AtomicLong(0) ;
+//        
+//        @Override
+//        public Node alloc(String label)
+//        {
+//            return NodeFactory.createAnon(new AnonId(label)) ;
+//        }
+//
+//        @Override public Node create()      { return alloc(null, SysRIOT.BNodeGenIdPrefix+(counter.getAndIncrement())) ; } 
+//        
+//        @Override
+//        public void reset()     {}
+//    } ;
+//    
+//    private static Allocator<String, Node> nodeMakerByLabelEncoded = new Allocator<String, Node>()
+//    {
+//        private AtomicLong counter = new AtomicLong(0) ;
+//        
+//        @Override
+//        public Node alloc(Node scope, String label)
+//        {
+//            return NodeFactory.createAnon(new AnonId(NodeFmtLib.decodeBNodeLabel(label))) ;
+//        }
+//
+//        @Override public Node create()      { return alloc(SysRIOT.BNodeGenIdPrefix+(counter.getAndIncrement())) ; }
+//        @Override
+//        
+//        public void reset()     {}
+//    } ;
 }

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangRDFJSON.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangRDFJSON.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangRDFJSON.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangRDFJSON.java Wed Jun 19 10:19:03 2013
@@ -412,7 +412,7 @@ public class LangRDFJSON extends LangBas
 				}
 				else
 				{
-					obj = profile.createPlainLiteral(value.getImage(), value.getLine(), value.getColumn()) ;
+					obj = profile.createStringLiteral(value.getImage(), value.getLine(), value.getColumn()) ;
 				}
 			}
 			else

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTriG.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTriG.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTriG.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTriG.java Wed Jun 19 10:19:03 2013
@@ -29,7 +29,6 @@ import org.apache.jena.riot.tokens.Token
 import org.apache.jena.riot.tokens.Tokenizer ;
 
 import com.hp.hpl.jena.graph.Node ;
-import com.hp.hpl.jena.graph.NodeFactory ;
 import com.hp.hpl.jena.sparql.core.Quad ;
 
 /** TriG language: http://www4.wiwiss.fu-berlin.de/bizer/TriG/
@@ -82,7 +81,7 @@ public class LangTriG extends LangTurtle
             if (token.getType() != TokenType.RBRACKET) 
                 exception(t, "Broken term: [ not followed by ]") ;
 
-            graphNode = NodeFactory.createAnon() ;
+            graphNode = profile.createBlankNode(graphNode, t.getLine(), t.getColumn()) ;
             nextToken() ;
         } else {
             if (token.isNode()) {

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTurtleBase.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTurtleBase.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTurtleBase.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/lang/LangTurtleBase.java Wed Jun 19 10:19:03 2013
@@ -424,8 +424,8 @@ public abstract class LangTurtleBase<X> 
     
     protected final Node triplesBlankNode()
     {
-        nextToken() ;        // Skip [
-        Node subject = NodeFactory.createAnon() ;
+        Token t = nextToken() ;        // Skip [
+        Node subject =  profile.createBlankNode(currentGraph, t.getLine(), t.getColumn()) ;
 
         if ( peekPredicate() )
             predicateObjectList(subject) ;

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/out/NodeToLabel.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/out/NodeToLabel.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/out/NodeToLabel.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/out/NodeToLabel.java Wed Jun 19 10:19:03 2013
@@ -58,7 +58,7 @@ public class NodeToLabel extends MapWith
     private static final NodeToLabel _internal = createBNodeByLabelEncoded() ;
     public static NodeToLabel labelByInternal() { return _internal ; }  
 
-    private NodeToLabel(ScopePolicy<Node, String, Node> scopePolicy, Allocator<Node, String> allocator)
+    private NodeToLabel(ScopePolicy<Node, String, Node> scopePolicy, Allocator<Node, String, Node> allocator)
     {
         super(scopePolicy, allocator) ;
     }
@@ -100,13 +100,13 @@ public class NodeToLabel extends MapWith
     // ======== Allocators 
 
     /** Allocator and some default policies. */
-    private abstract static class AllocatorBase implements Allocator<Node, String>
+    private abstract static class AllocatorBase implements Allocator<Node, String, Node>
     {
         // abstract to make you think about the policy!
         private long counter = 0 ;
         
         @Override
-        public final String alloc(Node node)
+        public final String alloc(Node scope, Node node)
         {
             if ( node.isURI() )         return labelForURI(node) ;
             if ( node.isLiteral() )     return labelForLiteral(node) ;

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/MapWithScope.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/MapWithScope.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/MapWithScope.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/MapWithScope.java Wed Jun 19 10:19:03 2013
@@ -36,12 +36,12 @@ public class MapWithScope<A, B, S>
     /** Allocate a B, given some A.
      *  Only called once per instance of B if the ScopePolicy map is non-null.
      */ 
-    public interface Allocator<A,B>
+    public interface Allocator<A,B,S>
     {
         /** Allocate - return the same B for a given A.
          * "same" means .equals, not == 
          */
-        public B alloc(A item) ;
+        public B alloc(S scope, A item) ;
         
         /** Create a fresh, unique (to within policy) B */  
         public B create() ;
@@ -50,11 +50,13 @@ public class MapWithScope<A, B, S>
     }
     
     // ======== The Object
-
+    // To be fully general, we should have an allocator per scope (and have an allocator factory).
+    // But we don't need that complexity.
+    
     private final ScopePolicy<A,B,S> scopePolicy ;
-    private final Allocator<A,B> allocator ;
+    private final Allocator<A,B,S> allocator ;
 
-    protected MapWithScope(ScopePolicy<A,B,S> scopePolicy, Allocator<A,B> allocator)
+    protected MapWithScope(ScopePolicy<A,B,S> scopePolicy, Allocator<A,B,S> allocator)
     {
         this.scopePolicy = scopePolicy ;
         this.allocator = allocator ;
@@ -69,12 +71,12 @@ public class MapWithScope<A, B, S>
         Map<A, B> map = scopePolicy.getScope(scope) ;
         if ( map == null )
             // No map - no item->allocation tracking.
-            return allocator.alloc(item) ;
+            return allocator.alloc(scope, item) ;
 
         B mappedItem = map.get(item) ;
         if ( mappedItem == null )
         {
-            mappedItem = allocator.alloc(item) ;
+            mappedItem = allocator.alloc(scope, item) ;
             map.put(item, mappedItem) ;
         }
         return mappedItem ;

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfile.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfile.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfile.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfile.java Wed Jun 19 10:19:03 2013
@@ -33,13 +33,28 @@ public interface ParserProfile
     public String resolveIRI(String uriStr, long line, long col) ;
     public IRI makeIRI(String uriStr, long line, long col) ;
     
+    /** Create a triple */
     public Triple createTriple(Node subject, Node predicate, Node object, long line, long col) ;
-    public Quad createQuad(Node graph, Node subject, Node predicate, Node object, long line, long col) ;    
+
+    /** Create a Quad */
+    public Quad createQuad(Node graph, Node subject, Node predicate, Node object, long line, long col) ;
+    
+    /** Create a URI Node */
     public Node createURI(String uriStr, long line, long col) ;
+    
+    /** Create a literal for a string+datatype */
     public Node createTypedLiteral(String lexical, RDFDatatype datatype, long line, long col) ;
+    
+    /** Create a literal for a string+language */
     public Node createLangLiteral(String lexical, String langTag, long line, long col) ;
-    public Node createPlainLiteral(String lexical, long line, long col) ;
+    
+    /** Create a literal for a string */ 
+    public Node createStringLiteral(String lexical, long line, long col) ;
+    
+    /** Create a fresh blank node based on scope and label */ 
     public Node createBlankNode(Node scope, String label, long line, long col) ;
+    /** Create a fresh blank node */ 
+    public Node createBlankNode(Node scope, long line, long col) ;
     
     /** Make a node from a token - called after all else has been tried - return null for no such node */
     public Node createNodeFromToken(Node scope, Token token, long line, long col) ;

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileBase.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileBase.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileBase.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileBase.java Wed Jun 19 10:19:03 2013
@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 
-package org.apache.jena.riot.system;
+package org.apache.jena.riot.system ;
 
 import org.apache.jena.iri.IRI ;
 import org.apache.jena.riot.RiotException ;
@@ -32,136 +32,131 @@ import com.hp.hpl.jena.graph.NodeFactory
 import com.hp.hpl.jena.graph.Triple ;
 import com.hp.hpl.jena.sparql.core.Quad ;
 
-/** Basic profile of things, with key operations based on a simple
- *  use of the parse elements into Nodes 
+/**
+ * Basic profile of things, with key operations based on a simple use of the
+ * parse elements into Nodes
  */
-public class ParserProfileBase implements ParserProfile
-{
+public class ParserProfileBase implements ParserProfile {
     protected ErrorHandler errorHandler ;
-    protected Prologue prologue ;
-    protected LabelToNode labelMapping ;
-    protected boolean strictMode = SysRIOT.strictMode ;
+    protected Prologue     prologue ;
+    protected LabelToNode  labelMapping ;
+    protected boolean      strictMode = SysRIOT.strictMode ;
 
-    public ParserProfileBase(Prologue prologue, ErrorHandler errorHandler)
-    { 
+    public ParserProfileBase(Prologue prologue, ErrorHandler errorHandler) {
         this(prologue, errorHandler, SyntaxLabels.createLabelToNode()) ;
     }
-    
-    public ParserProfileBase(Prologue prologue, ErrorHandler errorHandler, LabelToNode labelMapping)
-    {
+
+    public ParserProfileBase(Prologue prologue, ErrorHandler errorHandler, LabelToNode labelMapping) {
         this.prologue = prologue ;
-        this.errorHandler = errorHandler ; 
+        this.errorHandler = errorHandler ;
         this.labelMapping = labelMapping ;
     }
-    
+
     @Override
-    public ErrorHandler getHandler()    { return errorHandler ; }
+    public ErrorHandler getHandler() {
+        return errorHandler ;
+    }
 
     @Override
-    public void setHandler(ErrorHandler handler) { errorHandler = handler ; }
+    public void setHandler(ErrorHandler handler) {
+        errorHandler = handler ;
+    }
 
     @Override
-    public Prologue getPrologue()           { return prologue ; }      
+    public Prologue getPrologue() {
+        return prologue ;
+    }
 
     @Override
-    public void setPrologue(Prologue p)     { prologue = p ; }      
+    public void setPrologue(Prologue p) {
+        prologue = p ;
+    }
 
     @Override
-    public LabelToNode getLabelToNode()
-    { return labelMapping ; }
+    public LabelToNode getLabelToNode() {
+        return labelMapping ;
+    }
 
     @Override
-    public void setLabelToNode(LabelToNode mapper) { labelMapping = mapper ; }
+    public void setLabelToNode(LabelToNode mapper) {
+        labelMapping = mapper ;
+    }
 
     @Override
-    public String resolveIRI(String uriStr, long line, long col)
-    {
+    public String resolveIRI(String uriStr, long line, long col) {
         return prologue.getResolver().resolveToString(uriStr) ;
     }
-    
+
     @Override
-    public IRI makeIRI(String uriStr, long line, long col)
-    {
+    public IRI makeIRI(String uriStr, long line, long col) {
         return prologue.getResolver().resolve(uriStr) ;
     }
 
     @Override
-    public Quad createQuad(Node g, Node s, Node p, Node o, long line, long col)
-    {
-        return new Quad(g,s,p,o) ;
+    public Quad createQuad(Node g, Node s, Node p, Node o, long line, long col) {
+        return new Quad(g, s, p, o) ;
     }
 
     @Override
-    public Triple createTriple(Node s, Node p, Node o, long line, long col)
-    {
+    public Triple createTriple(Node s, Node p, Node o, long line, long col) {
         return new Triple(s, p, o) ;
     }
 
     @Override
-    public Node createURI(String uriStr, long line, long col)
-    {
+    public Node createURI(String uriStr, long line, long col) {
         return RiotLib.createIRIorBNode(uriStr) ;
     }
 
     @Override
-    public Node createBlankNode(Node scope, String label, long line, long col)
-    {
+    public Node createBlankNode(Node scope, String label, long line, long col) {
         return labelMapping.get(scope, label) ;
     }
 
-//    @Override
-//    public Node createTypedLiteral(String lexical, String datatype, long line, long col)
-//    {
-//        RDFDatatype dt = Node.getType(datatype) ;
-//        return createTypedLiteral(lexical, dt, line, col) ;
-//    }
-    
     @Override
-    public Node createTypedLiteral(String lexical, RDFDatatype dt, long line, long col)
-    {
-        return NodeFactory.createLiteral(lexical, null, dt)  ;
+    public Node createBlankNode(Node scope, long line, long col) {
+        return labelMapping.create() ;
     }
 
     @Override
-    public Node createLangLiteral(String lexical, String langTag, long line, long col)
-    {
-        return NodeFactory.createLiteral(lexical, langTag, null)  ;
+    public Node createTypedLiteral(String lexical, RDFDatatype dt, long line, long col) {
+        return NodeFactory.createLiteral(lexical, null, dt) ;
     }
 
     @Override
-    public Node createPlainLiteral(String lexical, long line, long col)
-    {
+    public Node createLangLiteral(String lexical, String langTag, long line, long col) {
+        return NodeFactory.createLiteral(lexical, langTag, null) ;
+    }
+
+    @Override
+    public Node createStringLiteral(String lexical, long line, long col) {
         return NodeFactory.createLiteral(lexical) ;
     }
-    
-    /** Special token forms*/ 
+
+    /** Special token forms */
     @Override
-    public Node createNodeFromToken(Node scope, Token token, long line, long col)
-    {
-        // OFF - Don't produce Node.ANY by default. 
-        if ( false && token.getType() == TokenType.KEYWORD )
-        {
-            if ( Token.ImageANY.equals(token.getImage()) )
+    public Node createNodeFromToken(Node scope, Token token, long line, long col) {
+        // OFF - Don't produce Node.ANY by default.
+        if (false && token.getType() == TokenType.KEYWORD) {
+            if (Token.ImageANY.equals(token.getImage()))
                 return Node.ANY ;
         }
         return null ;
     }
 
     @Override
-    public Node create(Node currentGraph, Token token)
-    {
+    public Node create(Node currentGraph, Token token) {
         // Dispatches to the underlying operation
         long line = token.getLine() ;
         long col = token.getColumn() ;
         String str = token.getImage() ;
-        switch(token.getType())
-        {
-            case BNODE:         return createBlankNode(currentGraph, str, line, col) ;
-            case IRI:           return createURI(str, line, col) ;
-            case PREFIXED_NAME:
-            {
+        switch (token.getType()) {
+            case BNODE :
+                return createBlankNode(currentGraph, str, line, col) ;
+            case IRI :
+                return createURI(str, line, col) ;
+            case PREFIXED_NAME : {
                 String prefix = str ;
-                String suffix   = token.getImage2() ;
+                String suffix = token.getImage2() ;
                 String expansion = expandPrefixedName(prefix, suffix, token) ;
                 return createURI(expansion, line, col) ;
             }
@@ -169,64 +164,65 @@ public class ParserProfileBase implement
                 return createTypedLiteral(str, XSDDatatype.XSDdecimal, line, col) ;
             case DOUBLE :
                 return createTypedLiteral(str, XSDDatatype.XSDdouble, line, col) ;
-            case INTEGER:
+            case INTEGER :
                 return createTypedLiteral(str, XSDDatatype.XSDinteger, line, col) ;
-            case LITERAL_DT :
-            {
+            case LITERAL_DT : {
                 Token tokenDT = token.getSubToken2() ;
                 String uriStr ;
-                
-                switch(tokenDT.getType())
-                {
-                    case IRI:               uriStr = tokenDT.getImage() ; break ;
-                    case PREFIXED_NAME:
-                    {
+
+                switch (tokenDT.getType()) {
+                    case IRI :
+                        uriStr = tokenDT.getImage() ;
+                        break ;
+                    case PREFIXED_NAME : {
                         String prefix = tokenDT.getImage() ;
                         String suffix = tokenDT.getImage2() ;
                         uriStr = expandPrefixedName(prefix, suffix, tokenDT) ;
                         break ;
                     }
-                    default:
-                        throw new RiotException("Expected IRI for datatype: "+token) ;
+                    default :
+                        throw new RiotException("Expected IRI for datatype: " + token) ;
                 }
-                
+
                 uriStr = resolveIRI(uriStr, tokenDT.getLine(), tokenDT.getColumn()) ;
                 RDFDatatype dt = NodeFactory.getType(uriStr) ;
                 return createTypedLiteral(str, dt, line, col) ;
             }
-            
-            case LITERAL_LANG : 
-                return createLangLiteral(str, token.getImage2(), line, col)  ;
-                
-            case STRING:                
-            case STRING1:
-            case STRING2:
-            case LONG_STRING1:
-            case LONG_STRING2:
-                return createPlainLiteral(str, line, col) ;
-            default: 
-            {
+
+            case LITERAL_LANG :
+                return createLangLiteral(str, token.getImage2(), line, col) ;
+
+            case STRING :
+            case STRING1 :
+            case STRING2 :
+            case LONG_STRING1 :
+            case LONG_STRING2 :
+                return createStringLiteral(str, line, col) ;
+            default : {
                 Node x = createNodeFromToken(currentGraph, token, line, col) ;
-                if ( x != null )
+                if (x != null)
                     return x ;
-                errorHandler.fatal("Not a valid token for an RDF term: "+token, line , col) ;
+                errorHandler.fatal("Not a valid token for an RDF term: " + token, line, col) ;
                 return null ;
             }
         }
     }
-    
-    private String expandPrefixedName(String prefix, String localPart, Token token)
-    {
+
+    private String expandPrefixedName(String prefix, String localPart, Token token) {
         String expansion = prologue.getPrefixMap().expand(prefix, localPart) ;
-        if ( expansion == null )
-            errorHandler.fatal("Undefined prefix: "+prefix, token.getLine(), token.getColumn()) ;
+        if (expansion == null)
+            errorHandler.fatal("Undefined prefix: " + prefix, token.getLine(), token.getColumn()) ;
         return expansion ;
     }
 
     @Override
-    public boolean isStrictMode()               { return strictMode ; }
+    public boolean isStrictMode() {
+        return strictMode ;
+    }
 
     @Override
-    public void    setStrictMode(boolean mode)  { strictMode = mode ; }
+    public void setStrictMode(boolean mode) {
+        strictMode = mode ;
+    }
 
 }

Modified: jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileChecker.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileChecker.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileChecker.java (original)
+++ jena/trunk/jena-arq/src/main/java/org/apache/jena/riot/system/ParserProfileChecker.java Wed Jun 19 10:19:03 2013
@@ -151,7 +151,7 @@ public class ParserProfileChecker extend
     }
     
     @Override
-    public Node createPlainLiteral(String lexical, long line, long col)
+    public Node createStringLiteral(String lexical, long line, long col)
     {
         return NodeFactory.createLiteral(lexical) ;
     }

Modified: jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestLabelToNode.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestLabelToNode.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestLabelToNode.java (original)
+++ jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestLabelToNode.java Wed Jun 19 10:19:03 2013
@@ -45,10 +45,15 @@ public class TestLabelToNode extends Bas
             @Override public LabelToNode create() { return SyntaxLabels.createLabelToNode() ; }
             @Override public String toString() { return "SyntaxLabels.createLabelToNode" ; }
         } ;
+        
+        LabelToNodeFactory fScopeDocumentHash = new LabelToNodeFactory() {
+            @Override public LabelToNode create() { return LabelToNode.createScopeByDocumentHash() ; }
+            @Override public String toString() { return "ScopeByDocumentHash" ; }
+        } ;
 
         LabelToNodeFactory fScopeByDocument = new LabelToNodeFactory() {
-                @Override public LabelToNode create() { return LabelToNode.createScopeByDocument() ; }
-                @Override public String toString() { return "ScopeByDocument" ; }
+                @Override public LabelToNode create() { return LabelToNode.createScopeByDocumentOld() ; }
+                @Override public String toString() { return "ScopeByDocumentOld" ; }
         } ;
         LabelToNodeFactory fScopeByGraph = new LabelToNodeFactory() {
             @Override public LabelToNode create() { return LabelToNode.createScopeByGraph() ; }
@@ -67,19 +72,14 @@ public class TestLabelToNode extends Bas
             @Override public String toString() { return "Incremental" ; }
         } ;
 
-        LabelToNodeFactory fScopeDocumentHash = new LabelToNodeFactory() {
-            @Override public LabelToNode create() { return LabelToNode.createScopeByDocumentHash() ; }
-            @Override public String toString() { return "ScopeByDocumentHash" ; }
-        } ;
-
         // (1) Factory, whether DocScoped, (2) whether unique in a document (or graph) (3) whether unique per run 
         x.add(new Object[]{fSyntaxLabels,       true, true}) ;
+        x.add(new Object[]{fScopeDocumentHash,  true, true}) ;
         x.add(new Object[]{fScopeByDocument,    true, true}) ;
         x.add(new Object[]{fScopeByGraph,       false, true}) ;
         x.add(new Object[]{fUseLabelAsGiven,    true, false}) ;
         x.add(new Object[]{fUseLabelEncoded,    true, false}) ;
-        x.add(new Object[]{fIncremental,        true, true}) ;
-        x.add(new Object[]{fScopeDocumentHash,  true, true}) ;
+        x.add(new Object[]{fIncremental,        true, false}) ;
         return x ; 
     }
 
@@ -120,7 +120,8 @@ public class TestLabelToNode extends Bas
         Node n2 = mapper2.create() ;
         assertNotNull(n1) ;
         assertNotNull(n2) ;
-        assertNotEquals(n1, n2) ;
+        if ( unique )
+            assertNotEquals(n1, n2) ;
     }
     
     @Test public void label2node_Label1()
@@ -208,8 +209,12 @@ public class TestLabelToNode extends Bas
         Node n2 = mapper.get(null, "label1") ;
         assertNotNull(n1) ;
         assertNotNull(n2) ;
-        if ( unique )
+        if ( unique ) {
+            if ( n1.equals(n2) )
+                System.err.println("equals") ;
+            
             assertNotEquals(n1,n2) ;
+        }
         else
             assertEquals(n1,n2) ;
     }

Modified: jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestNodeAllocator.java
URL: http://svn.apache.org/viewvc/jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestNodeAllocator.java?rev=1494535&r1=1494534&r2=1494535&view=diff
==============================================================================
--- jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestNodeAllocator.java (original)
+++ jena/trunk/jena-arq/src/test/java/org/apache/jena/riot/lang/TestNodeAllocator.java Wed Jun 19 10:19:03 2013
@@ -20,6 +20,7 @@ package org.apache.jena.riot.lang;
 
 import org.apache.jena.atlas.junit.BaseTest ;
 import org.apache.jena.riot.lang.LabelToNode ;
+import org.apache.jena.riot.system.SyntaxLabels ;
 import org.junit.Test ;
 
 import com.hp.hpl.jena.graph.Node ;
@@ -30,20 +31,19 @@ public class TestNodeAllocator extends B
     static Node gragh1 = NodeFactory.createURI("g1") ;
     static Node gragh2 = NodeFactory.createURI("g2") ;
     
-    // ---- One Scope
+    // ---- Glaobl default policy needed for RDF parsing
     @Test public void allocOneScope1()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
         Node b1 = alloc.get(gragh1, "xyz" ) ;
         Node b2 = alloc.get(gragh1, "xyz" ) ;
         // SAME
         assertEquals(b1,b2) ;
-        assertSame(b1,b2) ;
     }
     
     @Test public void allocOneScope2()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
         Node b1 = alloc.get(gragh1, "xyz" ) ;
         Node b2 = alloc.get(gragh1, "123" ) ;
         // DIFFERENT
@@ -52,7 +52,7 @@ public class TestNodeAllocator extends B
 
     @Test public void allocOneScope3()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
         Node b1 = alloc.get(gragh1, "xyz" ) ;
         Node b2 = alloc.get(gragh2, "xyz" ) ;
         // SAME
@@ -61,8 +61,8 @@ public class TestNodeAllocator extends B
     
     @Test public void allocOneScope4()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
-        Node b1 = alloc.get(null, "xyz" ) ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
+        Node b1 = alloc.get(null,   "xyz" ) ;
         Node b2 = alloc.get(gragh2, "xyz" ) ;
         // SAME
         assertEquals(b1,b2) ;
@@ -70,7 +70,7 @@ public class TestNodeAllocator extends B
     
     @Test public void allocOneScope5()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
         Node b1 = alloc.get(null, "xyz" ) ;
         Node b2 = alloc.get(null, "xyz" ) ;
         // SAME
@@ -108,8 +108,8 @@ public class TestNodeAllocator extends B
     
     @Test public void allocGraphScope4()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
-        Node b1 = alloc.get(null, "xyz" ) ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
+        Node b1 = alloc.get(null,   "xyz" ) ;
         Node b2 = alloc.get(gragh2, "xyz" ) ;
         // DIFFERENT
         assertEquals(b1,b2) ;
@@ -117,7 +117,7 @@ public class TestNodeAllocator extends B
     
     @Test public void allocGraphScope5()
     {
-        LabelToNode alloc = LabelToNode.createScopeByDocument() ;
+        LabelToNode alloc = SyntaxLabels.createLabelToNode() ;
         Node b1 = alloc.get(null, "xyz" ) ;
         Node b2 = alloc.get(null, "xyz" ) ;
         // SAME