You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by bu...@apache.org on 2013/01/01 16:42:12 UTC
svn commit: r844520 - in /websites/staging/jena/trunk/content: ./
documentation/io/arp.html documentation/io/arp_howto.html
documentation/io/index.html documentation/io/rdf-output.html
documentation/io/rdfxml_howto.html
Author: buildbot
Date: Tue Jan 1 15:42:12 2013
New Revision: 844520
Log:
Staging update by buildbot for jena
Added:
websites/staging/jena/trunk/content/documentation/io/rdfxml_howto.html
Removed:
websites/staging/jena/trunk/content/documentation/io/arp_howto.html
Modified:
websites/staging/jena/trunk/content/ (props changed)
websites/staging/jena/trunk/content/documentation/io/arp.html
websites/staging/jena/trunk/content/documentation/io/index.html
websites/staging/jena/trunk/content/documentation/io/rdf-output.html
Propchange: websites/staging/jena/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Tue Jan 1 15:42:12 2013
@@ -1 +1 @@
-1427439
+1427445
Modified: websites/staging/jena/trunk/content/documentation/io/arp.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/arp.html (original)
+++ websites/staging/jena/trunk/content/documentation/io/arp.html Tue Jan 1 15:42:12 2013
@@ -156,7 +156,7 @@
<p>This section details the Jena RDF/XML parser.
ARP is the parsing subsystem in Jena for handling the RDF/XML syntax.</p>
<ul>
-<li><a href="arp_howto.html">Using ARP</a></li>
+<li><a href="rdfxml_howto.html">Using ARP</a></li>
<li><a href="arp_features.html">ARP Features</a></li>
<li><a href="arp_standalone.html">Using ARP without Jena</a></li>
<li><a href="arp_sax.html">Using other SAX and DOM XML sources</a></li>
Modified: websites/staging/jena/trunk/content/documentation/io/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/io/index.html Tue Jan 1 15:42:12 2013
@@ -154,24 +154,24 @@
<div id="content">
<h1 class="title">Reading RDF in Jena</h1>
<p>This page details the setup of RDF I/O technology (RIOT) introduced in Jena 2.10.</p>
-<p>The output capabilities are described <a href="#rdf-output.html">elsewhere</a>.</p>
+<p>The output capabilities are described <a href="rdf-output.html">elsewhere</a>.</p>
<ul>
<li><a href="#formats">Formats</a></li>
-<li><a href="#command_line_tools">Commands</a></li>
+<li><a href="#command-line-tools">Commands</a></li>
<li><a href="#inference">Inference</a></li>
<li><a href="#api">API</a></li>
-<li><a href="#determining_the_rdf_syntax">Determining the RDF syntax</a></li>
-<li><a href="#example_1___common_usage">Common usage</a></li>
-<li><a href="##example_2___using_the_rdfdatamgr">Using the RDFDataMgr</a></li>
+<li><a href="#determining-the-rdf-syntax">Determining the RDF syntax</a></li>
+<li><a href="#example-1-common-usage">Common usage</a></li>
+<li><a href="##example-2-using-the-rdfdatamgr">Using the RDFDataMgr</a></li>
<li><a href="#logging">Logging</a></li>
-<li><a href="#">The StreamManager and LocationMapper</a></li>
-<li><a href="#configuring_the_streammanager">Configuring the <code>StreamManager</code></a></li>
-<li><a href="#configuring_a_locationmapper">Configuring a <code>LocationMapper</code></a></li>
-<li><a href="#add_a_new_language">Add a new language</a></li>
-<li><a href="#advanced_examples">Advanced examples</a></li>
+<li><a href="#streammanager-and-locationmapper">The StreamManager and LocationMapper</a></li>
+<li><a href="#configuring-a-streammanager">Configuring the <code>StreamManager</code></a></li>
+<li><a href="#configuring-a-locationmapper">Configuring a <code>LocationMapper</code></a></li>
+<li><a href="#add-a-new-language">Add a new language</a></li>
+<li><a href="#advanced-examples">Advanced examples</a></li>
</ul>
<p>Full details of operations are given in the javadoc.</p>
-<h1 id="formats">Formats</h1>
+<h2 id="formats">Formats</h2>
<p>The following RDF formats are supported by Jena. In addition, other syntaxes
can be integrated into the parser framework.</p>
<ul>
@@ -186,7 +186,7 @@ can be integrated into the parser framew
See the <a href="rdf-json.html">description of RDF/JSON</a>.</p>
<p>See also the <a href="arp.html">RDF/XML specific documentation</a> for configuration
of the RDF/XML parser.</p>
-<h1 id="command-line-tools">Command line tools</h1>
+<h2 id="command-line-tools">Command line tools</h2>
<p>There are scripts in Jena download to run these commands.</p>
<ul>
<li><code>riot</code> - parse, guessing the syntax from the file extension.
@@ -195,14 +195,40 @@ of the RDF/XML parser.</p>
</ul>
<p>These can be called directly as Java programs:</p>
<p>The file extensions are:</p>
-<p>| Extension | Language |
-|===========|==========|
-| <code>.nt</code> | N-triples |
-| <code>.ttl</code> | Turtle |
-| <code>.nq</code> | N-Quads |
-| <code>.trig</code> | TriG |
-| <code>.rdf</code> | RDF/XML |
-| <code>.owl</code> | RDF/XML |</p>
+<table>
+<thead>
+<tr>
+<th>Extension</th>
+<th>Language</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>.nt</code></td>
+<td>N-triples</td>
+</tr>
+<tr>
+<td><code>.ttl</code></td>
+<td>Turtle</td>
+</tr>
+<tr>
+<td><code>.nq</code></td>
+<td>N-Quads</td>
+</tr>
+<tr>
+<td><code>.trig</code></td>
+<td>TriG</td>
+</tr>
+<tr>
+<td><code>.rdf</code></td>
+<td>RDF/XML</td>
+</tr>
+<tr>
+<td>\ <code>.owl</code></td>
+<td>RDF/XML</td>
+</tr>
+</tbody>
+</table>
<p>In addition, if the extension is .gz the file is assumed to be gzip
compressed. The file name is examined for an inner extension. For
example, <code>.nt.gz</code> is gzip compressed N-Triples.</p>
@@ -224,7 +250,7 @@ utility which reads a file of bytes as U
<ul>
<li><code>utf8</code> -- read bytes as UTF8</li>
</ul>
-<h1 id="inference">Inference</h1>
+<h2 id="inference">Inference</h2>
<p>RIOT support creation of inferred triples during the parsing
process:</p>
<div class="codehilite"><pre><span class="n">riotcmd</span><span class="o">.</span><span class="n">infer</span> <span class="o">--</span><span class="n">rdfs</span> <span class="n">VOCAB</span> <span class="n">FILE</span> <span class="n">FILE</span> <span class="o">...</span>
@@ -233,7 +259,7 @@ process:</p>
<p>Output will contain the base data and triples inferred based on
subclass, subproperty, domain and range.</p>
-<h1 id="api">API</h1>
+<h2 id="api">API</h2>
<p>Much of the functionality is accessed via the Jena Model API; direct
calling of the RIOT subsystem isn't needed. A resource name
with no URI scheme is assumed to be a local file name.</p>
@@ -269,7 +295,7 @@ with no URI scheme is assumed to be a lo
</tr>
</tbody>
</table>
-<h2 id="determining-the-rdf-syntax">Determining the RDF syntax</h2>
+<h3 id="determining-the-rdf-syntax">Determining the RDF syntax</h3>
<p>The syntax of the RDF file is determined by the content type (if an HTTP
request), then the file extension if there is no content type (or it's
<code>text/plain</code>), which is assumed to be type returned for an unconfigured
@@ -287,7 +313,7 @@ http server. The application can also pa
</pre></div>
-<h2 id="example-1-common-usage">Example 1 : Common usage</h2>
+<h3 id="example-1-common-usage">Example 1 : Common usage</h3>
<p>In this example, a file in the current directory is read as Turtle.</p>
<p>Model model = ModelFactory.createDefaultModel() ;
model.read("data.ttl") ;</p>
@@ -296,7 +322,7 @@ http server. The application can also pa
</pre></div>
-<h2 id="example-2-using-the-rdfdatamgr">Example 2 : Using the RDFDataMgr</h2>
+<h3 id="example-2-using-the-rdfdatamgr">Example 2 : Using the RDFDataMgr</h3>
<p>In versions of Jena priot to 2.10.0, the <code>FileManager</code> provided some of
this functionality. It was more basic, and not properly web enabled. The
<code>RDFDataMgr</code> superceeds the <code>FileManager</code>. "load*" operations create an
@@ -315,10 +341,10 @@ add data into an existing model or datas
</pre></div>
-<h1 id="logging">Logging</h1>
+<h2 id="logging">Logging</h2>
<p>The parsers log to a logger called <code>org.aapche.jena.riot</code>. To avoid <code>WARN</code>
messages, set this in log4j.properties to <code>ERROR</code>.</p>
-<h1 id="the-streammanager-and-locationmapper">The StreamManager and LocationMapper</h1>
+<h2 id="streammanager-and-locationmapper">StreamManager and LocationMapper</h2>
<p>By default, the <code>RDFDataMgr</code> uses the global <code>StreamManager</code> to open typed
InputStreams. This is available to applications via <code>RDFDataMgr.open</code> as well as directly
using a <code>StreamManager</code>.</p>
@@ -334,7 +360,7 @@ data:</p>
<li>Class loader locator</li>
<li>Zip file locator</li>
</ul>
-<h2 id="configuring-the-streammanager">Configuring the <code>StreamManager</code></h2>
+<h3 id="configuring-a-streammanager">Configuring a <code>StreamManager</code></h3>
<p>The <code>StreamManager</code> can be reconfigured with different places to look for
files. The default configuration used for the global <code>StreamManager</code> is
a file access class, wihere the current directory is that of the java
@@ -344,7 +370,7 @@ either as the global set up, </p>
<p>There is also a <code>LocationMapper</code> for rewiting file names and URLs before
use to allow placing known names in different places (e.g. having local
copies of import http resources).</p>
-<h2 id="configuring-a-locationmapper">Configuring a <code>LocationMapper</code></h2>
+<h3 id="configuring-a-locationmapper">Configuring a <code>LocationMapper</code></h3>
<p>Location mapping files are RDF, usually written in Turtle although
an RDF syntax can be used.</p>
<div class="codehilite"><pre><span class="nv">@prefix</span> <span class="n">lm:</span> <span class="sr"><http://jena.hpl.hp.com/2004/08/location-mapping#></span>
@@ -399,12 +425,12 @@ configuration file is necessary.</p>
<li>org.apache.jena.riot.stream.StreamManager</li>
<li>org.apache.jena.riot.stream.LocationMapper</li>
</ul>
-<h1 id="advanced-examples">Advanced examples</h1>
-<h2 id="filter-the-output-of-parsing">Filter the output of parsing.</h2>
+<h2 id="advanced-examples">Advanced examples</h2>
+<h3 id="filter-the-output-of-parsing">Filter the output of parsing.</h3>
<p>When working with very large files, it can be useful to process the stream of triples or quads produced
by the parser so as to work in a streaming fashion.</p>
<p>See <a href="https://svn.apache.org/repos/asf/jena/trunk/jena-arq/src-examples/arq/examples/riot/ExRIOT_4.java">RIOT example 4</a></p>
-<h2 id="add-a-new-language">Add a new language</h2>
+<h3 id="add-a-new-language">Add a new language</h3>
<p>The set of languages is fixed - a new languages can be added to RIOT as shown in
<a href="https://svn.apache.org/repos/asf/jena/trunk/jena-arq/src-examples/arq/examples/riot/ExRIOT_5.java">RIOT example 5</a></p>
</div>
Modified: websites/staging/jena/trunk/content/documentation/io/rdf-output.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/rdf-output.html (original)
+++ websites/staging/jena/trunk/content/documentation/io/rdf-output.html Tue Jan 1 15:42:12 2013
@@ -153,7 +153,7 @@
<div id="content">
<h1 class="title">RDF Output</h1>
- <p>See the <a href="arp_howto.html">Jena RDF/XML How-To</a> for details of RDF/XML and
+ <p>See the <a href="rdfxml_howto.html#advanced-rdfxml-output">Jena RDF/XML How-To</a> for details of RDF/XML and
RDF/XML-ABBREV configuration.</p>
<h2 id="advanced-turtle-output">Advanced Turtle Output</h2>
<p>The Turtle pretty printer (which is used by default)Â and the Turtle plain
Added: websites/staging/jena/trunk/content/documentation/io/rdfxml_howto.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/rdfxml_howto.html (added)
+++ websites/staging/jena/trunk/content/documentation/io/rdfxml_howto.html Tue Jan 1 15:42:12 2013
@@ -0,0 +1,809 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<!--
+
+ 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.
+-->
+
+ <link href="/css/jena.css" rel="stylesheet" type="text/css">
+
+ <title>Apache Jena - Jena RDF/XML How-To</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+ <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js" type="text/javascript"></script>
+ <script src="/js/jena-navigation.js" type="text/javascript"></script>
+</head>
+
+<body>
+ <div id="header">
+ <div id="logoblock">
+ <img alt="Apache Jena" src="/images/jena-logo/jena-logo-small.png"/>
+ </div>
+
+ <div id="titleblock">
+ <h1 class="title">Apache Jena</h1>
+ <div id="topmenu" class="tabbar round-10">
+ <ul>
+ <li class="round-top-8"><a class="round-top-8" href="/index.html" id="home_menu">Home</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/help_and_support/index.html">Support</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/getting_started/index.html">Getting started</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/tutorials/index.html">Tutorials</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/documentation/index.html">Documentation</a></li>
+ </ul>
+ </div>
+ </div>
+ </div>
+
+ <div id="navigation" class="clear">
+ <h1 id="quick-links">Quick links</h1>
+<ul>
+<li><a href="/index.html">Home</a></li>
+<li><a href="/download/index.html">Downloads</a></li>
+<li><a href="/help_and_support/index.html">Help and support</a></li>
+<li><a href="/help_and_support/bugs_and_suggestions.html">Report a bug</a></li>
+<li><a href="/about_jena/roadmap.html">Roadmap</a></li>
+<li><a href="/getting_involved/index.html">Getting involved</a></li>
+<li><a href="/documentation/">Documentation</a></li>
+</ul>
+<h1 id="about-jena">About Jena</h1>
+<ul>
+<li><a href="/index.html">Home</a></li>
+<li><a href="/about_jena/about.html">About Jena</a></li>
+<li><a href="/about_jena/architecture.html">Architecture</a></li>
+<li><a href="/about_jena/roadmap.html">Roadmap</a></li>
+<li><a href="/about_jena/team.html">Project team</a></li>
+<li><a href="/about_jena/contributions.html">Related projects</a></li>
+</ul>
+<h1 id="download">Download</h1>
+<ul>
+<li><a href="/download/index.html">Downloading Jena</a></li>
+<li><a href="/download/maven.html">Using Maven</a></li>
+<li><a href="/download/osgi.html">Using OSGi</a></li>
+</ul>
+<h1 id="help-and-support">Help and support</h1>
+<ul>
+<li><a href="/help_and_support/index.html">Getting help</a></li>
+<li><a href="/help_and_support/bugs_and_suggestions.html">Bugs and suggestions</a></li>
+</ul>
+<h1 id="getting-started">Getting Started</h1>
+<ul>
+<li><a href="/getting_started/index.html">A first Jena project</a></li>
+<li><a href="/getting_started/rdf_api.html">RDF API overview</a></li>
+<li><a href="/getting_started/sparql.html">Querying RDF with SPARQL</a></li>
+<li><a href="/getting_started/fuseki.html">Serving RDF over HTTP</a></li>
+<li><a href="/getting_started/tell_me_how.html">Tell me how to ...</a></li>
+</ul>
+<h1 id="tutorials">Tutorials</h1>
+<ul>
+<li><a href="/tutorials/index.html">Tutorials index</a></li>
+<li><a href="/tutorials/rdf_api.html">RDF tutorial</a></li>
+<li><a href="/tutorials/sparql.html">SPARQL queries</a></li>
+<li><a href="/tutorials/using_jena_with_eclipse.html">Using Jena with Eclipse</a></li>
+</ul>
+<h1 id="documentation">Documentation</h1>
+<ul>
+<li><a href="/documentation/index.html">Overview</a></li>
+<li><a href="/documentation/javadoc/">Javadoc</a></li>
+<li><a href="/documentation/rdf/index.html">RDF</a></li>
+<li><a href="/documentation/io/index.html">I/O</a></li>
+<li><a href="/documentation/query/index.html">SPARQL (ARQ)</a><ul>
+<li><a href="/documentation/query/app_api.html">Application API</a></li>
+<li><a href="/documentation/query/cmds.html">Command line utilities</a></li>
+</ul>
+</li>
+<li><a href="/documentation/tdb/index.html">TDB</a><ul>
+<li><a href="/documentation/tdb/tdb_transactions.html">API for Transactions</a></li>
+<li><a href="/documentation/tdb/assembler.html">Dataset Assembler</a></li>
+</ul>
+</li>
+<li><a href="/documentation/serving_data/index.html">Fuseki: Serving Data</a></li>
+<li><a href="/documentation/ontology/index.html">Ontology</a></li>
+<li><a href="/documentation/inference/index.html">Inference</a></li>
+<li><a href="/documentation/assembler/index.html">Assembler</a><ul>
+<li><a href="/documentation/assembler/assembler-howto.html">Assembler how-to</a></li>
+<li><a href="/documentation/assembler/inside-assemblers.html">Inside assemblers</a></li>
+</ul>
+</li>
+<li><a href="/documentation/sdb/index.html">SDB</a></li>
+<li><a href="/documentation/larq/index.html">LARQ: Free Text Search</a></li>
+<li><a href="/documentation/notes/index.html">Notes</a><ul>
+<li><a href="/documentation/notes/concurrency-howto.html">Concurrency how-to</a></li>
+<li><a href="/documentation/notes/event-handler-howto.html">Event handler how-to</a></li>
+<li><a href="/documentation/notes/file-manager.html">File manager how-to</a></li>
+<li><a href="/documentation/notes/model-factory.html">Model factory how-to</a></li>
+<li><a href="/documentation/notes/rdf-frames.html">RDF frames</a></li>
+<li><a href="/documentation/notes/reification.html">Reification how-to</a></li>
+<li><a href="/documentation/notes/typed-literals.html">Typed literals how-to</a></li>
+<li><a href="/documentation/notes/iri.html">Support for IRI's</a></li>
+<li><a href="/documentation/notes/sse.html">SSE</a></li>
+</ul>
+</li>
+<li><a href="/documentation/tools/index.html">Tools</a><ul>
+<li><a href="/documentation/tools/schemagen.html">schemagen</a></li>
+<li><a href="/documentation/tools/eyeball-getting-started.html">eyeball</a></li>
+</ul>
+</li>
+</ul>
+<h1 id="getting-involved">Getting Involved</h1>
+<ul>
+<li><a href="/getting_involved/index.html">Contributing to Jena</a></li>
+</ul>
+<h1 id="asf-links">ASF links</h1>
+<ul>
+<li><a href="http://www.apache.org">Apache Software Foundation</a></li>
+<li><a href="http://www.apache.org/licenses/LICENSE-2.0">License</a></li>
+<li><a href="http://www.apache.org/foundation/thanks.html">Thanks</a></li>
+<li><a href="http://www.apache.org/foundation/sponsorship.html">Become a Sponsor</a></li>
+<li><a href="http://www.apache.org/security/">Security</a></li>
+</ul>
+ </div>
+
+ <div id="content">
+ <h1 class="title">Jena RDF/XML How-To</h1>
+ <p>This is a guide to the RDF/XML I/O subsystem of Jena, ARP.
+The first section gives a quick introduction to the
+I/O subsystem. The other sections are aimed at users wishing to use
+advanced features within the RDF/XML I/O subsystem.</p>
+<h2 id="contents">Contents</h2>
+<ul>
+<li><a href="#quick-introduction">Quick Introduction</a></li>
+<li><a href="#rdfxml-rdfxml-abbrev">RDF/XML, RDF/XML-ABBREV</a></li>
+<li><a href="#character-encoding-issues">Character Encoding Issues</a><ul>
+<li><a href="#encodings-supported-in-jena-22-and-later">Encodings Supported in Jena 2.2 and later</a></li>
+</ul>
+</li>
+<li><a href="#when-to-use-reader-and-writer">When to Use Reader and Writer?</a></li>
+<li><a href="#introduction-to-advanced-jena-io">Introduction to Advanced Jena I/O</a></li>
+<li><a href="#advanced-rdfxml-input">Advanced RDF/XML Input</a><ul>
+<li><a href="#arp-properties">ARP properties</a></li>
+<li><a href="#interrupting-arp">Interrupting ARP</a></li>
+</ul>
+</li>
+<li><a href="#advanced-rdfxml-output">Advanced RDF/XML Output</a></li>
+<li><a href="#conformance">Conformance</a></li>
+<li><a href="#faster-rdfxml-io">Faster RDF/XML I/O</a></li>
+</ul>
+<h2 id="quick-introduction">Quick Introduction</h2>
+<p>The main I/O methods in Jena use <code>InputStream</code>s and <code>OutputStream</code>s.
+This is import to correctly handle character sets.</p>
+<p>These methods are found on the
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> interface.
+These are:</p>
+<ul>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#read(java.io.InputStream, java.lang.String)"><code>read</code></a><code>(java.io.InputStream in, java.lang.String base)</code>
+ <br />Add statements from an RDF/XML serialization</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#read(java.io.InputStream, java.lang.String, java.lang.String)"><code>read</code></a><code>(java.io.InputStream in, java.lang.String base, java.lang.String lang)</code>
+ <br /> Add RDF statements represented in language <code>lang</code> to the model.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#read(java.lang.String)"><code>read</code></a><code>(java.lang.String url)</code>
+ <br />Add the RDF statements from an XML document.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#write(java.io.OutputStream)"><code>write</code></a><code>(java.io.OutputStream out)</code>
+ <br /> Write the model as an XML document.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#write(java.io.OutputStream, java.lang.String)"><code>write</code></a><code>(java.io.OutputStream out, java.lang.String lang)</code>
+ <br />Write a serialized representation of a model in a specified language.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#write(java.io.OutputStream, java.lang.String, java.lang.String)"><code>write</code></a><code>(java.io.OutputStream out, java.lang.String lang, java.lang.String base)</code>
+ <br />Write a serialized representation of a model in a specified language.</li>
+</ul>
+<p>The built-in languages are <code>"RDF/XML"</code>, <code>"RDF/XML-ABBREV"</code> as well as
+<code>"N-TRIPLE"</code>, and <code>"TURTLE"</code>.</p>
+<p>There are also methods which use <code>Reader</code>s and <code>Writer</code>s. Do not use
+them, unless you are sure it is correct to. In advanced
+applications, they are useful, see <a href="#reader-writer">below</a>; and
+there is every intention to continue to support them. The RDF/XML
+parser now checks to see if the <code>Model.read(Reader â¦)</code> calls
+are being abused, and issues
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#ERR_ENCODING_MISMATCH"><code>ERR_ENCODING_MISMATCH</code></a>
+and
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#WARN_ENCODING_MISMATCH"><code>WARN_ENCODING_MISMATCH</code></a>
+errors. Most incorrect usage of <code>Reader</code>s for RDF/XML input will
+result in such errors. Most incorrect usage of <code>Writer</code>s for RDF/XML
+output will produce correct XML by using an appropriate XML
+declaration giving the encoding - e.g.</p>
+<div class="codehilite"><pre><span class="sr"><?xml version='1.0' encoding='ISO-8859-15'?></span>
+</pre></div>
+
+
+<p>However, such XML is less portable than XML in UTF-8. Using the
+<code>Model.write(OutputStream â¦)</code> methods allows the Jena system
+code to choose UTF-8 encoding, which is the best choice.</p>
+<h2 id="rdfxml-rdfxml-abbrev">RDF/XML, RDF/XML-ABBREV</h2>
+<p>For input, both of these are the same, and fully implement the
+<a href="http://www.w3.org/TR/rdf-syntax-grammar/">RDF Syntax Recommendation</a>,
+see <a href="#conformance">conformance</a>.</p>
+<p>For output, <code>"RDF/XML"</code>, produces regular output reasonably
+efficiently, but it is not readable. In contrast,
+<code>"RDF/XML-ABBREV"</code>, produces readable output without much regard to
+efficiency.</p>
+<p>All the readers and writers for RDF/XML are configurable, see
+below, <a href="#input">input</a> and <a href="#output">output</a>.</p>
+<h2 id="character-encoding-issues">Character Encoding Issues</h2>
+<p>The easiest way to not read or understand this section is always to
+use <code>InputStream</code>s and <code>OutputStream</code>s with Jena, and to never use
+<code>Reader</code>s and <code>Writer</code>s. If you do this, Jena will do the right thing,
+for the vast majority of users. If you have legacy code that uses
+<code>Reader</code>s and <code>Writer</code>s, or you have special needs with respect to
+encodings, then this section may be helpful. The last part of this
+section summarizes the character encodings supported by Jena.</p>
+<p>Character encoding is the way that characters are mapped to bytes,
+shorts or ints. There are many different character encodings.
+Within Jena, character encodings are important in their
+relationship to Web content, particularly RDF/XML files, which
+cannot be understood without knowing the character encoding, and in
+relationship to Java, which provides support for many character
+encodings.</p>
+<p>The Java approach to encodings is designed for ease of use on a
+single machine, which uses a single encoding; often being a
+one-byte encoding, e.g. for European languages which do not need
+thousands of different characters.</p>
+<p>The XML approach is designed for the Web which uses multiple
+encodings, and some of them requiring thousands of characters.</p>
+<p>On the Web, XML files, including RDF/XML files, are by default
+encoded in "UTF-8" (Unicode). This is always a good choice for
+creating content, and is the one used by Jena by default. Other
+encodings can be used, but may be less interoperable. Other
+encodings should be named using the canonical name registered at
+<a href="http://www.iana.org/assignments/character-sets">IANA</a>, but other
+systems have no obligations to support any of these, other than
+UTF-8 and UTF-16.</p>
+<p>Within Java, encodings appear primarily with the <code>InputStreamReader</code>
+and <code>OutputStreamWriter</code> classes, which convert between bytes and
+characters using a named encoding, and with their subclasses,
+<code>FileReader</code> and <code>FileWriter</code>, which convert between bytes in the file
+and characters using the default encoding of the platform. It is
+not possible to change the encoding used by a <code>Reader</code> or <code>Writer</code>
+while it is being used. The default encoding of the platform
+depends on a large range of factors. This default encoding may be
+useful for communicating with other programs on the same platform.
+Sometimes the default encoding is not registered at IANA, and so
+Jena application developers should not use the default encoding for
+Web content, but use UTF-8.</p>
+<h3 id="encodings-supported-in-jena-22-and-later">Encodings Supported in Jena 2.2 and later</h3>
+<p>On RDF/XML input any encoding supported by Java can be used. If
+this is not a canonical name registered at IANA a warning message
+is produced. Some encodings have better support in Java 1.5 than
+Java 1.4; for such encodings a warning message is produced on Java
+1.4, suggesting upgrading.</p>
+<p>On RDF/XML output any encoding supported by Java can be used, by
+constructing an <code>OutputStreamWriter</code> using that encoding, and using
+that for output. If the encoding is not registered at IANA then a
+warning message is produced. Some encodings have better support in
+Java 1.5 than Java 1.4; for such encodings a warning message is
+produced on Java 1.4, suggesting upgrading.</p>
+<p>Java can be configured either with or without a jar of extra
+encodings on the classpath. This jar is <code>charsets.jar</code> and sits in
+the <code>lib</code> directory of the Java Runtime. If this jar is not on your
+classpath then the range of encodings supported is fairly small.</p>
+<p>The encodings supported by Java are listed by Sun, for
+<a href="http://docs.oracle.com/javase/1.4.2/docs/guide/intl/encoding.doc.html">1.4.2</a>,
+and
+<a href="http://docs.oracle.com/javase/1.5.0/docs/guide/intl/encoding.doc.html">1.5.0</a>.
+For an encoding that is not in these lists it is possible to write
+your own transcoder as documented in the <code>java.nio.charset</code> package
+documentation.</p>
+<p>Earlier versions of Jena supported fewer encodings.</p>
+<h2 id="when-to-use-reader-and-writer">When to Use Reader and Writer?</h2>
+<p>Infrequently.</p>
+<p>Despite the character encoding issues, it is still sometimes
+appropriate to use <code>Reader</code>s and <code>Writer</code>s with Jena I/O. A good
+example is using <code>Reader</code>s and <code>Writer</code>s into <code>StringBuffer</code>s in memory.
+These do not need to be encoded and decoded so a character encoding
+does not need to be specified. Other examples are when an advanced
+user explicitly wishes to correctly control the encoding.</p>
+<ul>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#read(java.io.Reader, java.lang.String)"><code>read</code></a><code>(java.io.Reader reader, java.lang.String base)</code>
+<br />Using this method is often a mistake.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#read(java.io.Reader, java.lang.String, java.lang.String)"><code>read</code></a><code>(java.io.Reader reader, java.lang.String base, java.lang.String lang)</code>
+<br />Using this method is often a mistake.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#write(java.io.Writer)"><code>write</code></a><code>(java.io.Writer writer)</code>
+<br />Caution! Write the model as an XML document.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#write(java.io.Writer, java.lang.String)"><code>write</code></a><code>(java.io.Writer writer, java.lang.String lang)</code>
+<br /> Caution! Write a serialized representation of a model in a specified language.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#write(java.io.Writer, java.lang.String, java.lang.String)"><code>write</code></a><code>(java.io.Writer writer, java.lang.String lang, java.lang.String base)</code>
+<br /> Caution! Write a serialized representation of a model in a specified language.</li>
+</ul>
+<p>Incorrect use of these <code>read(Reader, â¦)</code> methods results in
+warnings and errors with RDF/XML and RDF/XML-ABBREV (except in a
+few cases where the incorrect use cannot be automatically
+detected). Incorrect use of the <code>write(Writer, â¦)</code> methods
+results in peculiar XML declarations such as
+<code><?xml version="1.0" encoding="WINDOWS-1252"?></code>. This would reflect
+that the character encoding you used (probably without realizing)
+in your Writer is registered with IANA under the name
+"WINDOWS-1252". The resulting XML is of reduced portability as a
+result. Glenn Marcy
+<a href="http://nagoya.apache.org/bugzilla/show_bug.cgi?id=4456">notes</a>:</p>
+<blockquote>
+<p>since UTF-8 and UTF-16 are the only encodings REQUIRED to be
+understood by all conformant XML processors, even ISO-8859-1 would
+technically be on shaky ground if not for the fact that it is in
+such widespread use that every reasonable XML processor supports
+it.With N-TRIPLE incorrect use is usually benign, since N-TRIPLE is
+ascii based.</p>
+</blockquote>
+<p>Character encoding issues of N3 are not well-defined; hence use of
+these methods may require changes in the future. Use of the
+InputStream and OutputStream methods will allow your code to work
+with future versions of Jena which do the right thing - whatever
+that is. Currently the OutputStream methods use UTF-8 encoding.</p>
+<h2 id="introduction-to-advanced-jena-io">Introduction to Advanced Jena I/O</h2>
+<p>The RDF/XML input and output is configurable.
+However, to configure it, it is necessary to access an <code>RDFReader</code> or
+<code>RDFWriter</code> object that remains hidden in the simpler interface
+above.</p>
+<p>The four vital calls in the <code>Model</code> interface are:</p>
+<ul>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html"><code>RDFReader</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReaderF.html#getReader()"><code>getReader</code></a><code>()</code>
+<br />Return an RDFReader instance for the default serialization language.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html"><code>RDFReader</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReaderF.html#getReader(java.lang.String)"><code>getReader</code></a><code>(java.lang.String lang)</code>
+<br />Return an RDFReader instance for the specified serialization language.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html"><code>RDFReader</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFWriterF.html#getWriter()"><code>getWriter</code></a><code>()</code>
+<br />Return an RDFWriter instance for the default serialization language.</li>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html"><code>RDFReader</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFWriterF.html#getWriter(java.lang.String)"><code>getWriter</code></a><code>(java.lang.String lang)</code>
+<br />An RDFWriter instance for the specified serialization language.</li>
+</ul>
+<p>Each of these calls returns an <code>RDFReader</code> or <code>RDFWriter</code> that can be
+used to read or write any <code>Model</code> (not just the one which created
+it). As well as the necessary
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html#read(com.hp.hpl.jena.rdf.model.Model, java.io.InputStream, java.lang.String)"><code>read</code></a>
+and
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFWriter.html#write(com.hp.hpl.jena.rdf.model.Model, java.io.OutputStream, java.lang.String)"><code>write</code></a>
+methods, these interfaces provide:</p>
+<ul>
+<li><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFErrorHandler.html"><code>RDFErrorHandler</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html#setErrorHandler(com.hp.hpl.jena.rdf.model.RDFErrorHandler)"><code>setErrorHandler</code></a><code>(</code> <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFErrorHandler.html">RDFErrorHandler</a> <code>errHandler )</code>
+<br />Set an error handler for the reader</li>
+<li><code>java.lang.Object</code>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html#setProperty(java.lang.String, java.lang.Object)"><code>setProperty</code></a><code>(java.lang.String propName, java.lang.Object propValue)</code>
+<br />Set the value of a reader property.</li>
+</ul>
+<p>Setting properties, or the error handler, on an <code>RDFReader</code> or an
+<code>RDFWriter</code> allows the programmer to access non-default behaviour.
+Moreover, since the <code>RDFReader</code> and <code>RDFWriter</code> is not bound to a
+specific <code>Model</code>, a typical idiom is to create the <code>RDFReader</code> or
+<code>RDFWriter</code> on system initialization, to set the appropriate
+properties so that it behaves exactly as required in your application,
+and then to do all subsequent I/O through it.</p>
+<div class="codehilite"><pre><span class="n">Model</span> <span class="n">m</span> <span class="o">=</span> <span class="n">Modelfactory</span><span class="o">.</span><span class="n">createDefaultModel</span><span class="p">();</span>
+<span class="n">RDFWriter</span> <span class="n">writer</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">getRDFWriter</span><span class="p">();</span>
+<span class="n">m</span> <span class="o">=</span> <span class="n">null</span><span class="p">;</span> <span class="sr">//</span> <span class="n">m</span> <span class="n">is</span> <span class="nb">no</span> <span class="n">longer</span> <span class="n">needed</span><span class="o">.</span>
+<span class="n">writer</span><span class="o">.</span><span class="n">setErrorHandler</span><span class="p">(</span><span class="n">myErrorHandler</span><span class="p">);</span>
+<span class="n">writer</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"showXmlDeclaration"</span><span class="p">,</span><span class="s">"true"</span><span class="p">);</span>
+<span class="n">writer</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"tab"</span><span class="p">,</span><span class="s">"8"</span><span class="p">);</span>
+<span class="n">writer</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"relativeURIs"</span><span class="p">,</span><span class="s">"same-document,relative"</span><span class="p">);</span>
+<span class="err">â¦</span>
+<span class="n">Model</span> <span class="n">marray</span><span class="o">[]</span><span class="p">;</span>
+<span class="err">â¦</span>
+<span class="k">for</span> <span class="p">(</span><span class="nb">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i</span><span class="o"><</span><span class="n">marray</span><span class="o">.</span><span class="nb">length</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
+<span class="err">â¦</span>
+ <span class="n">OutputStream</span> <span class="n">out</span> <span class="o">=</span> <span class="k">new</span> <span class="n">FileOutputStream</span><span class="p">(</span><span class="s">"foo"</span> <span class="o">+</span> <span class="n">i</span> <span class="o">+</span> <span class="s">".rdf"</span><span class="p">);</span>
+ <span class="n">writer</span><span class="o">.</span><span class="nb">write</span><span class="p">(</span><span class="n">marray</span><span class="p">[</span><span class="n">i</span><span class="p">],</span>
+ <span class="n">out</span><span class="p">,</span>
+ <span class="s">"http://example.org/"</span><span class="p">);</span>
+ <span class="n">out</span><span class="o">.</span><span class="nb">close</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>Note that all of the current implementations are synchronized, so
+that a specific <code>RDFReader</code> cannot be reading two different documents
+at the same time. In a multi-threaded application this may suggest a
+need for a pool of <code>RDFReader</code>s and/or <code>RDFWriter</code>s, or alternatively
+to create, initialize, use and discard them as needed.</p>
+<p>For N-TRIPLE there are currently no properties supported for
+either the <code>RDFReader</code> or the <code>RDFWriter</code>. Hence this idiom above is
+not very helpful, and just using the <code>Model.write()</code> methods may
+prove easier.</p>
+<p>For RDF/XML and RDF/XML-ABBREV, there are many options in both the
+<code>RDFReader</code> and the <code>RDFWriter</code>. N3 has options on the <code>RDFWriter</code>. These
+options are detailed below. For RDF/XML they are also found in the
+JavaDoc for
+<code>JenaReader.</code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/JenaReader.html#setProperty(java.lang.String, java.lang.Object)"><code>setProperty</code></a><code>(String, Object)</code>
+and
+<code>RDFXMLWriterI.</code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/xmloutput/RDFXMLWriterI.html#setProperty(java.lang.String, java.lang.Object)"><code>setProperty</code></a><code>(String, Object)</code>.</p>
+<h2 id="advanced-rdfxml-input">Advanced RDF/XML Input</h2>
+<p>For access to these advanced features, first get an <code>RDFReader</code>
+object that is an instance of an ARP parser, by using the
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReaderF.html#getReader()"><code>getReader</code></a><code>()</code>
+method on any <code>Model</code>. It is then configured using the
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/JenaReader.html#setProperty(java.lang.String, java.lang.Object)"><code>setProperty</code></a><code>(String, Object)</code>
+method. This changes the properties for parsing RDF/XML. Many of
+the properties change the RDF parser, some change the XML parser.
+(The Jena RDF/XML parser, ARP, implements the
+<a href="http://www.w3.org/TR/rdf-syntax-grammar/#section-Infoset-Grammar">RDF grammar</a>
+over a <a href="http://xml.apache.org/xerces2-j/index.html">Xerces2-J</a> XML
+parser). However, changing the features and properties of the XML
+parser is not likely to be useful, but was easy to implement.</p>
+<p><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/JenaReader.html#setProperty(java.lang.String, java.lang.Object)"><code>setProperty</code></a><code>(String, Object)</code>
+can be used to set and get:</p>
+<ul>
+<li>ARP properties
+ <br /> These allow fine grain control over the extensive error
+ reporting capabilities of ARP. And are detailed directly below.</li>
+<li>SAX2 features
+ <br />See
+ <a href="http://xml.apache.org/xerces2-j/features.html">Xerces features</a>.
+ Value should be given as a String <code>"true"</code> or <code>"false"</code> or a <code>Boolean</code>.</li>
+<li>SAX2 properties
+ <br /> See <a href="http://xml.apache.org/xerces2-j/properties.html">Xerces properties</a>.</li>
+<li>Xerces features
+ <br /> See <a href="http://xml.apache.org/xerces2-j/features.html">Xerces features</a>.
+ Value should be given as a String <code>"true"</code> or <code>"false"</code> or a <code>Boolean</code>.</li>
+<li>Xerces properties
+ <br /> See <a href="http://xml.apache.org/xerces2-j/properties.html">Xerces properties</a>.</li>
+</ul>
+<h3 id="arp-properties">ARP properties</h3>
+<p>An ARP property is referred to either by its property name, (see
+below) or by an absolute URL of the form
+<code>http://jena.hpl.hp.com/arp/properties/<PropertyName></code>. The value
+should be a String, an Integer or a Boolean depending on the
+property.</p>
+<p>ARP property names and string values are case insensitive.</p>
+<table>
+<thead>
+<tr>
+<th>Property Name</th>
+<th>Description</th>
+<th>Value class</th>
+<th>Legal Values</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>iri-rules</code></td>
+<td>Set the engine for checking and resolving. <code>"strict"</code> sets the IRI engine with rules for valid IRIs, XLink and RDF; it does not permit spaces in IRIs. <code>"iri"</code>sets the IRI engine to IRI (<a href="http://www.ietf.org/rfc/rfc3986.txt">RFC 3986</a>, <a href="http://www.ietf.org/rfc/rfc3987.txt">RFC 3987</a>) <code>.</code> The default is <code>"lax"</code>(for backwards compatibility)<code>,</code> the rules for RDF URI references only, which does permit spaces although the use of spaces is not good practice.</td>
+<td>String</td>
+<td><code>lax</code><br /><code>strict</code><br /><code>iri</code></td>
+</tr>
+<tr>
+<td><code>error-mode</code></td>
+<td><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPOptions.html#setDefaultErrorMode()"><code>ARPOptions.setDefaultErrorMode()</code></a> <br /><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPOptions.html#setLaxErrorMode()"><code>ARPOptions.setLaxErrorMode()</code></a><br /><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPOptions.html#setStrictErrorMode()"><code>ARPOptions.setStrictErrorMode()</code></a><br /><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPOptions.html#setStrictErrorMode(int)"><code>ARPOptions.setStrictErrorMode(int)</code></a><br /> This allows a coarse-grained approach to control of error handling. Setting this property is equivalent to setting many of the fine-grained error handling properties.</td>
+<td><code>String</code></td>
+<td><code>default</code><br /><code>lax</code><br /><code>strict</code><br /><code>strict-ignore</code><br /><code>strict-warning</code><br /><code>strict-error</code><br /><code>strict-fatal</code></td>
+</tr>
+<tr>
+<td><code>embedding</code></td>
+<td><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPOptions.html#setEmbedding(boolean)"><code>ARPOptions.setEmbedding(boolean)</code></a> <br />This sets ARP to look for RDF embedded within an enclosing XML document.</td>
+<td><code>String</code> or <code>Boolean</code></td>
+<td><code>true</code><br /><code>false</code></td>
+</tr>
+<tr>
+<td><code>ERR_<XXX></code> <br /><code>WARN_<XXX></code><br /><code>IGN_<XXX></code></td>
+<td>See <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html"><code>ARPErrorNumbers</code></a> for a complete list of the error conditions detected. Setting one of these properties is equivalent to the method <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPOptions.html#setErrorMode(int,%20int)"><code>ARPOptions.setErrorMode(int, int)</code></a>. Thus fine-grained control over the behaviour in response to specific error conditions is possible.</td>
+<td><code>String</code> or <code>Integer</code></td>
+<td><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#EM_IGNORE"><code>EM_IGNORE</code></a><br /><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#EM_WARNING"><code>EM_WARNING</code></a><br /><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#EM_ERROR"><code>EM_ERROR</code></a><br /><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#EM_FATAL"><code>EM_FATAL</code></a></td>
+</tr>
+</tbody>
+</table>
+<p>As an example, if you are working in an environment with legacy RDF
+data that uses unqualified RDF attributes such as "about" instead
+of "rdf:about", then the following code is appropriate:</p>
+<div class="codehilite"><pre><span class="n">Model</span> <span class="n">m</span> <span class="o">=</span> <span class="n">Modelfactory</span><span class="o">.</span><span class="n">createDefaultModel</span><span class="p">();</span>
+<span class="n">RDFReader</span> <span class="n">arp</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">getReader</span><span class="p">();</span>
+<span class="n">m</span> <span class="o">=</span> <span class="n">null</span><span class="p">;</span> <span class="sr">//</span> <span class="n">m</span> <span class="n">is</span> <span class="nb">no</span> <span class="n">longer</span> <span class="n">needed</span><span class="o">.</span>
+<span class="sr">//</span> <span class="n">initialize</span> <span class="n">arp</span>
+<span class="sr">//</span> <span class="n">Do</span> <span class="ow">not</span> <span class="nb">warn</span> <span class="n">on</span> <span class="k">use</span> <span class="n">of</span> <span class="n">unqualified</span> <span class="n">RDF</span> <span class="n">attributes</span><span class="o">.</span>
+<span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"WARN_UNQUALIFIED_RDF_ATTRIBUTE"</span><span class="p">,</span><span class="s">"EM_IGNORE"</span><span class="p">);</span>
+
+<span class="err">â¦</span>
+
+<span class="n">InputStream</span> <span class="n">in</span> <span class="o">=</span> <span class="k">new</span> <span class="n">FileInputStream</span><span class="p">(</span><span class="n">fname</span><span class="p">);</span>
+<span class="n">arp</span><span class="o">.</span><span class="nb">read</span><span class="p">(</span><span class="n">m</span><span class="p">,</span><span class="n">in</span><span class="p">,</span><span class="n">url</span><span class="p">);</span>
+<span class="n">in</span><span class="o">.</span><span class="nb">close</span><span class="p">();</span>
+</pre></div>
+
+
+<p>As a second example, suppose you wish to work in strict mode, but
+allow <code>"daml:collection"</code>, the following works:</p>
+<div class="codehilite"><pre> <span class="err">â¦</span>
+ <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"error-mode"</span><span class="p">,</span> <span class="s">"strict"</span> <span class="p">);</span>
+ <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"IGN_DAML_COLLECTION"</span><span class="p">,</span><span class="s">"EM_IGNORE"</span><span class="p">);</span>
+ <span class="err">â¦</span>
+</pre></div>
+
+
+<p>The other way round does not work.</p>
+<div class="codehilite"><pre> <span class="err">â¦</span>
+ <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"IGN_DAML_COLLECTION"</span><span class="p">,</span><span class="s">"EM_IGNORE"</span><span class="p">);</span>
+ <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"error-mode"</span><span class="p">,</span> <span class="s">"strict"</span> <span class="p">);</span>
+ <span class="err">â¦</span>
+</pre></div>
+
+
+<p>This is because in strict mode
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#IGN_DAML_COLLECTION"><code>IGN_DAML_COLLECTION</code></a>
+is treated as an error, and so the second call to <code>setProperty</code>
+overwrites the effect of the first.</p>
+<p>The IRI rules and resolver can be set on a per-reader basis:</p>
+<div class="codehilite"><pre><span class="n">InputStream</span> <span class="n">in</span> <span class="o">=</span> <span class="o">...</span> <span class="p">;</span>
+<span class="n">String</span> <span class="n">baseURI</span> <span class="o">=</span> <span class="o">...</span> <span class="p">;</span>
+<span class="n">Model</span> <span class="n">model</span> <span class="o">=</span> <span class="n">Modelfactory</span><span class="o">.</span><span class="n">createDefaultModel</span><span class="p">();</span>
+<span class="n">RDFReader</span> <span class="n">r</span> <span class="o">=</span> <span class="n">model</span><span class="o">.</span><span class="n">getReader</span><span class="p">(</span><span class="s">"RDF/XML"</span><span class="p">);</span>
+<span class="n">r</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"iri-rules"</span><span class="p">,</span> <span class="s">"strict"</span><span class="p">)</span> <span class="p">;</span>
+<span class="n">r</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"error-mode"</span><span class="p">,</span> <span class="s">"strict"</span><span class="p">)</span> <span class="p">;</span> <span class="sr">//</span> <span class="n">Warning</span> <span class="n">will</span> <span class="n">be</span> <span class="n">errors</span><span class="o">.</span>
+
+<span class="sr">//</span> <span class="n">Alternative</span> <span class="n">to</span> <span class="n">the</span> <span class="n">above</span> <span class="s">"error-mode"</span><span class="p">:</span> <span class="n">set</span> <span class="n">specific</span> <span class="n">warning</span> <span class="n">to</span> <span class="n">be</span> <span class="n">an</span> <span class="n">error</span><span class="o">.</span>
+<span class="sr">//</span><span class="n">r</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span> <span class="s">"WARN_MALFORMED_URI"</span><span class="p">,</span> <span class="n">ARPErrorNumbers</span><span class="o">.</span><span class="n">EM_ERROR</span><span class="p">)</span> <span class="p">;</span>
+<span class="n">r</span><span class="o">.</span><span class="nb">read</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="n">in</span><span class="p">,</span> <span class="n">baseURI</span><span class="p">)</span> <span class="p">;</span>
+<span class="n">in</span><span class="o">.</span><span class="nb">close</span><span class="p">();</span>
+</pre></div>
+
+
+<p>The global default IRI engine can be set with:</p>
+<div class="codehilite"><pre><span class="n">ARPOptions</span><span class="o">.</span><span class="n">setIRIFactoryGlobal</span><span class="p">(</span><span class="n">IRIFactory</span><span class="o">.</span><span class="n">iriImplementation</span><span class="p">())</span> <span class="p">;</span>
+</pre></div>
+
+
+<p>or other IRI rule engine from <code>IRIFactory</code>.</p>
+<h3 id="interrupting-arp">Interrupting ARP</h3>
+<p>ARP can be interrupted using the <code>Thread.interrupt()</code> method. This
+causes an
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#ERR_INTERRUPTED"><code>ERR_INTERRUPTED</code></a>
+error during the parse, which is usually treated as a fatal error.</p>
+<p>Here is an illustrative code sample:</p>
+<div class="codehilite"><pre><span class="n">ARP</span> <span class="n">a</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ARP</span><span class="p">();</span>
+<span class="n">final</span> <span class="n">Thread</span> <span class="n">arpt</span> <span class="o">=</span> <span class="n">Thread</span><span class="o">.</span><span class="n">currentThread</span><span class="p">();</span>
+<span class="n">Thread</span> <span class="n">killt</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Thread</span><span class="p">(</span><span class="k">new</span> <span class="n">Runnable</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">public</span> <span class="n">void</span> <span class="n">run</span><span class="p">()</span> <span class="p">{</span>
+ <span class="n">try</span> <span class="p">{</span>
+ <span class="n">Thread</span><span class="o">.</span><span class="nb">sleep</span><span class="p">(</span><span class="n">tim</span><span class="p">);</span>
+ <span class="p">}</span> <span class="n">catch</span> <span class="p">(</span><span class="n">InterruptedException</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
+ <span class="p">}</span>
+ <span class="n">arpt</span><span class="o">.</span><span class="n">interrupt</span><span class="p">();</span>
+ <span class="p">}</span>
+ <span class="p">});</span>
+<span class="n">killt</span><span class="o">.</span><span class="n">start</span><span class="p">();</span>
+<span class="n">try</span> <span class="p">{</span>
+ <span class="n">in</span> <span class="o">=</span> <span class="k">new</span> <span class="n">FileInputStream</span><span class="p">(</span><span class="n">fileName</span><span class="p">);</span>
+ <span class="n">a</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="n">in</span><span class="p">);</span>
+ <span class="n">in</span><span class="o">.</span><span class="nb">close</span><span class="p">();</span>
+ <span class="n">fail</span><span class="p">(</span><span class="s">"Thread was not interrupted."</span><span class="p">);</span>
+<span class="p">}</span> <span class="n">catch</span> <span class="p">(</span><span class="n">SAXParseException</span> <span class="n">e</span><span class="p">)</span> <span class="p">{</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<h2 id="advanced-rdfxml-output">Advanced RDF/XML Output</h2>
+<p>The first RDF/XML output question is whether to use the <code>"RDF/XML"</code>
+or <code>"RDF/XML-ABBREV"</code> writer. While some of the code is shared, these
+two writers are really very different, resulting in different but
+equivalent output. <code>RDF/XML-ABBREV</code> is slower, but should produce
+more readable XML.</p>
+<p>For access to advanced features, first get an RDFWriter object, of
+the appropriate language, by using
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFWriterF.html#getWriter(java.lang.String)"><code>getWriter</code></a><code>("RDF/XML")</code>
+or
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFWriterF.html#getWriter(java.lang.String)"><code>getWriter</code></a><code>("RDF/XML-ABBREV")</code>
+on any <code>Model</code>. It is then configured using the
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/JenaReader.html#setProperty(java.lang.String, java.lang.Object)"><code>setProperty</code></a><code>(String, Object)</code>
+method. This changes the properties for writing RDF/XML.</p>
+<h3 id="properties-to-control-rdfxml-output">Properties to Control RDF/XML Output</h3>
+<p><table>
+<tr><th>Property Name</th><th>Description</th><th>Value class</th><th>Legal Values</th></tr>
+<tr>
+<td><code>xmlbase</code></td>
+<td>The value to be included for an xml:base attribute on the root element in the file.</td>
+<td><code>String</code></td>
+<td>A URI string, or null (default)</td>
+</tr>
+<tr>
+<td><code>longId</code></td>
+<td>Whether to use long or short id's for anon resources. Short id's are easier to read and are the default, but can run out of memory on very large models.</td>
+<td><code>String</code> or <code>Boolean</code></td>
+<td><code>"true"</code>, <code>"false"</code> (default)</td>
+</tr>
+<tr>
+<td><code>allowBadURIs</code></td>
+<td>URIs in the graph are, by default, checked prior to serialization.</td>
+<td><code>String</code> or <code>Boolean</code></td>
+<td><code>"true"</code>, <code>"false"</code> (default)</td>
+</tr>
+<tr>
+<td><code>relativeURIs</code></td>
+<td>What sort of relative URIs should be used. A comma separated list of options:</p>
+<ul>
+<li><em>same-document</em><br />
+ same-document references (e.g. "" or "#foo")</li>
+<li><em>network</em><br />
+ network paths e.g. <code>"//example.org/foo"</code> omitting the URI scheme</li>
+<li><em>absolute</em><br />
+ absolute paths e.g. <code>"/foo"</code> omitting the scheme and authority</li>
+<li><em>relative</em><br />
+ relative path not beginning in <code>"../"</code></li>
+<li><em>parent</em><br />
+ relative path beginning in <code>"../"</code></li>
+<li><em>grandparent</em><br />
+ relative path begining in <code>"../../"</code></li>
+</ul>
+<p>The default value is "same-document, absolute, relative, parent".
+To switch off relative URIs use the value "". Relative URIs of any
+of these types are output where possible if and only if the option
+has been specified.</td>
+<td>String</td>
+</tr>
+<tr>
+<td><code>showXmlDeclaration</code></td>
+<td>
+If true, an XML Declaration is included in the output, if false no XML declaration is included.
+The default behaviour only gives an XML Declaration when asked to write to an <code>OutputStreamWriter</code>
+that uses some encoding other than UTF-8 or UTF-16. In this case the encoding is shown in the
+XML declaration. To ensure that the encoding attribute is shown in the XML declaration either:</p>
+<ul>
+<li>Set this option to true and use the
+ <code>write(Model,Writer,String)</code> variant with an appropriate <code>OutputStreamWriter</code>.</li>
+<li>
+<p>Or set this option to false, and write the declaration to an <code>OutputStream</code> before calling
+ <code>write(Model,OutputStream,String)</code>.
+</td>
+<td><code>true</code>, <code>"true"</code>, <code>false</code>, <code>"false"</code> or <code>"default"</code></td>
+<td>can be true, false or "default" (null)</td>
+</tr>
+<tr>
+<td><code>showDoctypeDeclaration</code></td>
+<td>
+If true, an XML Doctype declaration is included in the output. This
+declaration includes a <code>!ENTITY</code> declaration for each prefix mapping
+in the model, and any attribute value that starts with the URI of
+that mapping is written as starting with the corresponding entity
+invocation.
+</td>
+<td><code>String</code> or <code>Boolean</code></td>
+<td><code>true</code>, <code>false</code>, <code>"true"</code>, <code>"false"</code></td>
+</tr>
+<tr>
+<td><code>tab</code></td>
+<td>The number of spaces with which to indent XML child elements.</td>
+<td><code>String</code> or <code>Integer</code></td>
+<td>positive integer "2" is the default</td>
+</tr>
+<tr>
+<td><code>attributeQuoteChar</code></td>
+<td>How to write XML attributes.</td>
+<td><code>String</code></td>
+<td><code>"\""</code> or <code>"'"</code></td>
+</tr>
+<tr>
+<td><code>blockRules</code></td>
+<td>
+A list of <code>Resource</code> or a <code>String</code> being a comma separated list of
+fragment IDs from <a href="http://www.w3.org/TR/rdf-syntax-grammar">http://www.w3.org/TR/rdf-syntax-grammar</a>
+indicating grammar rules that will not be used. Rules that can be blocked are:</p>
+</li>
+<li>
+<p><a href="http://www.w3.org/TR/rdf-syntax-grammar#section-Reification">section-Reification</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#sectionReification"><code>RDFSyntax.sectionReification</code></a>)</p>
+</li>
+<li><a href="http://www.w3.org/TR/rdf-syntax-grammar#section-List-Expand">section-List-Expand</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#sectionListExpand"><code>RDFSyntax.sectionListExpand</code></a>)</li>
+<li><a href="http://www.w3.org/TR/rdf-syntax-grammar#parseTypeLiteralPropertyElt">parseTypeLiteralPropertyElt</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#parseTypeLiteralPropertyElt"><code>RDFSyntax.parseTypeLiteralPropertyElt</code></a>)</li>
+<li><a href="http://www.w3.org/TR/rdf-syntax-grammar#parseTypeResourcePropertyElt">parseTypeResourcePropertyElt</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#parseTypeLiteralPropertyElt"><code>RDFSyntax.parseTypeLiteralPropertyElt</code></a>)</li>
+<li><a href="http://www.w3.org/TR/rdf-syntax-grammar#parseTypeCollectionPropertyElt">parseTypeCollectionPropertyElt</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#parseTypeCollectionPropertyElt"><code>RDFSyntax.parseTypeCollectionPropertyElt</code></a>)</li>
+<li><a href="http://www.w3.org/TR/rdf-syntax-grammar#idAttr">idAttr</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#idAttr"><code>RDFSyntax.idAttr</code></a>)</li>
+<li><a href="http://www.w3.org/TR/rdf-syntax-grammar#propertyAttr">propertyAttr</a>
+ (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#propertyAttr"><code>RDFSyntax.propertyAttr</code></a>)</li>
+</ul>
+<p>In addition <code>"daml:collection"</code>
+(<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/DAML_OIL.html#collection"><code>DAML_OIL.collection</code></a>)
+can be blocked. Blocking
+<a href="http://www.w3.org/TR/rdf-syntax-grammar#idAttr">idAttr</a> also
+blocks
+<a href="http://www.w3.org/TR/rdf-syntax-grammar#section-Reification">section-Reification</a>.
+By default, rule
+<a href="http://www.w3.org/TR/rdf-syntax-grammar#propertyAttr">propertyAttr</a>
+is blocked. For the basic writer (RDF/XML) only
+<a href="http://www.w3.org/TR/rdf-syntax-grammar#parseTypeLiteralPropertyElt">parseTypeLiteralPropertyElt</a>
+has any effect, since none of the other rules are implemented by
+that writer.
+</td>
+<td><code>Resource[]</code> or <code>String</code></td>
+<td></td>
+</tr>
+<tr>Â
+<td><code>prettyTypes</code></td>
+<td>
+Only for the RDF/XML-ABBREV writer. This is a list of the types of
+the principal objects in the model. The writer will tend to create
+RDF/XML with resources of these types at the top level.
+</td>
+<td>
+<code>Resource[]</code>
+</td>
+<td></td>
+</tr>
+</table>
+Â
+As an example,</p>
+<div class="codehilite"><pre><span class="n">RDFWriter</span> <span class="n">w</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">getWriter</span><span class="p">(</span><span class="s">"RDF/XML-ABBREV"</span><span class="p">);</span>
+<span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"attribtueQuoteChar"</span><span class="p">,</span><span class="s">"'"</span><span class="p">);</span>
+<span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"showXMLDeclaration"</span><span class="p">,</span><span class="s">"true"</span><span class="p">);</span>
+<span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"tab"</span><span class="p">,</span><span class="s">"1"</span><span class="p">);</span>
+<span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"blockRules"</span><span class="p">,</span>
+ <span class="s">"daml:collection,parseTypeLiteralPropertyElt,"</span>
+ <span class="o">+</span><span class="s">"parseTypeResourcePropertyElt,parseTypeCollectionPropertyElt"</span><span class="p">);</span>
+</pre></div>
+
+
+<p>creates a writer that does not use rdf:parseType (preferring
+rdf:datatype for rdf:XMLLiteral), indents only a little, and
+produces the XMLDeclaration. Attributes are used, and are quoted
+with <code>"'"</code>.</p>
+<p>Note that property attributes are not used at all, by default.
+However, the RDF/XML-ABBREV writer includes a rule to produce
+property attributes when the value does not contain any spaces.
+This rule is normally switched off. This rule can be turned on
+selectively by using the blockRules property as detailed above.</p>
+<h2 id="conformance">Conformance</h2>
+<p>The RDF/XML I/O endeavours to conform with the
+<a href="http://www.w3.org/TR/rdf-syntax-grammar/">RDF Syntax Recommendation</a>.</p>
+<p>The parser must be set to strict mode. (Note that, the conformant
+behaviour for <code>rdf:parseType="daml:collection"</code> is to silently turn
+<code>"daml:collection"</code> into <code>"Literal"</code>).</p>
+<p>The RDF/XML writer is conformant, but does not exercise much of the
+grammar.</p>
+<p>The RDF/XML-ABBREV writer exercises all of the grammar and is
+conformant except that it uses the <code>daml:collection</code> construct for
+DAML ontologies. This non-conformant behaviour can be switched off
+using the <code>blockRules</code> property.</p>
+<h2 id="faster-rdfxml-io">Faster RDF/XML I/O</h2>
+<p>To optimise the speed of writing RDF/XML it is suggested that all
+URI processing is turned off. Also do not use RDF/XML-ABBREV. It is
+unclear whether the longId attribute is faster or slower; the short
+IDs have to be generated on the fly and a table maintained during
+writing. The longer IDs are long, and hence take longer to write.
+The following creates a faster writer:</p>
+<div class="codehilite"><pre><span class="n">Model</span> <span class="n">m</span><span class="p">;</span>
+<span class="err">â¦</span>
+<span class="err">â¦</span>
+<span class="n">RDFWriter</span> <span class="n">fasterWriter</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">getWriter</span><span class="p">(</span><span class="s">"RDF/XML"</span><span class="p">);</span>
+<span class="n">fasterWriter</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"allowBadURIs"</span><span class="p">,</span><span class="s">"true"</span><span class="p">);</span>
+<span class="n">fasterWriter</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"relativeURIs"</span><span class="p">,</span><span class="s">""</span><span class="p">);</span>
+<span class="n">fasterWriter</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"tab"</span><span class="p">,</span><span class="s">"0"</span><span class="p">);</span>
+</pre></div>
+
+
+<p>When reading RDF/XML the check for reuse of rdf:ID has a memory
+overhead, which can be significant for very large files. In this
+case, this check can be suppressed by telling ARP to ignore this
+error.</p>
+<div class="codehilite"><pre><span class="n">Model</span> <span class="n">m</span><span class="p">;</span>
+<span class="err">â¦</span>
+<span class="err">â¦</span>
+<span class="n">RDFReader</span> <span class="n">bigFileReader</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">getReader</span><span class="p">(</span><span class="s">"RDF/XML"</span><span class="p">);</span>
+<span class="n">bigFileReader</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">"WARN_REDEFINITION_OF_ID"</span><span class="p">,</span><span class="s">"EM_IGNORE"</span><span class="p">);</span>
+<span class="err">â¦</span>
+</pre></div>
+ </div>
+
+ <div id="footer">
+ <div class="copyright">
+ <p>
+ Copyright © 2011–12 The Apache Software Foundation, Licensed under
+ the <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.
+ <br />
+ Apache Jena, Jena, the Apache Jena project logo,
+ Apache and the Apache feather logos are trademarks of The Apache Software Foundation.
+ </p>
+ </div>
+ </div>
+
+</body>
+</html>