GH-2675: Call JenaSystem.init in RDFLinkHTTPBuilder

jena-arq/src/main/java/org/apache/jena/riot/RIOT.java

@@ -51,9 +51,6 @@ public class RIOT {
     /** The root package name for RIOT */
     public static final String PATH    = "org.apache.jena.riot" ;
 
-    /** Control of multiline literals */
-    public static final Symbol multilineLiterals = Symbol.create("riot.multiline_literals") ;
-
     /** The system-wide context, shared with ARQ and other modules. */
     private static Context systemGlobalContext = new Context();
 
@@ -158,4 +155,16 @@ public static String getVersion() {
      * Printing style. Whether to use a "wide" or "long" indentation style.
      */
     public static final Symbol symTurtleIndentStyle = SystemARQ.allocSymbol(TURTLE_SYMBOL_BASE, "indentStyle");
+
+    /**
+     * Print literals with newlines in multiple line form, using triple quotes.
+     */
+    public static final Symbol symTurtleMultilineLiterals = SystemARQ.allocSymbol(TURTLE_SYMBOL_BASE, "multiline_literals") ;
+
+    /**
+     * Control of multiline literals.
+     * @deprecated Use {@link #symTurtleMultilineLiterals}.
+     */
+    @Deprecated(forRemoval = true)
+    public static final Symbol multilineLiterals = symTurtleMultilineLiterals;
 }

jena-arq/src/main/java/org/apache/jena/riot/writer/TurtleShell.java

@@ -77,7 +77,7 @@ protected TurtleShell(IndentedWriter out, PrefixMap pmap, String baseURI, Contex
     }
 
     static public NodeFormatter createNodeFormatter(PrefixMap pmap, String baseURI, Context context) {
-        if ( context != null && context.isTrue(RIOT.multilineLiterals) )
+        if ( context != null && context.isTrue(RIOT.symTurtleMultilineLiterals) )
             return new NodeFormatterTTL_MultiLine(baseURI, pmap, NodeToLabel.createScopeByDocument());
         else
             return new NodeFormatterTTL(baseURI, pmap, NodeToLabel.createScopeByDocument());

jena-core/src/main/java/org/apache/jena/datatypes/xsd/impl/RDFDirLangString.java

@@ -18,27 +18,40 @@
 
 package org.apache.jena.datatypes.xsd.impl;
 
+import java.util.Objects;
+
 import org.apache.jena.datatypes.BaseDatatype ;
 import org.apache.jena.datatypes.RDFDatatype ;
 import org.apache.jena.graph.impl.LiteralLabel ;
+import org.apache.jena.vocabulary.RDF;
 
 /**
- * rdf:dirLangString (literal with language and initial text direction)
- * This covers the unusual case of "foo"^^rdf:langString or "foo"^^rdf:dirLangString.
- * When there is a language tag, there is a lexical form but it is in two parts lex@lang or lex@lang--ltr
+ * {@code rdf:dirLangString} - a literal with language and initial text direction.
+ * <p>
+ * This covers the unusual case of {@code "foo"^^rdf:dirLangString}.
  */
 
 public class RDFDirLangString extends BaseDatatype implements RDFDatatype {
 
-    /** Singleton instance */
-    // Include the string for the RDF namespace, do not use RDF.getURI() to avoid an initializer circularity.
-    public static final RDFDatatype rdfDirLangString = new RDFDirLangString("http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString");
+    public static final String rdfDirLangStringURI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString";
+
+    /**
+     * Singleton instance
+     * <p>
+     * Prefer {@link RDF#dtDirLangString} in applications.
+     */
+    public static final RDFDatatype rdfDirLangString = new RDFDirLangString();
 
     /**
-     * Private constructor.
+     * Test where an {@link RDFDatatype} is that for {@code rdf:dirLangString}.
      */
-    private RDFDirLangString(String uri) {
-        super(uri);
+    public static boolean isRDFDirLangString(RDFDatatype rdfDatatype) {
+        Objects.requireNonNull(rdfDatatype);
+        return rdfDirLangStringURI.equals(rdfDatatype.getURI());
+    }
+
+    private RDFDirLangString() {
+        super(rdfDirLangStringURI);
     }
 
     /**
@@ -49,7 +62,7 @@ public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
         return isEqualByTerm(value1, value2) ;
     }
 
-    // This covers the unusual case of "foo"^^"rdf:langString" or "foo"^^rdf:dirLangString.
+    /** This covers the unusual case of "foo"^^rdf:dirLangString. */
     @Override
     public Object parse(String lexicalForm) { return lexicalForm ; }
 

jena-core/src/main/java/org/apache/jena/datatypes/xsd/impl/RDFLangString.java

@@ -18,26 +18,42 @@
 
 package org.apache.jena.datatypes.xsd.impl;
 
+import java.util.Objects;
+
 import org.apache.jena.datatypes.BaseDatatype ;
 import org.apache.jena.datatypes.RDFDatatype ;
 import org.apache.jena.graph.impl.LiteralLabel ;
+import org.apache.jena.vocabulary.RDF;
 
-/** rdf:langString.
- * This covers the unusual case of "foo"^^rdf:langString
- * When there is a language tag, there is a lexical form but it is in two parts lex@lang
+/**
+ * {@code rdf:dirLangString} - a literal with language and initial text direction.
+ * <p>
+ * This covers the unusual case of {@code "foo"^^rdf:langString}.
+ * When there is a language tag, there is a lexical form but it is in two parts lex@lang.
  * This is not rdf:plainLiteral!
  */
 
 public class RDFLangString extends BaseDatatype implements RDFDatatype {
-    /** Singleton instance */
-    // Include the string for the RDF namespace, not use RDF.getURI(), to avoid an initializer circularity
-    public static final RDFDatatype rdfLangString = new RDFLangString("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString");
+
+    public static final String rdfLangStringURI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
+
+    /**
+     * Singleton instance
+     * <p>
+     * Prefer {@link RDF#dtLangString} in applications.
+     */
+    public static final RDFDatatype rdfLangString = new RDFLangString();
 
     /**
-     * Private constructor.
+     * Test where an {@link RDFDatatype} is that for {@code rdf:langString}.
      */
-    private RDFLangString(String uri) {
-        super(uri);
+    public static boolean isRDFLangString(RDFDatatype rdfDatatype) {
+        Objects.requireNonNull(rdfDatatype);
+        return rdfLangStringURI.equals(rdfDatatype.getURI());
+    }
+
+    private RDFLangString() {
+        super(rdfLangStringURI);
     }
 
     /**
@@ -48,9 +64,7 @@ public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
         return isEqualByTerm(value1, value2) ;
     }
 
-    // This covers the unusual case of "foo"^^"rdf:langString"
-    // When there is a language tag, there is a lexcial form but it is in two parts lex@lang
-    // This is not rdf:plainLiteral!
+    /** This covers the unusual case of "foo"^^rdf:langString. */
     @Override
     public Object parse(String lexicalForm) { return lexicalForm ; }
 

jena-core/src/main/java/org/apache/jena/datatypes/xsd/impl/RDFhtml.java

@@ -18,37 +18,54 @@
 
 package org.apache.jena.datatypes.xsd.impl;
 
+import java.util.Objects;
+
 import org.apache.jena.datatypes.BaseDatatype ;
 import org.apache.jena.datatypes.RDFDatatype ;
 import org.apache.jena.graph.impl.LiteralLabel ;
+import org.apache.jena.vocabulary.RDF;
 
-/** rdf:html.
- * This only implements syntactic equality, not value equality (parsed HTML5, DOM normalized)    
+/**
+ * <a href="https://www.w3.org/TR/rdf-concepts/#section-html">rdf:HTML</a>.
+ * <p>
+ * This only implements syntactic equality, not value equality (parsed HTML5, DOM normalized)
  */
-
 public class RDFhtml extends BaseDatatype implements RDFDatatype {
-    /** Singleton instance */
-    // Include the string for the RDF namespace, not use RDF.getURI(), to avoid an initializer circularity
-    public static final RDFDatatype rdfHTML = new RDFhtml("http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML");
-
+
+    public static String RDFhtmlURI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML";
+
+    /**
+     * Singleton instance
+     * <p>
+     * Prefer {@link RDF#dtRDFHTML} in applications.
+     */
+    public static final RDFDatatype rdfHTML = new RDFhtml();
+
     /**
-     * Private constructor.
+     * Test where an {@link RDFDatatype} is that for {@code rdf:HTML}.
      */
-    private RDFhtml(String uri) {
-        super(uri);
+    public static boolean isXMLLiteral(RDFDatatype rdfDatatype) {
+        Objects.requireNonNull(rdfDatatype);
+        return RDFhtmlURI.equals(rdfDatatype.getURI());
+    }
+
+    private RDFhtml() {
+        // Include the string for the RDF namespace.
+        // Do not use RDF.dtRDFHTML.getURI() to avoid an initializer circularity
+        super(RDFhtmlURI);
     }
 
     /**
-     * Compares two instances of values of the given datatype. 
+     * Compares two instances of values of the given datatype.
      */
     @Override
     public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
         return isEqualByTerm(value1, value2) ;
     }
-    
+
     @Override
     public Object parse(String lexicalForm) { return lexicalForm ; }
-    
+
     @Override
     public String unparse(Object value) { return value.toString(); }
 }

jena-core/src/main/java/org/apache/jena/datatypes/xsd/impl/RDFjson.java

@@ -18,37 +18,59 @@
 
 package org.apache.jena.datatypes.xsd.impl;
 
+import java.util.Objects;
+
 import org.apache.jena.datatypes.BaseDatatype ;
 import org.apache.jena.datatypes.RDFDatatype ;
 import org.apache.jena.graph.impl.LiteralLabel ;
+import org.apache.jena.vocabulary.RDF;
 
-/** rdf:json.
- * This only implements syntactic equality, not value equality.    
+/**
+ * <a href="https://www.w3.org/TR/rdf-concepts/#section-json">rdf:JSON</a>.
+ * <p>
+ * This only implements syntactic equality, not value equality.
  */
-
 public class RDFjson extends BaseDatatype implements RDFDatatype {
-    /** Singleton instance */
-    // Include the string for the RDF namespace, not use RDF.getURI(), to avoid an initializer circularity
-    public static final RDFDatatype rdfJSON = new RDFjson("http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON");
-
+
+    public static final String rdfJsonURI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON";
+
+    /**
+     * Singleton instance.
+     * <p>
+     * Prefer {@link RDF#dtRDFJSON} in applications.
+     */
+    public static final RDFDatatype rdfJSON = new RDFjson();
+
     /**
-     * Private constructor.
+     * @deprecated Prefer {@link #rdfJsonURI}.
      */
-    private RDFjson(String uri) {
-        super(uri);
+    @Deprecated
+    public static String RDFjson = rdfJsonURI;
+
+    /**
+     * Test where an {@link RDFDatatype} is that for {@code rdf:XMLLiteral}.
+     */
+    public static boolean isRDFjson(RDFDatatype rdfDatatype) {
+        Objects.requireNonNull(rdfDatatype);
+        return rdfJsonURI.equals(rdfDatatype.getURI());
+    }
+
+    private RDFjson() {
+        // Include the string for the RDF namespace, not use RDF.getURI(), to avoid an initializer circularity
+        super(rdfJsonURI);
     }
 
     /**
-     * Compares two instances of values of the given datatype. 
+     * Compares two instances of values of the given datatype.
      */
     @Override
     public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
         return isEqualByTerm(value1, value2) ;
     }
-    
+
     @Override
     public Object parse(String lexicalForm) { return lexicalForm ; }
-    
+
     @Override
     public String unparse(Object value) { return value.toString(); }
 }

jena-core/src/main/java/org/apache/jena/datatypes/xsd/impl/XMLLiteralType.java

@@ -62,18 +62,19 @@
 public class XMLLiteralType extends BaseDatatype implements RDFDatatype {
 
     public static String XMLLiteralTypeURI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral";
+
     /**
      * Singleton instance of the rdf:XMLLIteral datatype.
      * Prefer {@link RDF#dtXMLLiteral} in applications.
      */
-    public static final RDFDatatype rdfXMLLiteral = new XMLLiteralType(XMLLiteralTypeURI);
+    public static final RDFDatatype rdfXMLLiteral = new XMLLiteralType();
 
     /**
      * Singleton instance (legacy name)
      * @deprecated Prefer the constant {@link #rdfXMLLiteral} or {@link RDF#dtXMLLiteral}
      */
     @Deprecated
-    public static final RDFDatatype theXMLLiteralType = new XMLLiteralType(XMLLiteralTypeURI);
+    public static final RDFDatatype theXMLLiteralType = rdfXMLLiteral;
 
     private static final String  xmlWrapperTagName  = "xml-literal-fragment";
     private static final String  xmlWrapperTagStart = "<"+xmlWrapperTagName+">";
@@ -87,8 +88,8 @@ public static boolean isXMLLiteral(RDFDatatype rdfDatatype) {
         return XMLLiteralTypeURI.equals(rdfDatatype.getURI());
     }
 
-    private XMLLiteralType(String uri) {
-        super(uri);
+    private XMLLiteralType() {
+        super(XMLLiteralTypeURI);
     }
 
     /**

jena-core/src/main/java/org/apache/jena/irix/IRIProviderJenaIRI.java

@@ -30,7 +30,7 @@
  */
 public class IRIProviderJenaIRI implements IRIProvider {
 
-    // Notes:
+    // Notes about jena-iri
     // jena-iri:IRI.create is silent.
     // jena-iri:IRI.construct throws errors.
     // jena-iri:IRI.resolve is the same as create
@@ -359,7 +359,7 @@ private static void checkUUID(IRI iriObj, String original) {
     private static String UNRESERVED = "-0-9a-z._~";
     // Or use \p{IsAlphabetic}
     private static String UCSCHAR = "\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF";
-            /*
+            /* Beyond 16 bits:
             / %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD
             / %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD
             / %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD
@@ -376,12 +376,15 @@ private static void checkUUID(IRI iriObj, String original) {
     private static String PCHARS1 = UNRESERVED+SUB_DELIMS+":"+"@";
     private static String PCHAR = "(?:(?:["+PCHARS1+"]|"+PCT+"))";
 
-    private static String URN_COMP_X = "/\\?";
-    private static String URN_RQ_COMP_CHAR = PCHAR+URN_COMP_X;
-    private static String URN_R_COMP = "(?:\\?\\+["+URN_RQ_COMP_CHAR+"]+)?";
-    private static String URN_Q_COMP = "(?:\\?=["+URN_RQ_COMP_CHAR+"]+)?";
-    private static String URN_F_COMP = "(?:#["+PCHAR+"]*)?";
-    private static String URN_UUID_REGEXP = "^urn:uuid:"+UUID_BASE+URN_R_COMP+URN_Q_COMP+URN_F_COMP+"$";
+    // Elements of components.
+    private static String URN_COMPONENT_X = "/\\?";     // "/" and "?"
+    private static String URN_RQ_COMPONENT_CHAR = PCHAR+URN_COMPONENT_X;
+    // Optional components
+    private static String URN_R_COMPONENT = "(?:\\?\\+["+URN_RQ_COMPONENT_CHAR+"]+)?";
+    private static String URN_Q_COMPONENT = "(?:\\?=["+URN_RQ_COMPONENT_CHAR+"]+)?";
+    private static String URN_F_COMPONENT = "(?:#["+PCHAR+"]*)?";
+    // scheme , NID, uuid, optional URN_R_COMPONENT, optional URN_Q_COMPONENT, optional F_COMPONENT
+    private static String URN_UUID_REGEXP = "^urn:uuid:"+UUID_BASE+URN_R_COMPONENT+URN_Q_COMPONENT+URN_F_COMPONENT+"$";
 
     private static Pattern URN_UUID_PATTERN = Pattern.compile(URN_UUID_REGEXP, Pattern.CASE_INSENSITIVE);
 

jena-core/src/main/java/org/apache/jena/sys/JenaSystem.java

@@ -77,17 +77,20 @@ public static void logLifecycle(String fmt, Object ...args) {
     }
 
     public static void init() {
+        // Once jena is initialized, all calls are an immediate return.
         if ( initialized )
             return ;
+        // Overlapping attempts to perform initialization will block on the synchronized.
         synchronized(JenaSystem.class) {
             if ( initialized )
                 return ;
-            initialized = true;
             setup();
             if ( DEBUG_INIT )
                 singleton.debug(DEBUG_INIT);
             singleton.initialize();
             singleton.debug(false);
+            // Last so overlapping initialization waits on the synchronized
+            initialized = true;
         }
     }