| /* |
| * 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; |
| |
| import java.util.* ; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| |
| import org.apache.jena.util.Metadata ; |
| |
| /** Methods and constants that define features of the current the environment. |
| * Primarily for other parts of the Jena framework. |
| */ |
| |
| public class JenaRuntime |
| { |
| /** |
| * <p> |
| * The global <tt>isRDF11</tt> exists only to support development in Jena2. |
| * It is not expected that this flag will be "true" for Jena2 releases. |
| * </p> |
| * <p> |
| * Jena2 provides RDF 1.0 (AKA RDF 2004) and as much of RDF 1.1 that can be provided without |
| * invalidating existing data and applciations. For example, the Turtle family parsers |
| * cover the RDF 1.1 defined grammars. |
| * </p> |
| * <p> |
| * RDF 1.1 does make some changes that will effect some applications. The RDF Working Group |
| * do not expect these to be that major but they are visible in some situations. |
| * </p> |
| * <p> |
| * One of these changes is that literals always have a datatype. RDF 1.0 plain literals |
| * (e.g. <tt>"foo"</tt> and <tt>"foo"@en</tt>) do not have datatype. |
| * </p> |
| * <p> |
| * In RDF 1.1: |
| * <ul> |
| * <li>string literals without language tag have datatype <tt>xsd:string</tt></li> |
| * <li>string literals with language tag have datatype <tt>rdf:langString</tt>. |
| * They still have a language tag.</li> |
| * </ul> |
| * <p> |
| * In RDF 1.0, <tt>"foo"</tt> and <tt>"foo"^^xsd:string</tt> are different RDF terms. |
| * Triples <tt>:s :p "foo"</tt> and <tt>:s :p "foo"^^xsd:string</tt> are two different RDF triples. |
| * Jena memory models provide "same value" semantics, so these can both be found looking for |
| * object of <tt>"foo"</tt> but two such triples are found. |
| * </p> |
| * <p> |
| * Other storage implementations do not provide these "same value" semantics. |
| * Two triples are stored in a graph or in a database. |
| * </p> |
| * <p> |
| * In RDF 1.1, <tt>"foo"</tt> and <tt>"foo"^^xsd:string</tt> are the same RDF term; it is just |
| * two different ways to write it. The example triples above are the same triple. |
| * Only one triple would be stored in a graph or on disk. |
| * </p> |
| * <p> |
| * It is common for applications to work either with RDF 1.0 untyped strings or with typed |
| * <tt>xsd:strings</tt>. Mixed working is less common. Mixed working applications will be |
| * affected by the changes in RDF 1.1. |
| * </p> |
| * <p> |
| * Default full RDF 1.1 behaviour is expected in Jena3, with the change of major version |
| * number used to indicate the application-visible change. |
| * </p> |
| */ |
| |
| public static boolean isRDF11 = true ; |
| |
| // -------------------------------------------------------------- |
| |
| private static String metadataLocation = "org/apache/jena/jena-properties.xml" ; |
| private static Metadata metadata = new Metadata(metadataLocation) ; |
| public static String getMetadata(String key, String defaultValue) { return metadata.get(key, defaultValue) ; } |
| |
| /** The JVM does not implement java.security (correctly) */ |
| public static final String featureNoSecurity = "http://jena.hpl.hp.com/2004/07/feature/noSecurity" ; |
| |
| /** The JVM does not implement java.nio.charset.Charset operations (correctly) */ |
| public static final String featureNoCharset = "http://jena.hpl.hp.com/2004/07/feature/noCharset" ; |
| |
| static Map<String, String> features = new HashMap<>() ; |
| static { |
| // Note getSystemProperty uses featureNoSecurity but works if it |
| // has not been initialized |
| if ( getSystemProperty(featureNoSecurity) != null ) |
| setFeature(featureNoSecurity) ; |
| |
| if ( getSystemProperty(featureNoCharset) != null ) |
| setFeature(featureNoCharset) ; |
| } |
| |
| public static void setFeature(String featureName) { features.put(featureName, "true") ; } |
| public static boolean runUnder(String featureName) { return features.containsKey(featureName) ; } |
| public static boolean runNotUnder(String featureName) { return ! features.containsKey(featureName) ; } |
| |
| |
| static final String lineSeparator = getSystemProperty("line.separator", "\n") ; |
| public static String getLineSeparator() |
| { |
| return lineSeparator ; |
| } |
| |
| public static String getSystemProperty(String propName) |
| { |
| return getSystemProperty(propName, null) ; |
| } |
| |
| public static String getSystemProperty(final String propName, String defaultValue) |
| { |
| try { |
| return System.getProperty(propName, defaultValue) ; |
| } catch (SecurityException ex) |
| { |
| if ( runUnder(featureNoSecurity)) |
| return defaultValue ; |
| try { |
| PrivilegedAction<String> a = new PrivilegedAction<String>() { |
| @Override |
| public String run() { |
| return System.getProperty(propName); |
| } |
| } ; |
| return AccessController.doPrivileged(a) ; |
| } catch (Exception ex2) |
| { |
| // Give up |
| return defaultValue ; |
| } |
| } |
| } |
| } |