/*
* 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.rdfxml.xmloutput.impl;
import java.io.OutputStream ;
import java.io.OutputStreamWriter ;
import java.io.PrintWriter ;
import java.io.Writer ;
import java.util.* ;
import java.util.Map.Entry ;
import java.util.regex.Pattern ;
import org.apache.jena.JenaRuntime ;
import org.apache.jena.iri.IRI ;
import org.apache.jena.iri.IRIFactory ;
import org.apache.jena.rdf.model.* ;
import org.apache.jena.rdf.model.impl.RDFDefaultErrorHandler ;
import org.apache.jena.rdf.model.impl.ResourceImpl ;
import org.apache.jena.rdf.model.impl.Util ;
import org.apache.jena.rdfxml.xmloutput.RDFXMLWriterI ;
import org.apache.jena.shared.* ;
import org.apache.jena.util.CharEncoding ;
import org.apache.jena.util.FileUtils ;
import org.apache.jena.vocabulary.* ;
import org.apache.xerces.util.XMLChar ;
import org.slf4j.Logger ;
import org.slf4j.LoggerFactory ;
/**
* This is not part of the public API.
* Base class for XML serializers.
* All methods with side-effects should be synchronized in this class and its
* subclasses. (i. e. XMLWriters assume that the world is not changing around
* them while they are writing).
*
* Functionality:
*
* <ul>
* <li>setProperty etc
* <li>namespace prefixes
* <li>xmlbase
* <li>relative URIs
* <li>encoding issues
* <li>anonymous node presentational
* <li>errorHandler
* </ul>
*/
abstract public class BaseXMLWriter implements RDFXMLWriterI {
private static final String newline =
JenaRuntime.getSystemProperty( "line.separator" );
static private final String DEFAULT_NS_ENTITY_NAME = "this";
static private final String DEFAULT_NS_ENTITY_NAME_ALT = "here";
private String defaultNSEntityName = "UNSET" ;
public BaseXMLWriter() {
setupMaps();
}
private static Logger xlogger = LoggerFactory.getLogger( BaseXMLWriter.class );
protected static SimpleLogger logger = new SimpleLogger() {
@Override
public void warn(String s) {
xlogger.warn(s);
}
@Override
public void warn(String s, Exception e) {
xlogger.warn(s,e);
}
};
public static SimpleLogger setLogger(SimpleLogger lg) {
SimpleLogger old = logger;
logger= lg;
return old;
}
abstract protected void unblockAll();
abstract protected void blockRule(Resource r);
abstract protected void writeBody
( Model mdl, PrintWriter pw, String baseUri, boolean inclXMLBase );
static private Set<String> badRDF = new HashSet<>();
/**
Counter used for allocating Jena transient namespace declarations.
*/
private int jenaPrefixCount;
static String RDFNS = RDF.getURI();
static private Pattern jenaNamespace;
static {
jenaNamespace =
Pattern.compile("j\\.([1-9][0-9]*|cook\\.up)");
badRDF.add("RDF");
badRDF.add("Description");
badRDF.add("li");
badRDF.add("about");
badRDF.add("aboutEach");
badRDF.add("aboutEachPrefix");
badRDF.add("ID");
badRDF.add("nodeID");
badRDF.add("parseType");
badRDF.add("datatype");
badRDF.add("bagID");
badRDF.add("resource");
}
String xmlBase = null;
private IRI baseURI;
boolean longId = false;
private boolean demandGoodURIs = true;
int tabSize = 2;
int width = 60;
HashMap<AnonId, String> anonMap = new HashMap<>();
int anonCount = 0;
static private RDFDefaultErrorHandler defaultErrorHandler =
new RDFDefaultErrorHandler();
RDFErrorHandler errorHandler = defaultErrorHandler;
Boolean showXmlDeclaration = null;
protected Boolean showDoctypeDeclaration = Boolean.FALSE;
/*
* There are two sorts of id's for anonymous resources. Short id's are the
* default, but require a mapping table. The mapping table means that
* serializing a large model could run out of memory. Long id's require no
* mapping table, but are less readable.
*/
String anonId(Resource r) {
return longId ? longAnonId( r ) : shortAnonId( r );
}
/*
* A shortAnonId is computed by maintaining a mapping table from the internal
* id's of anon resources. The short id is the index into the table of the
* internal id.
*/
private String shortAnonId(Resource r) {
String result = anonMap.get(r.getId());
if (result == null) {
result = "A" + Integer.toString(anonCount++);
anonMap.put(r.getId(), result);
}
return result;
}
/*
* A longAnonId is the internal id of the anon resource expressed as a
* character string.
*
* This code makes no assumptions about the characters used in the
* implementation of an anon id. It checks if they are valid namechar
* characters and escapes the id if not.
*/
private String longAnonId(Resource r) {
String rid = r.getId().toString();
return XMLChar.isValidNCName( rid ) ? rid : escapedId( rid );
}
/**
true means all namespaces defined in the model prefixes will be noted in xmlns
declarations; false means only "required" ones will be noted. Hook for configuration.
*/
private boolean writingAllModelPrefixNamespaces = true;
private Relation<String> nameSpaces = new Relation<>();
private Map<String, String> ns;
private PrefixMapping modelPrefixMapping;
private Set<String> namespacesNeeded;
void addNameSpace(String uri) {
namespacesNeeded.add(uri);
}
boolean isDefaultNamespace( String uri ) {
return "".equals( ns.get( uri ) );
}
private void addNameSpaces( Model model ) {
NsIterator nsIter = model.listNameSpaces();
while (nsIter.hasNext()) this.addNameSpace( nsIter.nextNs() );
}
private void primeNamespace( Model model )
{
Map<String, String> m = model.getNsPrefixMap();
for ( Entry<String, String> e : m.entrySet() )
{
String value = e.getValue();
String already = this.getPrefixFor( value );
if ( already == null )
{
this.setNsPrefix( model.getNsURIPrefix( value ), value );
if ( writingAllModelPrefixNamespaces )
{
this.addNameSpace( value );
}
}
}
if ( usesPrefix(model, "") )
{
// Doing "" prefix. Ensure it is a non-clashing, non-empty entity name.
String entityForEmptyPrefix = DEFAULT_NS_ENTITY_NAME ;
if ( usesPrefix(model, entityForEmptyPrefix) )
entityForEmptyPrefix = DEFAULT_NS_ENTITY_NAME_ALT ;
int i = 0 ;
while ( usesPrefix(model,entityForEmptyPrefix) )
{
entityForEmptyPrefix = DEFAULT_NS_ENTITY_NAME_ALT+"."+i ;
i++ ;
}
defaultNSEntityName = entityForEmptyPrefix ;
}
}
void setupMaps() {
nameSpaces.set11(RDF.getURI(), "rdf");
nameSpaces.set11(RDFS.getURI(), "rdfs");
nameSpaces.set11(DC.getURI(), "dc");
nameSpaces.set11(RSS.getURI(), "rss");
nameSpaces.set11("http://www.daml.org/2001/03/daml+oil.daml#", "daml");
nameSpaces.set11(VCARD.getURI(), "vcard");
nameSpaces.set11("http://www.w3.org/2002/07/owl#", "owl");
}
void workOutNamespaces() {
if (ns == null) {
ns = new HashMap<>();
Set<String> prefixesUsed = new HashSet<>();
setFromWriterSystemProperties( ns, prefixesUsed );
setFromGivenNamespaces( ns, prefixesUsed );
}
}
private void setFromWriterSystemProperties( Map<String, String> ns, Set<String> prefixesUsed ) {
for ( String uri : namespacesNeeded )
{
String val = JenaRuntime.getSystemProperty( RDFWriter.NSPREFIXPROPBASE + uri );
if ( val != null && checkLegalPrefix( val ) && !prefixesUsed.contains( val ) )
{
ns.put( uri, val );
prefixesUsed.add( val );
}
}
}
private void setFromGivenNamespaces( Map<String, String> ns, Set<String> prefixesUsed ) {
for ( String uri : namespacesNeeded )
{
if ( ns.containsKey( uri ) )
{
continue;
}
String val = null;
Set<String> s = nameSpaces.forward( uri );
if ( s != null )
{
Iterator<String> it2 = s.iterator();
if ( it2.hasNext() )
{
val = it2.next();
}
if ( prefixesUsed.contains( val ) )
{
val = null;
}
}
if ( val == null )
{
// just in case the prefix has already been used, look for a free one.
// (the usual source of such prefixes is reading in a model we wrote out earlier)
do
{
val = "j." + ( jenaPrefixCount++ );
}
while ( prefixesUsed.contains( val ) );
}
ns.put( uri, val );
prefixesUsed.add( val );
}
}
final synchronized public void setNsPrefix(String prefix, String ns) {
if (checkLegalPrefix(prefix)) {
nameSpaces.set11(ns, prefix);
}
}
final public String getPrefixFor( String uri )
{
// xml and xmlns namespaces are pre-bound
if ("http://www.w3.org/XML/1998/namespace".equals(uri)) return "xml";
if ("http://www.w3.org/2000/xmlns/".equals(uri)) return "xmlns";
Set<String> s = nameSpaces.backward( uri );
if (s != null && s.size() == 1) return s.iterator().next();
return null;
}
String xmlnsDecl() {
workOutNamespaces();
StringBuilder result = new StringBuilder();
Iterator<Entry<String, String>> it = ns.entrySet().iterator();
while (it.hasNext()) {
Entry<String, String> ent = it.next();
String prefix = ent.getValue();
String uri = ent.getKey();
result.append( newline ).append( " xmlns" );
if (prefix.length() > 0) result.append( ':' ).append( prefix );
result.append( '=' ).append( substitutedAttribute( checkURI( uri ) ) );
}
return result.toString();
}
static final private int FAST = 1;
static final private int START = 2;
static final private int END = 3;
static final private int ATTR = 4;
static final private int FASTATTR = 5;
String rdfEl(String local) {
return tag(RDFNS, local, FAST, true);
}
String startElementTag(String uri, String local) {
return tag(uri, local, START, false);
}
protected String startElementTag(String uriref) {
return splitTag(uriref, START);
}
String attributeTag(String uriref) {
return splitTag(uriref, ATTR);
}
String attributeTag(String uri, String local) {
return tag(uri, local, ATTR, false);
}
String rdfAt(String local) {
return tag(RDFNS, local, FASTATTR, true);
}
String endElementTag(String uri, String local) {
return tag(uri, local, END, false);
}
protected String endElementTag(String uriref) {
return splitTag(uriref, END);
}
String splitTag(String uriref, int type) {
int split = Util.splitNamespaceXML( uriref );
if (split == uriref.length()) throw new InvalidPropertyURIException( uriref );
return tag( uriref.substring( 0, split ), uriref.substring( split ), type, true );
}
static public boolean dbg = false;
String tag( String namespace, String local, int type, boolean localIsQname) {
if (dbg)
System.err.println(namespace + " - " + local);
String prefix = ns.get( namespace );
if (type != FAST && type != FASTATTR) {
if ((!localIsQname) && !XMLChar.isValidNCName(local))
return splitTag(namespace + local, type);
if (namespace.equals(RDFNS)) {
// Description, ID, nodeID, about, aboutEach, aboutEachPrefix, li
// bagID parseType resource datatype RDF
if (badRDF.contains(local)) {
logger.warn( "The URI rdf:" + local + " cannot be serialized in RDF/XML." );
throw new InvalidPropertyURIException( "rdf:" + local );
}
}
}
boolean cookUp = false;
if (prefix == null) {
checkURI( namespace );
logger.warn(
"Internal error: unexpected QName URI: <"
+ namespace
+ ">. Fixing up with j.cook.up code.",
new BrokenException( "unexpected QName URI " + namespace ));
cookUp = true;
} else if (prefix.length() == 0) {
if (type == ATTR || type == FASTATTR)
cookUp = true;
else
return local;
}
if (cookUp) return cookUpAttribution( type, namespace, local );
return prefix + ":" + local;
}
private String cookUpAttribution( int type, String namespace, String local )
{
String prefix = "j.cook.up";
switch (type) {
case FASTATTR :
case ATTR :
return "xmlns:" + prefix + "=" + substitutedAttribute( namespace ) + " " + prefix + ":" + local;
case START :
return prefix + ":" + local + " xmlns:" + prefix+ "=" + substitutedAttribute( namespace );
default:
case END :
return prefix + ":" + local;
case FAST :
// logger.error("Unreachable code - reached.");
throw new BrokenException( "cookup reached final FAST" );
}
}
/** Write out an XML serialization of a model.
* @param model the model to be serialized
* @param out the OutputStream to receive the serialization
* @param base The URL at which the file will be placed.
*/
@Override
final public void write(Model model, OutputStream out, String base)
{ write( model, FileUtils.asUTF8(out), base ); }
/** Serialize Model <code>model</code> to Writer <code>out</out>.
* @param model The model to be written.
* @param out The Writer to which the serialization should be sent.
* @param base the base URI for relative URI calculations. <code>null</code> means use only absolute URI's.
*/
@Override
synchronized public void write(Model model, Writer out, String base)
{
setupNamespaces( model );
PrintWriter pw = out instanceof PrintWriter ? (PrintWriter) out : new PrintWriter( out );
if (!Boolean.FALSE.equals(showXmlDeclaration)) writeXMLDeclaration( out, pw );
writeXMLBody( model, pw, base );
pw.flush();
}
/**
@param baseModel
@param model
*/
private void setupNamespaces( Model model )
{
this.namespacesNeeded = new HashSet<>();
this.ns = null;
this.modelPrefixMapping = model;
primeNamespace( model );
addNameSpace( RDF.getURI() );
addNameSpaces(model);
jenaPrefixCount = 0;
}
@SuppressWarnings("deprecation")
static IRIFactory factory = IRIFactory.jenaImplementation();
private void writeXMLBody( Model model, PrintWriter pw, String base ) {
if (showDoctypeDeclaration.booleanValue()) generateDoctypeDeclaration( model, pw );
// try {
// errors?
if (xmlBase == null) {
baseURI = (base == null || base.length() == 0) ? null : factory.create(base);
writeBody(model, pw, base, false);
} else {
baseURI = xmlBase.length() == 0 ? null : factory.create(xmlBase);
writeBody(model, pw, xmlBase, true);
}
// } catch (MalformedURIException e) {
// throw new BadURIException( e.getMessage(), e);
// }
}
protected static final Pattern predefinedEntityNames = Pattern.compile( "amp|lt|gt|apos|quot" );
public boolean isPredefinedEntityName( String name )
{ return predefinedEntityNames.matcher( name ).matches(); }
private String attributeQuoteChar ="\"";
protected String attributeQuoted( String s )
{ return attributeQuoteChar + s + attributeQuoteChar; }
protected String substitutedAttribute( String s )
{
String substituted = Util.substituteStandardEntities( s );
if (!showDoctypeDeclaration.booleanValue())
return attributeQuoted( substituted );
else
{
int split = Util.splitNamespaceXML( substituted );
String namespace = substituted.substring( 0, split );
String prefix = modelPrefixMapping.getNsURIPrefix( namespace );
return prefix == null || isPredefinedEntityName( prefix )
? attributeQuoted( substituted )
: attributeQuoted( "&" + strForPrefix(prefix) + ";" + substituted.substring( split ) )
;
}
}
private void generateDoctypeDeclaration( Model model, PrintWriter pw )
{
String rdfns = RDF.getURI();
String rdfRDF = model.qnameFor( rdfns + "RDF" );
if ( rdfRDF == null ) {
model.setNsPrefix("rdf",rdfns);
rdfRDF = "rdf:RDF";
}
Map<String, String> prefixes = model.getNsPrefixMap();
pw.print( "<!DOCTYPE " + rdfRDF +" [" );
for ( String prefix : prefixes.keySet() )
{
if ( isPredefinedEntityName( prefix ) )
{
continue;
}
pw.print(
newline + " <!ENTITY " + strForPrefix( prefix ) + " '" + Util.substituteEntitiesInEntityValue(
prefixes.get( prefix ) ) + "'>" );
}
pw.print( "]>" + newline );
}
private String strForPrefix(String prefix)
{
if ( prefix.length() == 0 )
return defaultNSEntityName ;
return prefix ;
}
private static boolean usesPrefix(Model model, String prefix)
{
return model.getNsPrefixURI(prefix) != null ;
}
private void writeXMLDeclaration(Writer out, PrintWriter pw) {
String decl = null;
if (out instanceof OutputStreamWriter) {
String javaEnc = ((OutputStreamWriter) out).getEncoding();
// System.err.println(javaEnc);
if (!(javaEnc.equals("UTF8") || javaEnc.equals("UTF-16"))) {
CharEncoding encodingInfo = CharEncoding.create(javaEnc);
String ianaEnc = encodingInfo.name();
decl = "<?xml version="+attributeQuoted("1.0")+" encoding=" + attributeQuoted(ianaEnc) + "?>";
if (!encodingInfo.isIANA())
logger.warn(encodingInfo.warningMessage()+"\n"+
" It is better to use a FileOutputStream, in place of a FileWriter.");
}
}
if (decl == null && showXmlDeclaration != null)
decl = "<?xml version="+attributeQuoted("1.0")+"?>";
if (decl != null) {
pw.println(decl);
}
}
/** Set an error handler.
* @param errHandler The new error handler to be used, or null for the default handler.
* @return the old error handler
*/
@Override
synchronized public RDFErrorHandler setErrorHandler(RDFErrorHandler errHandler) {
// null means no user defined error handler.
// We implement this using defaultErrorHandler,
// but hide this fact from the user.
RDFErrorHandler rslt = errorHandler;
if (rslt == defaultErrorHandler) rslt = null;
errorHandler = errHandler == null ? defaultErrorHandler : errHandler;
return rslt;
}
static private final char ESCAPE = 'X';
static private String escapedId(String id) {
StringBuffer result = new StringBuffer();
for (int i = 0; i < id.length(); i++) {
char ch = id.charAt(i);
if (ch != ESCAPE
&& (i == 0 ? XMLChar.isNCNameStart(ch) : XMLChar.isNCName(ch))) {
result.append( ch );
} else {
escape( result, ch );
}
}
return result.toString();
}
static final char [] hexchar = "0123456789abcdef".toCharArray();
static private void escape( StringBuffer sb, char ch) {
sb.append( ESCAPE );
int charcode = ch;
do {
sb.append( hexchar[charcode & 15] );
charcode = charcode >> 4;
} while (charcode != 0);
sb.append( ESCAPE );
}
/**
Set the writer property propName to the value obtained from propValue. Return an
Object representation of the original value.
@see org.apache.jena.rdf.model.RDFWriter#setProperty(java.lang.String, java.lang.Object)
*/
@Override
final synchronized public Object setProperty( String propName, Object propValue ) {
if (propName.equalsIgnoreCase("showXmlDeclaration")) {
return setShowXmlDeclaration(propValue);
} else if (propName.equalsIgnoreCase( "showDoctypeDeclaration" )) {
return setShowDoctypeDeclaration( propValue );
} else if (propName.equalsIgnoreCase( "minimalPrefixes" )) {
try { return new Boolean( !writingAllModelPrefixNamespaces ); }
finally { writingAllModelPrefixNamespaces = !getBoolean( propValue ); }
} else if (propName.equalsIgnoreCase("xmlbase")) {
String result = xmlBase;
xmlBase = (String) propValue;
return result;
} else if (propName.equalsIgnoreCase("tab")) {
return setTab( propValue );
} else if (propName.equalsIgnoreCase("width")) {
return setWidth(propValue);
} else if (propName.equalsIgnoreCase("longid")) {
Boolean result = new Boolean(longId);
longId = getBoolean(propValue);
return result;
} else if (propName.equalsIgnoreCase("attributeQuoteChar")) {
return setAttributeQuoteChar(propValue);
} else if (propName.equalsIgnoreCase( "allowBadURIs" )) {
Boolean result = new Boolean( !demandGoodURIs );
demandGoodURIs = !getBoolean(propValue);
return result;
} else if (propName.equalsIgnoreCase("prettyTypes")) {
return setTypes((Resource[]) propValue);
} else if (propName.equalsIgnoreCase("relativeURIs")) {
int old = relativeFlags;
relativeFlags = str2flags((String) propValue);
return flags2str(old);
} else if (propName.equalsIgnoreCase("blockRules")) {
return setBlockRules(propValue);
} else {
logger.warn("Unsupported property: " + propName);
return null;
}
}
private String setAttributeQuoteChar(Object propValue) {
String oldValue = attributeQuoteChar;
if ( "\"".equals(propValue) || "'".equals(propValue) )
attributeQuoteChar = (String)propValue;
else
logger.warn("attributeQutpeChar must be either \"\\\"\" or \', not \""+propValue+"\"" );
return oldValue;
}
private Integer setWidth(Object propValue) {
Integer oldValue = new Integer(width);
if (propValue instanceof Integer) {
width = ((Integer) propValue).intValue();
} else {
try {
width = Integer.parseInt((String) propValue);
} catch (Exception e) {
logger.warn( "Bad value for width: '" + propValue + "' [" + e.getMessage() + "]" );
}
}
return oldValue;
}
private Integer setTab(Object propValue) {
Integer result = new Integer(tabSize);
if (propValue instanceof Integer) {
tabSize = ((Integer) propValue).intValue();
} else {
try {
tabSize = Integer.parseInt((String) propValue);
} catch (Exception e) {
logger.warn( "Bad value for tab: '" + propValue + "' [" + e.getMessage() + "]" );
}
}
return result;
}
private String setShowDoctypeDeclaration( Object propValue )
{
String oldValue = showDoctypeDeclaration.toString();
showDoctypeDeclaration = getBooleanValue( propValue, Boolean.FALSE );
return oldValue;
}
private String setShowXmlDeclaration( Object propValue )
{
String oldValue = showXmlDeclaration == null ? null : showXmlDeclaration.toString();
showXmlDeclaration = getBooleanValue( propValue, null );
return oldValue;
}
/**
Answer the boolean value corresponding to o, which must either be a Boolean,
or a String parsable as a Boolean.
*/
static private boolean getBoolean( Object o )
{ return getBooleanValue( o, Boolean.FALSE ).booleanValue(); }
private static Boolean getBooleanValue( Object propValue, Boolean theDefault )
{
if (propValue == null)
return theDefault;
else if (propValue instanceof Boolean)
return (Boolean) propValue;
else if (propValue instanceof String)
return stringToBoolean( (String) propValue, theDefault );
else
throw new JenaException( "cannot treat as boolean: " + propValue );
}
private static Boolean stringToBoolean( String b, Boolean theDefault )
{
if (b.equals( "default" )) return theDefault;
if (b.equalsIgnoreCase( "true" )) return Boolean.TRUE;
if (b.equalsIgnoreCase( "false" )) return Boolean.FALSE;
throw new BadBooleanException( b );
}
Resource[] setTypes( Resource x[] ) {
logger.warn( "prettyTypes is not a property on the Basic RDF/XML writer." );
return null;
}
private Resource blockedRules[] = new Resource[]{RDFSyntax.propertyAttr};
Resource[] setBlockRules(Object o) {
Resource rslt[] = blockedRules;
unblockAll();
if (o instanceof Resource[]) {
blockedRules = (Resource[]) o;
} else {
StringTokenizer tkn = new StringTokenizer((String) o, ", ");
Vector<Resource> v = new Vector<>();
while (tkn.hasMoreElements()) {
String frag = tkn.nextToken();
// System.err.println("Blocking " + frag);
v.add(new ResourceImpl(RDFSyntax.getURI() + frag));
}
blockedRules = new Resource[v.size()];
v.copyInto(blockedRules);
}
for ( Resource blockedRule : blockedRules )
{
blockRule( blockedRule );
}
return rslt;
}
/*
private boolean sameDocument = true;
private boolean network = false;
private boolean absolute = true;
private boolean relative = true;
private boolean parent = true;
private boolean grandparent = false;
*/
private int relativeFlags =
IRI.SAMEDOCUMENT | IRI.ABSOLUTE | IRI.CHILD | IRI.PARENT;
/**
Answer the form of the URI after relativisation according to the relativeFlags set
by properties. If the flags are 0 or the base URI is null, answer the original URI.
Throw an exception if the URI is "bad" and we demandGoodURIs.
*/
protected String relativize( String uri ) {
return relativeFlags != 0 && baseURI != null
? relativize( baseURI, uri )
: checkURI( uri );
}
/**
Answer the relative form of the URI against the base, according to the relativeFlags.
*/
private String relativize( IRI base, String uri ) {
// errors?
return base.relativize( uri, relativeFlags).toString();
}
/**
Answer the argument URI, but if we demandGoodURIs and it isn't good, throw
a JenaException that encapsulates a MalformedURIException. There doesn't
appear to be a convenient URI.checkGood() kind of method, alas.
*/
private String checkURI( String uri ) {
if (demandGoodURIs) {
IRI iri = factory.create( uri );
if (iri.hasViolation(false) )
throw new BadURIException( "Only well-formed absolute URIrefs can be included in RDF/XML output: "
+ (iri.violations(false).next()).getShortMessage());
}
return uri;
}
/**
Answer true iff prefix is a "legal" prefix to use, ie, is empty [for the default namespace]
or an NCName that does not start with "xml" and does not match the reserved-to-Jena
pattern.
*/
private boolean checkLegalPrefix( String prefix ) {
if (prefix.equals(""))
return true;
if (prefix.toLowerCase().startsWith( "xml" ))
logger.warn( "Namespace prefix '" + prefix + "' is reserved by XML." );
else if (!XMLChar.isValidNCName(prefix))
logger.warn( "'" + prefix + "' is not a legal namespace prefix." );
else if (jenaNamespace.matcher(prefix).matches())
logger.warn( "Namespace prefix '" + prefix + "' is reserved by Jena." );
else
return true;
return false;
}
static private String flags2str(int f) {
StringBuffer oldValue = new StringBuffer(64);
if ( (f&IRI.SAMEDOCUMENT)!=0 )
oldValue.append( "same-document, " );
if ( (f&IRI.NETWORK)!=0 )
oldValue.append( "network, ");
if ( (f&IRI.ABSOLUTE)!=0 )
oldValue.append("absolute, ");
if ( (f&IRI.CHILD)!=0 )
oldValue.append("relative, ");
if ((f&IRI.PARENT)!=0)
oldValue.append("parent, ");
if ((f&IRI.GRANDPARENT)!=0)
oldValue.append("grandparent, ");
if (oldValue.length() > 0)
oldValue.setLength(oldValue.length()-2);
return oldValue.toString();
}
public static int str2flags(String pv){
StringTokenizer tkn = new StringTokenizer(pv,", ");
int rslt = 0;
while ( tkn.hasMoreElements() ) {
String flag = tkn.nextToken();
if ( flag.equals("same-document") )
rslt |= IRI.SAMEDOCUMENT;
else if ( flag.equals("network") )
rslt |= IRI.NETWORK;
else if ( flag.equals("absolute") )
rslt |= IRI.ABSOLUTE;
else if ( flag.equals("relative") )
rslt |= IRI.CHILD;
else if ( flag.equals("parent") )
rslt |= IRI.PARENT;
else if ( flag.equals("grandparent") )
rslt |= IRI.GRANDPARENT;
else
logger.warn(
"Incorrect property value for relativeURIs: " + flag
);
}
return rslt;
}
}