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 2015/07/14 14:52:15 UTC
svn commit: r958279 [1/6] - in /websites/staging/jena/trunk/content: ./
about_jena/ documentation/ documentation/csv/ documentation/hadoop/
documentation/inference/ documentation/io/ documentation/jdbc/
documentation/notes/ documentation/ontology/ docu...
Author: buildbot
Date: Tue Jul 14 12:52:14 2015
New Revision: 958279
Log:
Staging update by buildbot for jena
Modified:
websites/staging/jena/trunk/content/ (props changed)
websites/staging/jena/trunk/content/about_jena/roadmap.html
websites/staging/jena/trunk/content/documentation/csv/design.html
websites/staging/jena/trunk/content/documentation/hadoop/index.html
websites/staging/jena/trunk/content/documentation/inference/index.html
websites/staging/jena/trunk/content/documentation/io/DOM2Jena.java
websites/staging/jena/trunk/content/documentation/io/arp_sax.html
websites/staging/jena/trunk/content/documentation/io/arp_standalone.html
websites/staging/jena/trunk/content/documentation/io/rdfxml_howto.html
websites/staging/jena/trunk/content/documentation/jdbc/index.html
websites/staging/jena/trunk/content/documentation/migrate_jena2_jena3.html
websites/staging/jena/trunk/content/documentation/notes/event-handler-howto.html
websites/staging/jena/trunk/content/documentation/notes/file-manager.html
websites/staging/jena/trunk/content/documentation/notes/iri.html
websites/staging/jena/trunk/content/documentation/notes/model-factory.html
websites/staging/jena/trunk/content/documentation/notes/rdf-frames.html
websites/staging/jena/trunk/content/documentation/notes/sse.html
websites/staging/jena/trunk/content/documentation/notes/typed-literals.html
websites/staging/jena/trunk/content/documentation/ontology/index.html
websites/staging/jena/trunk/content/documentation/query/algebra.html
websites/staging/jena/trunk/content/documentation/query/app_api.html
websites/staging/jena/trunk/content/documentation/query/architecture.html
websites/staging/jena/trunk/content/documentation/query/explain.html
websites/staging/jena/trunk/content/documentation/query/extension.html
websites/staging/jena/trunk/content/documentation/query/http-auth.html
websites/staging/jena/trunk/content/documentation/query/java-uri.html
websites/staging/jena/trunk/content/documentation/query/library-function.html
websites/staging/jena/trunk/content/documentation/query/library-propfunc.html
websites/staging/jena/trunk/content/documentation/query/logging.html
websites/staging/jena/trunk/content/documentation/query/parameterized-sparql-strings.html
websites/staging/jena/trunk/content/documentation/query/sparql-remote.html
websites/staging/jena/trunk/content/documentation/query/spatial-query.html
websites/staging/jena/trunk/content/documentation/query/support_request.html
websites/staging/jena/trunk/content/documentation/query/text-query.html
websites/staging/jena/trunk/content/documentation/query/writing_functions.html
websites/staging/jena/trunk/content/documentation/query/writing_propfuncs.html
websites/staging/jena/trunk/content/documentation/rdf/index.html
websites/staging/jena/trunk/content/documentation/sdb/dataset_description.html
websites/staging/jena/trunk/content/documentation/sdb/fuseki_integration.html
websites/staging/jena/trunk/content/documentation/serving_data/index.html
websites/staging/jena/trunk/content/documentation/tdb/assembler.html
websites/staging/jena/trunk/content/documentation/tdb/configuration.html
websites/staging/jena/trunk/content/documentation/tdb/optimizer.html
websites/staging/jena/trunk/content/documentation/tools/schemagen.html
websites/staging/jena/trunk/content/tutorials/rdf_api.html
websites/staging/jena/trunk/content/tutorials/rdf_api_pt.html
websites/staging/jena/trunk/content/tutorials/using_jena_with_eclipse_pt.html
Propchange: websites/staging/jena/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Tue Jul 14 12:52:14 2015
@@ -1 +1 @@
-1689619
+1690917
Modified: websites/staging/jena/trunk/content/about_jena/roadmap.html
==============================================================================
--- websites/staging/jena/trunk/content/about_jena/roadmap.html (original)
+++ websites/staging/jena/trunk/content/about_jena/roadmap.html Tue Jul 14 12:52:14 2015
@@ -144,14 +144,19 @@
<div class="col-md-12">
<div id="breadcrumbs"></div>
<h1 class="title">Jena Roadmap</h1>
- <p>There isn't an official roadmap yet. </p>
-<p>However, you can view a list of the <a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&jqlQuery=project+%3D+JENA+AND+status+%3D+Open+ORDER+BY+priority+DESC&mode=hide">open issues</a> on JIRA (sorted by priority).
+ <style type="text/css">
+/* The following code is added by mdx_elementid.py
+ It was originally lifted from http://subversion.apache.org/style/site.css */
+/*
+ * Hide class="elementid-permalink", except when an enclosing heading
+ * has the :hover property.
+ */
+.headerlink, .elementid-permalink {
+ visibility: hidden;
+}
+h2:hover > .headerlink, h3:hover > .headerlink, h1:hover > .headerlink, h6:hover > .headerlink, h4:hover > .headerlink, h5:hover > .headerlink, dt:hover > .elementid-permalink { visibility: visible }</style>
+<p>You can view a list of the <a href="https://issues.apache.org/jira/secure/IssueNavigator.jspa?reset=true&jqlQuery=project+%3D+JENA+AND+status+%3D+Open+ORDER+BY+priority+DESC&mode=hide">open issues</a> on JIRA (sorted by priority).
Or, you can look at the <a href="https://issues.apache.org/jira/secure/QuickSearch.jspa?searchString=jena+updated:-1w">last week activity</a> to get a sense of what people are working on.</p>
-<p>The following features are desired or expected, but are not yet underway:</p>
-<ul>
-<li>OWL 2 support in ontology API</li>
-<li>migrate package names from <code>com.hp</code> to <code>org.apache</code></li>
-</ul>
<p>Patches and other contributions welcome!</p>
</div>
</div>
Modified: websites/staging/jena/trunk/content/documentation/csv/design.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/csv/design.html (original)
+++ websites/staging/jena/trunk/content/documentation/csv/design.html Tue Jul 14 12:52:14 2015
@@ -144,14 +144,25 @@
<div class="col-md-12">
<div id="breadcrumbs"></div>
<h1 class="title">CSV PropertyTable - Design</h1>
- <h2 id="architecture">Architecture</h2>
+ <style type="text/css">
+/* The following code is added by mdx_elementid.py
+ It was originally lifted from http://subversion.apache.org/style/site.css */
+/*
+ * Hide class="elementid-permalink", except when an enclosing heading
+ * has the :hover property.
+ */
+.headerlink, .elementid-permalink {
+ visibility: hidden;
+}
+h2:hover > .headerlink, h3:hover > .headerlink, h1:hover > .headerlink, h6:hover > .headerlink, h4:hover > .headerlink, h5:hover > .headerlink, dt:hover > .elementid-permalink { visibility: visible }</style>
+<h2 id="architecture">Architecture<a class="headerlink" href="#architecture" title="Permanent link">¶</a></h2>
<p>The architecture of CSV PropertyTable mainly involves 2 components:</p>
<ul>
<li><a href="https://github.com/apache/jena/tree/master/jena-csv/src/main/java/org/apache/jena/propertytable/PropertyTable.java">PropertyTable</a></li>
<li><a href="https://github.com/apache/jena/tree/master/jena-csv/src/main/java/org/apache/jena/propertytable/impl/GraphPropertyTable.java">GraphPropertyTable</a></li>
</ul>
<p><img alt="Picture of architecture of jena-csv" src="jena-csv-architecture.png" title="Architecture of jena-csv" /></p>
-<h2 id="propertytable">PropertyTable</h2>
+<h2 id="propertytable">PropertyTable<a class="headerlink" href="#propertytable" title="Permanent link">¶</a></h2>
<p>A <code>PropertyTable</code> is collection of data that is sufficiently regular in shape it can be treated as a table.
That means each subject has a value for each one of the set of properties.
Irregularity in terms of missing values needs to be handled but not multiple values for the same property.
@@ -162,7 +173,7 @@ With special storage, a PropertyTable</p
<li>can guarantee access orders</li>
</ul>
<p>More explicitly, <code>PropertyTable</code> is designed to be a table of RDF terms, or
-<a href="https://github.com/apache/jena/tree/master/jena-core/src/main/java/com/hp/hpl/jena/graph/Node.java">Nodes</a> in Jena.
+<a href="https://github.com/apache/jena/tree/master/jena-core/src/main/java/org/apache/jena/graph/Node.java">Nodes</a> in Jena.
Each <a href="https://github.com/apache/jena/tree/master/jena-csv/src/main/java/org/apache/jena/propertytable/Column.java">Column</a> of the <code>PropertyTable</code> has an unique columnKey <code>Node</code> of the predicate (or p for short).
Each <a href="https://github.com/apache/jena/tree/master/jena-csv/src/main/java/org/apache/jena/propertytable/Row.java">Row</a> of the <code>PropertyTable</code> has an unique rowKey <code>Node</code> of the subject (or s for short).
You can use <code>getColumn()</code> to get the <code>Column</code> by its columnKey <code>Node</code> of the predicate, while <code>getRow()</code> for <code>Row</code>.</p>
@@ -173,37 +184,37 @@ You can use <code>getColumn()</code> to
<li>For each <code>Row</code> created, set a value (<code>Node</code>) at the specified <code>Column</code>, by calling <code>Row.setValue()</code></li>
</ol>
<p>Once a <code>PropertyTable</code> is built, tabular data within can be accessed by the API of <code>PropertyTable.getMatchingRows()</code>, <code>PropertyTable.getColumnValues()</code>, etc.</p>
-<h2 id="graphpropertytable">GraphPropertyTable</h2>
-<p><code>GraphPropertyTable</code> implements the <a href="https://github.com/apache/jena/tree/master/jena-core/src/main/java/com/hp/hpl/jena/graph/Graph.java">Graph</a> interface (read-only) over a <code>PropertyTable</code>.
-This is subclass from <a href="https://github.com/apache/jena/tree/master/jena-core/src/main/java/com/hp/hpl/jena/graph/impl/GraphBase.java">GraphBase</a> and implements <code>find()</code>.
+<h2 id="graphpropertytable">GraphPropertyTable<a class="headerlink" href="#graphpropertytable" title="Permanent link">¶</a></h2>
+<p><code>GraphPropertyTable</code> implements the <a href="https://github.com/apache/jena/tree/master/jena-core/src/main/java/org/apache/jena/graph/Graph.java">Graph</a> interface (read-only) over a <code>PropertyTable</code>.
+This is subclass from <a href="https://github.com/apache/jena/tree/master/jena-core/src/main/java/org/apache/jena/graph/impl/GraphBase.java">GraphBase</a> and implements <code>find()</code>.
The <code>graphBaseFind()</code>(for matching a <code>Triple</code>) and <code>propertyTableBaseFind()</code>(for matching a whole <code>Row</code>) methods can choose the access route based on the find arguments.
<code>GraphPropertyTable</code> holds/wraps an reference of the <code>PropertyTable</code> instance, so that such a <code>Graph</code> can be treated in a more table-like fashion.</p>
<p><strong>Note:</strong> Both <code>PropertyTable</code> and <code>GraphPropertyTable</code> are <em>NOT</em> restricted to CSV data.
They are supposed to be compatible with any table-like data sources, such as relational databases, Microsoft Excel, etc.</p>
-<h2 id="graphcsv">GraphCSV</h2>
+<h2 id="graphcsv">GraphCSV<a class="headerlink" href="#graphcsv" title="Permanent link">¶</a></h2>
<p><a href="https://github.com/apache/jena/tree/master/jena-csv/src/main/java/org/apache/jena/propertytable/impl/GraphCSV.java">GraphCSV</a> is a sub class of GraphPropertyTable aiming at CSV data.
Its constructor takes a CSV file path as the parameter, parse the file using a CSV Parser, and makes a <code>PropertyTable</code> through <code>PropertyTableBuilder</code>.</p>
<p>For CSV to RDF mapping, we establish some basic principles:</p>
-<h3 id="single-value-and-regular-shaped-csv-only">Single-Value and Regular-Shaped CSV Only</h3>
+<h3 id="single-value-and-regular-shaped-csv-only">Single-Value and Regular-Shaped CSV Only<a class="headerlink" href="#single-value-and-regular-shaped-csv-only" title="Permanent link">¶</a></h3>
<p>In the <a href="https://www.w3.org/2013/csvw/wiki/Main_Page">CSV-WG</a>, it looks like duplicate column names are not going to be supported. Therefore, we just consider parsing single-valued CSV tables.
There is the current editor working <a href="http://w3c.github.io/csvw/syntax/">draft</a> from the CSV on the Web Working Group, which is defining a more regular data out of CSV.
This is the target for the CSV work of GraphCSV: tabular regular-shaped CSV; not arbitrary, irregularly shaped CSV.</p>
-<h3 id="no-additional-csv-metadata">No Additional CSV Metadata</h3>
+<h3 id="no-additional-csv-metadata">No Additional CSV Metadata<a class="headerlink" href="#no-additional-csv-metadata" title="Permanent link">¶</a></h3>
<p>A CSV file with no additional metadata is directly mapped to RDF, which makes a simpler case compared to SQL-to-RDF work.
It's not necessary to have a defined primary column, similar to the primary key of database. The subject of the triple can be generated through one of:</p>
<ol>
<li>The triples for each row have a blank node for the subject, e.g. something like the illustration</li>
<li>The triples for row N have a subject URI which is <code><FILE#_N></code>.</li>
</ol>
-<h3 id="data-type-for-typed-literal">Data Type for Typed Literal</h3>
+<h3 id="data-type-for-typed-literal">Data Type for Typed Literal<a class="headerlink" href="#data-type-for-typed-literal" title="Permanent link">¶</a></h3>
<p>All the values in CSV are parsed as strings line by line. As a better option for the user to turn on, a dynamic choice which is a posh way of saying attempt to parse it as an integer (or decimal, double, date) and if it passes, it's an integer (or decimal, double, date).
Note that for the current release, all of the numbers are parsed as <code>double</code>, and <code>date</code> is not supported yet.</p>
-<h3 id="file-path-as-namespace">File Path as Namespace</h3>
+<h3 id="file-path-as-namespace">File Path as Namespace<a class="headerlink" href="#file-path-as-namespace" title="Permanent link">¶</a></h3>
<p>RDF requires that the subjects and the predicates are URIs. We need to pass in the namespaces (or just the default namespaces) to make URIs by combining the namespaces with the values in CSV.
We donât have metadata of the namespaces for the columns, But subjects can be blank nodes which is useful because each row is then a new blank node. For predicates, suppose the URL of the CSV file is <code>file:///c:/town.csv</code>, then the columns can be <code><file:///c:/town.csv#Town></code> and <code><file:///c:/town.csv#Population></code>, as is showed in the illustration.</p>
-<h3 id="first-line-of-table-header-needed-as-predicates">First Line of Table Header Needed as Predicates</h3>
+<h3 id="first-line-of-table-header-needed-as-predicates">First Line of Table Header Needed as Predicates<a class="headerlink" href="#first-line-of-table-header-needed-as-predicates" title="Permanent link">¶</a></h3>
<p>The first line of the CSV file must be the table header. The columns of the first line are parsed as the predicates of the RDF triples. The RDF triple data are parsed starting from the second line.</p>
-<h3 id="utf-8-encoded-only">UTF-8 Encoded Only</h3>
+<h3 id="utf-8-encoded-only">UTF-8 Encoded Only<a class="headerlink" href="#utf-8-encoded-only" title="Permanent link">¶</a></h3>
<p>The CSV files must be UTF-8 encoded. If your CSV files are using Western European encodings, please change the encoding before using CSV PropertyTable.</p>
</div>
</div>
Modified: websites/staging/jena/trunk/content/documentation/hadoop/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/hadoop/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/hadoop/index.html Tue Jul 14 12:52:14 2015
@@ -144,15 +144,26 @@
<div class="col-md-12">
<div id="breadcrumbs"></div>
<h1 class="title">Apache Jena Elephas</h1>
- <p>Apache Jena Elephas is a set of libraries which provide various basic building blocks which enable you to start writing Apache Hadoop based applications which work with RDF data.</p>
+ <style type="text/css">
+/* The following code is added by mdx_elementid.py
+ It was originally lifted from http://subversion.apache.org/style/site.css */
+/*
+ * Hide class="elementid-permalink", except when an enclosing heading
+ * has the :hover property.
+ */
+.headerlink, .elementid-permalink {
+ visibility: hidden;
+}
+h2:hover > .headerlink, h3:hover > .headerlink, h1:hover > .headerlink, h6:hover > .headerlink, h4:hover > .headerlink, h5:hover > .headerlink, dt:hover > .elementid-permalink { visibility: visible }</style>
+<p>Apache Jena Elephas is a set of libraries which provide various basic building blocks which enable you to start writing Apache Hadoop based applications which work with RDF data.</p>
<p>Historically there has been no serious support for RDF within the Hadoop ecosystem and what support has existed has
often been limited and task specific. These libraries aim to be as generic as possible and provide the necessary
infrastructure that enables developers to create their application specific logic without worrying about the
underlying plumbing.</p>
-<h2 id="beta">Beta</h2>
+<h2 id="beta">Beta<a class="headerlink" href="#beta" title="Permanent link">¶</a></h2>
<p>These modules are currently considered to be in a <strong>Beta</strong> state, they have been under active development for about a year but have not yet been widely deployed and may contain as yet undiscovered bugs.</p>
<p>Please see the <a href="../../help_and_support/bugs_and_suggestions.html">How to Report a Bug</a> page for how to report any bugs you may encounter.</p>
-<h2 id="documentation">Documentation</h2>
+<h2 id="documentation">Documentation<a class="headerlink" href="#documentation" title="Permanent link">¶</a></h2>
<ul>
<li><a href="#overview">Overview</a></li>
<li><a href="#getting-started">Getting Started</a></li>
@@ -169,7 +180,7 @@ underlying plumbing.</p>
</li>
<li><a href="artifacts.html">Maven Artifacts</a></li>
</ul>
-<h2 id="overview">Overview</h2>
+<h2 id="overview">Overview<a class="headerlink" href="#overview" title="Permanent link">¶</a></h2>
<p>Apache Jena Elephas is published as a set of Maven module via its <a href="artifacts.html">maven artifacts</a>. The source for these libraries
may be <a href="/download/index.cgi">downloaded</a> as part of the source distribution. These modules are built against the Hadoop 2.x. APIs and no
backwards compatibility for 1.x is provided.</p>
@@ -186,7 +197,7 @@ that enables various common Hadoop tasks
will be used as a starting point to build more complex RDF processing applications.</p>
<p>Finally there is a <a href="demo.html">RDF Stats Demo</a> which is a runnable Hadoop job JAR file that demonstrates using these libraries to calculate
a number of basic statistics over arbitrary RDF data.</p>
-<h2 id="getting-started">Getting Started</h2>
+<h2 id="getting-started">Getting Started<a class="headerlink" href="#getting-started" title="Permanent link">¶</a></h2>
<p>To get started you will need to add the relevant dependencies to your project, the exact dependencies necessary will depend
on what you are trying to do. Typically you will likely need at least the IO library and possibly the Map/Reduce library:</p>
<div class="codehilite"><pre><span class="nt"><dependency></span>
@@ -238,7 +249,7 @@ then outputs each node with an initial c
<span class="n">import</span> <span class="n">org</span><span class="p">.</span><span class="n">apache</span><span class="p">.</span><span class="n">jena</span><span class="p">.</span><span class="n">hadoop</span><span class="p">.</span><span class="n">rdf</span><span class="p">.</span><span class="n">types</span><span class="p">.</span><span class="n">NodeWritable</span><span class="p">;</span>
<span class="n">import</span> <span class="n">org</span><span class="p">.</span><span class="n">apache</span><span class="p">.</span><span class="n">jena</span><span class="p">.</span><span class="n">hadoop</span><span class="p">.</span><span class="n">rdf</span><span class="p">.</span><span class="n">types</span><span class="p">.</span><span class="n">TripleWritable</span><span class="p">;</span>
-<span class="n">import</span> <span class="n">com</span><span class="p">.</span><span class="n">hp</span><span class="p">.</span><span class="n">hpl</span><span class="p">.</span><span class="n">jena</span><span class="p">.</span><span class="n">graph</span><span class="p">.</span><span class="n">Triple</span><span class="p">;</span>
+<span class="n">import</span> <span class="n">org</span><span class="p">.</span><span class="n">apache</span><span class="p">.</span><span class="n">jena</span><span class="p">.</span><span class="n">graph</span><span class="p">.</span><span class="n">Triple</span><span class="p">;</span>
<span class="o">/**</span>
<span class="o">*</span> <span class="n">A</span> <span class="n">mapper</span> <span class="k">for</span> <span class="n">counting</span> <span class="n">node</span> <span class="n">usages</span> <span class="n">within</span> <span class="n">triples</span> <span class="n">designed</span> <span class="n">primarily</span> <span class="k">for</span> <span class="n">use</span>
@@ -348,7 +359,7 @@ us with support for our desired RDF inpu
<p>So this really is no different from configuring any other Hadoop job, we simply have to point to the relevant input and output formats and provide our mapper and reducer. Note that here we use the <code>TriplesInputFormat</code> which can handle RDF in any Jena supported format, if you know your RDF is in a specific format it is usually more efficient to use a more specific input format. Please see the <a href="io.html">IO</a> page for more detail on the available input formats and the differences between them.</p>
<p>We recommend that you next take a look at our <a href="demo.html">RDF Stats Demo</a> which shows how to do some more complex computations by chaining multiple jobs together.</p>
-<h2 id="apis">APIs</h2>
+<h2 id="apis">APIs<a class="headerlink" href="#apis" title="Permanent link">¶</a></h2>
<p>There are three main libraries each with their own API:</p>
<ul>
<li><a href="common.html">Common</a> - this provides the basic data model for representing RDF data within Hadoop</li>
Modified: websites/staging/jena/trunk/content/documentation/inference/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/inference/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/inference/index.html Tue Jul 14 12:52:14 2015
@@ -144,7 +144,18 @@
<div class="col-md-12">
<div id="breadcrumbs"></div>
<h1 class="title">Reasoners and rule engines: Jena inference support</h1>
- <p>This section of the documentation describes the current support for inference
+ <style type="text/css">
+/* The following code is added by mdx_elementid.py
+ It was originally lifted from http://subversion.apache.org/style/site.css */
+/*
+ * Hide class="elementid-permalink", except when an enclosing heading
+ * has the :hover property.
+ */
+.headerlink, .elementid-permalink {
+ visibility: hidden;
+}
+h2:hover > .headerlink, h3:hover > .headerlink, h1:hover > .headerlink, h6:hover > .headerlink, h4:hover > .headerlink, h5:hover > .headerlink, dt:hover > .elementid-permalink { visibility: visible }</style>
+<p>This section of the documentation describes the current support for inference
available within Jena. It includes an outline of the general inference API,
together with details of the specific rule engines and configurations for RDFS
and OWL inference supplied with Jena.</p>
@@ -158,7 +169,7 @@
<a href="http://jena.apache.org/help_and_support/index.html">mailing lists</a>
is welcomed. </p>
-<h2 id="index">Index</h2>
+<h2 id="index">Index<a class="headerlink" href="#index" title="Permanent link">¶</a></h2>
<p><ol>
<li><a href="#overview">Overview of inference support</a> </li>
<li><a href="#api">The inference API</a></li>
@@ -169,7 +180,7 @@
<li><a href="#extensions">Extending the inference support</a></li>
<li><a href="#futures">Futures</a></li>
</ol></p>
-<h2 id="overview">Overview of inference support</h2>
+<h2 id="overview">Overview of inference support<a class="headerlink" href="#overview" title="Permanent link">¶</a></h2>
<p><p>The Jena inference subsystem is designed to allow a range of inference engines
or reasoners to be plugged into Jena. Such engines are used to derive additional
RDF assertions which are entailed from some base RDF together with any optional
@@ -186,7 +197,7 @@
engine</em> please forgive us. </p>
<p>The overall structure of the inference machinery is illustrated below. </p>
<p class="centered"><img src="reasoner-overview.png" width="544" height="305" alt="Overall structure of inference machinery"></p>
-<p>Applications normally access the inference machinery by using the <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
+<p>Applications normally access the inference machinery by using the <a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
to associate a data set with some reasoner to create a new Model. Queries to
the created model will return not only those statements that were present in
the original data but also additional statements than can be derived from the
@@ -195,7 +206,7 @@
of the Graph SPI, so that any of the different Model interfaces can be constructed
around an inference Graph. In particular, the <a href="../ontology/index.html">Ontology
API</a> provides convenient ways to link appropriate reasoners into the <code>OntModel</code>s
- that it constructs. As part of the general RDF API we also provide an <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/InfModel.html"><code>InfModel</code></a>,
+ that it constructs. As part of the general RDF API we also provide an <a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/InfModel.html"><code>InfModel</code></a>,
this is an extension to the normal <code>Model</code> interface that provides
additional control and access to an underlying inference graph. </p>
<p>The reasoner API supports the notion of specializing a reasoner by binding
@@ -213,7 +224,7 @@
can be examined. It is possible to register new reasoner types and to dynamically
search for reasoners of a given type. The <code>ReasonerRegistry</code> also
provides convenient access to prebuilt instances of the main supplied reasoners.</p></p>
-<h3 id="available-reasoners">Available reasoners</h3>
+<h3 id="available-reasoners">Available reasoners<a class="headerlink" href="#available-reasoners" title="Permanent link">¶</a></h3>
<p><p>Included in the Jena distribution are a number of predefined reasoners:</p>
<ol>
<li>Transitive reasoner: Provides support for storing and traversing class and property lattices.
@@ -228,7 +239,7 @@
</ol></p>
<p>[<a href="#index">index</a>]</p>
-<h2 id="api">The Inference API</h2>
+<h2 id="api">The Inference API<a class="headerlink" href="#api" title="Permanent link">¶</a></h2>
<p><ol>
<li><a href="#reasonerAPI">Generic reasoner API</a></li>
<li><a href="#generalExamples">Small examples</a></li>
@@ -242,15 +253,15 @@
- <a href="#tracing">Tracing</a> <br>
</li>
</ol></p>
-<h3 id="reasonerAPI">Generic reasoner API</h3>
-<h4 id="finding-a-reasoner">Finding a reasoner</h4>
+<h3 id="reasonerAPI">Generic reasoner API<a class="headerlink" href="#reasonerAPI" title="Permanent link">¶</a></h3>
+<h4 id="finding-a-reasoner">Finding a reasoner<a class="headerlink" href="#finding-a-reasoner" title="Permanent link">¶</a></h4>
<p><p>For each type of reasoner there is a factory class (which conforms to the interface
- <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/ReasonerFactory.html">ReasonerFactory</a></code>)
+ <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/ReasonerFactory.html">ReasonerFactory</a></code>)
an instance of which can be used to create instances of the associated
- <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/Reasoner.html">Reasoner</a></code>.
+ <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/Reasoner.html">Reasoner</a></code>.
The factory instances can be located by going directly to a known factory class
and using the static <code>theInstance</code>() method or by retrieval from
- a global <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/ReasonerRegistry.html">ReasonerRegistry</a></code>
+ a global <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/ReasonerRegistry.html">ReasonerRegistry</a></code>
which stores factory instances indexed by URI assigned to the reasoner. </p>
<p>In addition, there are convenience methods on the <code>ReasonerRegistry</code>
for locating a prebuilt instance of each of the main reasoners (<code>getTransitiveReasoner</code>,
@@ -267,7 +278,7 @@
<p>Similarly, if all you want is a plain RDF Model with RDFS inference included
then the convenience methods <code>ModelFactory.createRDFSModel</code> can be
used. </p></p>
-<h4 id="configuring-a-reasoner">Configuring a reasoner</h4>
+<h4 id="configuring-a-reasoner">Configuring a reasoner<a class="headerlink" href="#configuring-a-reasoner" title="Permanent link">¶</a></h4>
<p><p>The behaviour of many of the reasoners can be configured. To allow arbitrary
configuration information to be passed to reasoners we use RDF to encode the
configuration details. The <code>ReasonerFactory.create</code> method can be
@@ -277,12 +288,12 @@
method to set a single configuration parameter, <code>Reasoner.setParameter</code>.
The parameter being set is identified by the corresponding configuration property.</p>
<p>For the built in reasoners the available configuration parameters are described
- below and are predefined in the <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/ReasonerVocabulary.html">ReasonerVocabulary</a></code>
+ below and are predefined in the <code><a href="/documentation/javadoc/jena/org/apache/jena/vocabulary/ReasonerVocabulary.html">ReasonerVocabulary</a></code>
class.</p>
<p>The parameter value can normally be a String or a structured value. For example,
to set a boolean value one can use the strings "true" or "false",
or in Java use a Boolean object or in RDF use an instance of xsd:Boolean</p></p>
-<h4 id="applying-a-reasoner-to-data">Applying a reasoner to data</h4>
+<h4 id="applying-a-reasoner-to-data">Applying a reasoner to data<a class="headerlink" href="#applying-a-reasoner-to-data" title="Permanent link">¶</a></h4>
<p><p>Once you have an instance of a reasoner it can then be attached to a set of
RDF data to create an inference model. This can either be done by putting all
the RDF data into one Model or by separating into two components - schema and
@@ -295,22 +306,22 @@
a set schema data, use the <code>Reasoner.bindSchema</code> method which returns
a new, specialized, reasoner.</p>
<p>To bind the reasoner to the final data set to create an inference model see
- the <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
+ the <a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
methods, particularly <code>ModelFactory.createInfModel</code>. </p></p>
-<h4 id="accessing-inferences">Accessing inferences</h4>
+<h4 id="accessing-inferences">Accessing inferences<a class="headerlink" href="#accessing-inferences" title="Permanent link">¶</a></h4>
<p><p>Finally, having created a inference model then any API operations which access
RDF statements will be able to access additional statements which are entailed
from the bound data by means of the reasoner. Depending on the reasoner these
additional <i>virtual</i> statements may all be precomputed the first time the
model is touched, may be dynamically recomputed each time or may be computed
on-demand but cached.</p></p>
-<h4 id="reasoner-description">Reasoner description</h4>
+<h4 id="reasoner-description">Reasoner description<a class="headerlink" href="#reasoner-description" title="Permanent link">¶</a></h4>
<p><p>The reasoners can be described using RDF metadata which can be searched to
locate reasoners with appropriate properties. The calls <code>Reasoner.getCapabilities</code>
and <code>Reasoner.supportsProperty</code> are used to access this descriptive
metadata.</p>
<p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="generalExamples">Some small examples</h3>
+<h3 id="generalExamples">Some small examples<a class="headerlink" href="#generalExamples" title="Permanent link">¶</a></h3>
<p><p>These initial examples are not designed to illustrate the power of the reasoners
but to illustrate the code required to set one up.</p>
<p>Let us first create a Jena model containing the statements that some property
@@ -414,13 +425,13 @@
<p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="operationsOnInferenceModels">Operations on inference models</h3>
+<h3 id="operationsOnInferenceModels">Operations on inference models<a class="headerlink" href="#operationsOnInferenceModels" title="Permanent link">¶</a></h3>
<p><p>For many applications one simply creates a model incorporating some inference
step, using the <code>ModelFactory</code> methods, and then just works within
the standard Jena Model API to access the entailed statements. However, sometimes
it is necessary to gain more control over the processing or to access additional
reasoner features not available as <i>virtual</i> triples.</p></p>
-<h4 id="validation">Validation</h4>
+<h4 id="validation">Validation<a class="headerlink" href="#validation" title="Permanent link">¶</a></h4>
<p><p>The most common reasoner operation which can't be exposed through additional
triples in the inference model is that of validation. Typically the ontology
languages used with the semantic web allow constraints to be expressed, the
@@ -492,7 +503,7 @@
ontology is both valid (logically consistent) and generated no warnings (such
as inconsistent classes).</p>
-<h4 id="wzxhzdk363wzxhzdk364extended-list-statements"><a name="extendedListStatements"></a>Extended list statements</h4>
+<h4 id="extended-list-statements"><a name="extendedListStatements"></a>Extended list statements<a class="headerlink" href="#extended-list-statements" title="Permanent link">¶</a></h4>
<p><p>The default API supports accessing all entailed information at the level of
individual triples. This is surprisingly flexible but there are queries which
cannot be easily supported this way. The first such is when the query needs
@@ -511,7 +522,7 @@
preloading your data with expressions you might need to query over. However,
for some external reasoners, especially description logic reasoners, we anticipate
restricted uses of this form of listStatement will be important.</p></p>
-<h4 id="wzxhzdk375wzxhzdk376direct-and-indirect-relationships"><a name="directRelations"></a>Direct and indirect relationships</h4>
+<h4 id="direct-and-indirect-relationships"><a name="directRelations"></a>Direct and indirect relationships<a class="headerlink" href="#direct-and-indirect-relationships" title="Permanent link">¶</a></h4>
<p><p>The second type of operation that is not obviously convenient at the triple
level involves distinguishing between direct and indirect relationships. If
a relation is transitive, for example rdfs:subClassOf, then we can define the
@@ -528,21 +539,21 @@
aliases for those relations which can be queried this way. For the built in
reasoners this functionality is available for <code>rdfs:subClassOf</code> and
<code>rdfs:subPropertyOf</code> and the direct aliases for these are defined
- in <a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/ReasonerVocabulary.html"><code>ReasonerVocabulary</code></a>.</p>
+ in <a href="/documentation/javadoc/jena/org/apache/jena/vocabulary/ReasonerVocabulary.html"><code>ReasonerVocabulary</code></a>.</p>
<p>Typically the easiest way to work with such indirect and direct relations is
to use the <a href="../ontology/index.html">Ontology API</a> which hides the
grubby details of these property aliases.</p></p>
-<h4 id="wzxhzdk402wzxhzdk403derivations"><a name="derivations"></a>Derivations</h4>
+<h4 id="derivations"><a name="derivations"></a>Derivations<a class="headerlink" href="#derivations" title="Permanent link">¶</a></h4>
<p><p>It is sometimes useful to be able to trace where an inferred statement was
generated from. This is achieved using the <code>InfModel.getDerivation(Statement)</code>
- method. This returns a iterator over a set <a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/Derivation.html"><code>Derviation</code></a>
+ method. This returns a iterator over a set <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/Derivation.html"><code>Derviation</code></a>
objects through which a brief description of the source of the derivation can
be obtained. Typically understanding this involves tracing the sources for other
statements which were used in this derivation and the <code>Derivation.PrintTrace</code>
method is used to do this recursively.</p>
<p>The general form of the Derivation objects is quite abstract but in the case
of the rule-based reasoners they have a more detailed internal structure that
- can be accessed - see <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/RuleDerivation.html">RuleDerivation</a></code>.</p>
+ can be accessed - see <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/RuleDerivation.html">RuleDerivation</a></code>.</p>
<p>Derviation information is rather expensive to compute and store. For this reason,
it is not recorded by default and <code>InfModel.serDerivationLogging(true)</code>
must be used to enable derivations to be recorded. This should be called before
@@ -591,7 +602,7 @@
Fact (eg:C eg:p eg:D)</i>
</pre>
-<h4 id="wzxhzdk426wzxhzdk427accessing-raw-data-and-deductions"><a name="rawAccess"></a>Accessing raw data and deductions</h4>
+<h4 id="accessing-raw-data-and-deductions"><a name="rawAccess"></a>Accessing raw data and deductions<a class="headerlink" href="#accessing-raw-data-and-deductions" title="Permanent link">¶</a></h4>
<p><p>From an <code>InfModel</code> it is easy to retrieve the original, unchanged,
data over which the model has been computed using the <code>getRawModel()</code>
call. This returns a model equivalent to the one used in the initial <code>bind</code>
@@ -600,7 +611,7 @@
<p>Some reasoners, notably the forward chaining rule engine, store the deduced
statements in a concrete form and this set of deductions can be obtained separately
by using the <code>getDeductionsModel()</code> call. </p></p>
-<h4 id="wzxhzdk440wzxhzdk441processing-control"><a name="processingControl"></a>Processing control</h4>
+<h4 id="processing-control"><a name="processingControl"></a>Processing control<a class="headerlink" href="#processing-control" title="Permanent link">¶</a></h4>
<p><p>Having bound a <code>Model</code> into an <code>InfModel</code> by using a
<code>Reasoner</code> its content can still be changed by the normal <code>add</code>
and <code>remove</code> calls to the <code>InfModel</code>. Any such change
@@ -627,7 +638,7 @@
call. It there are any outstanding queries (i.e. StmtIterators which have not
been read to the end yet) then those will be aborted (the next hasNext() call
will return false).</p></p>
-<h4 id="wzxhzdk470wzxhzdk471tracing"><a name="tracing"></a>Tracing</h4>
+<h4 id="tracing"><a name="tracing"></a>Tracing<a class="headerlink" href="#tracing" title="Permanent link">¶</a></h4>
<p><p>When developing new reasoner configurations, especially new rule sets for the
rule engines, it is sometimes useful to be able to trace the operations of the
associated inference engine. Though, often this generates too much information
@@ -642,14 +653,14 @@
<p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p>
-<h2 id="wzxhzdk478wzxhzdk479the-rdfs-reasoner"><a name="rdfs"></a>The RDFS reasoner</h2>
+<h2 id="the-rdfs-reasoner"><a name="rdfs"></a>The RDFS reasoner<a class="headerlink" href="#the-rdfs-reasoner" title="Permanent link">¶</a></h2>
<p><ol>
<li><a href="#RDFSintro">RDFS reasoner - introduction and coverage</a></li>
<li><a href="#RDFSconfiguration">RDFS Configuration</a></li>
<li><a href="#RDFSexamples">RDFS Example</a></li>
<li><a href="#RDFSnotes">RDFS implementation and performance notes</a></li>
</ol></p>
-<h3 id="wzxhzdk498wzxhzdk499rdfs-reasoner-intro-and-coverage"><a name="RDFSintro"></a>RDFS reasoner - intro and coverage</h3>
+<h3 id="rdfs-reasoner-intro-and-coverage"><a name="RDFSintro"></a>RDFS reasoner - intro and coverage<a class="headerlink" href="#rdfs-reasoner-intro-and-coverage" title="Permanent link">¶</a></h3>
<p><p>Jena includes an RDFS reasoner (<code>RDFSRuleReasoner</code>) which supports
almost all of the RDFS entailments described by the RDF Core working group [<a href="http://www.w3.org/TR/rdf-mt/">RDF
Semantics</a>]. The only omissions are deliberate and are described below.</p>
@@ -684,7 +695,7 @@
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk518wzxhzdk519rdfs-configuration"><a name="RDFSconfiguration"></a>RDFS configuration</h3>
+<h3 id="rdfs-configuration"><a name="RDFSconfiguration"></a>RDFS configuration<a class="headerlink" href="#rdfs-configuration" title="Permanent link">¶</a></h3>
<p><p>The RDFSRuleReasoner can be configured to work at three different compliance
levels: </p>
<dl>
@@ -727,7 +738,7 @@
</pre></div>
-<h4 id="summary-of-parameters">Summary of parameters</h4>
+<h4 id="summary-of-parameters">Summary of parameters<a class="headerlink" href="#summary-of-parameters" title="Permanent link">¶</a></h4>
<p><table width="90%" border="1" cellspacing="0" cellpadding="0">
<tr>
<td width="22%"><b>Parameter</b></td>
@@ -777,7 +788,7 @@
</tr>
</table>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk629wzxhzdk630rdfs-example"><a name="RDFSexamples"></a>RDFS Example</h3>
+<h3 id="rdfs-example"><a name="RDFSexamples"></a>RDFS Example<a class="headerlink" href="#rdfs-example" title="Permanent link">¶</a></h3>
<p><p>As a complete worked example let us create a simple RDFS schema, some instance
data and use an instance of the RDFS reasoner to query the two.</p>
<p>We shall use a trivial schema:</p></p>
@@ -875,7 +886,7 @@ that is not compatible with 13</i></pre>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk635wzxhzdk636rdfs-implementation-and-performance-notes"><a name="RDFSnotes"></a>RDFS implementation and performance notes</h3>
+<h3 id="rdfs-implementation-and-performance-notes"><a name="RDFSnotes"></a>RDFS implementation and performance notes<a class="headerlink" href="#rdfs-implementation-and-performance-notes" title="Permanent link">¶</a></h3>
<p><p>The RDFSRuleReasoner is a hybrid implementation. The subproperty and subclass
lattices are eagerly computed and stored in a compact in-memory form using the
TransitiveReasoner (see below). The identification of which container membership
@@ -933,7 +944,7 @@ that is not compatible with 13</i></pre>
on adapting the rule engines to exploit the capabilities of the more sophisticated
database backends will be considered.</p>
<p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p></p>
-<h2 id="wzxhzdk723wzxhzdk724the-owl-reasoner"><a name="owl"></a>The OWL reasoner</h2>
+<h2 id="the-owl-reasoner"><a name="owl"></a>The OWL reasoner<a class="headerlink" href="#the-owl-reasoner" title="Permanent link">¶</a></h2>
<p><ol>
<li><a href="#OWLintro">OWL reasoner introduction</a></li>
<li><a href="#OWLcoverage">OWL coverage</a></li>
@@ -950,7 +961,7 @@ an external DL reasoner such as Pellet,
configuration still leaves something to be desired and will the subject of future work - time permitting.</p>
<p>See also <a href="#OWLnotes">subsection 5</a> for notes on more specific limitations
of the current implementation. </p></p>
-<h3 id="wzxhzdk757wzxhzdk758owl-coverage"><a name="OWLcoverage"></a>OWL coverage</h3>
+<h3 id="owl-coverage"><a name="OWLcoverage"></a>OWL coverage<a class="headerlink" href="#owl-coverage" title="Permanent link">¶</a></h3>
<p><p>The Jena OWL reasoners could be described as instance-based reasoners. That
is, they work by using rules to propagate the if- and only-if- implications of
the OWL constructs on instance data. Reasoning about classes is done indirectly
@@ -1169,9 +1180,9 @@ configuration still leaves something to
restriction.</li>
</ul>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1007wzxhzdk1008owl-configuration"><a name="OWLconfiguration"></a>OWL Configuration</h3>
+<h3 id="owl-configuration"><a name="OWLconfiguration"></a>OWL Configuration<a class="headerlink" href="#owl-configuration" title="Permanent link">¶</a></h3>
<p><p>This reasoner is accessed using <code>ModelFactory.createOntologyModel</code>
- with the prebuilt <a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>
+ with the prebuilt <a href="/documentation/javadoc/jena/org/apache/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>
<code>OWL_MEM_RULE_INF</code> or manually via <code>ReasonerRegistery.getOWLReasoner()</code>.</p>
<p>There are no OWL-specific configuration parameters though the reasoner supports
the standard control parameters:</p>
@@ -1206,7 +1217,7 @@ configuration still leaves something to
of the rule-based approach we imagine useful subsets of functionality emerging
- like that that supported by the RDFS reasoner in the form of the level settings.</p>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1073wzxhzdk1074owl-example"><a name="OWLexamples"></a>OWL Example</h3>
+<h3 id="owl-example"><a name="OWLexamples"></a>OWL Example<a class="headerlink" href="#owl-example" title="Permanent link">¶</a></h3>
<p><p>As an example of using the OWL inference support, consider the sample schema
and data file in the data directory - <a href="data/owlDemoSchema.xml">owlDemoSchema.xml</a>
and <a href="data/owlDemoData.xml">owlDemoData.xml</a>. </p>
@@ -1324,8 +1335,8 @@ Implicated node: eg:bigNameSpecialMB</i>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk1093wzxhzdk1094owl-notes-and-limitations"><a name="OWLnotes"></a>OWL notes and limitations</h3>
-<h4 id="comprehension-axioms">Comprehension axioms</h4>
+<h3 id="owl-notes-and-limitations"><a name="OWLnotes"></a>OWL notes and limitations<a class="headerlink" href="#owl-notes-and-limitations" title="Permanent link">¶</a></h3>
+<h4 id="comprehension-axioms">Comprehension axioms<a class="headerlink" href="#comprehension-axioms" title="Permanent link">¶</a></h4>
<p><p>A critical implication of our variant of the instance-based approach is that
the reasoner does not directly answer queries relating to dynamically introduced
class expressions.</p>
@@ -1353,12 +1364,12 @@ class B = cardinality(P,1)</pre>
Jena rule reasoner passes these tests only after they have been rewritten to
avoid the comprehension requirements.<br>
</p></p>
-<h4 id="prototypes">Prototypes</h4>
+<h4 id="prototypes">Prototypes<a class="headerlink" href="#prototypes" title="Permanent link">¶</a></h4>
<p><p>As noted above the current OWL rule set introduces prototypical instances for
each defined class. These prototypical instances used to be visible to queries.
From release 2.1 they are used internally but should not longer be visible.
</p></p>
-<h4 id="directindirect">Direct/indirect</h4>
+<h4 id="directindirect">Direct/indirect<a class="headerlink" href="#directindirect" title="Permanent link">¶</a></h4>
<p><p>We noted <a href="#directRelations">above</a> that the Jena reasoners support
a separation of direct and indirect relations for transitive properties such
as subClassOf. The current implementation of the full and mini OWL reasoner
@@ -1366,7 +1377,7 @@ class B = cardinality(P,1)</pre>
reasoner, which is but a small extension of RDFS, does suppor the direct queries.</p>
<p>This does not affect querying though the Ontology API, which works around this
limitation. It only affects direct RDF accesses to the inference model.</p></p>
-<h4 id="performance">Performance</h4>
+<h4 id="performance">Performance<a class="headerlink" href="#performance" title="Permanent link">¶</a></h4>
<p><p>The OWL reasoners use the rule engines for all inference. The full and mini
configurations omit some of the performance tricks employed by the RDFS reasoner
(notably the use of the custom transitive reasoner) making those OWL reasoner
@@ -1387,7 +1398,7 @@ class B = cardinality(P,1)</pre>
<p>One random hint: explicitly importing the owl.owl definitions causes much duplication
of rule use and a substantial slow down - the OWL axioms that the reasoner can
handle are already built in and don't need to be redeclared.</p></p>
-<h4 id="incompleteness">Incompleteness</h4>
+<h4 id="incompleteness">Incompleteness<a class="headerlink" href="#incompleteness" title="Permanent link">¶</a></h4>
<p><p>The rule based approach cannot offer a complete solution for OWL/Lite, let
alone the OWL/Full fragment corresponding to the OWL/Lite constructs. In addition
the current implementation is still under development and may well have ommisions
@@ -1395,7 +1406,7 @@ class B = cardinality(P,1)</pre>
should be valid) but not complete. </p></p>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p>
-<h2 id="wzxhzdk1132wzxhzdk1133the-transitive-reasoner"><a name="transitive"></a>The transitive reasoner</h2>
+<h2 id="the-transitive-reasoner"><a name="transitive"></a>The transitive reasoner<a class="headerlink" href="#the-transitive-reasoner" title="Permanent link">¶</a></h2>
<p><p>The TransitiveReasoner provides support for storing and traversing class and
property lattices. This implements just the <i>transitive</i> and <i>symmetric</i>
properties of <code>rdfs:subPropertyOf</code> and <code>rdfs:subClassOf</code>.
@@ -1411,7 +1422,7 @@ class B = cardinality(P,1)</pre>
used in the default RDFS reasoner.</p>
<p>It has no configuration options.</p>
<p>[<a href="#index">Index</a>]</p></p>
-<h2 id="wzxhzdk1154wzxhzdk1155the-general-purpose-rule-engine"><a name="rules"></a>The general purpose rule engine</h2>
+<h2 id="the-general-purpose-rule-engine"><a name="rules"></a>The general purpose rule engine<a class="headerlink" href="#the-general-purpose-rule-engine" title="Permanent link">¶</a></h2>
<p><ol>
<li><a href="#RULEoverview">Overview of the rule engine(s)</a></li>
<li><a href="#RULEsyntax">Rule syntax and structure</a></li>
@@ -1425,7 +1436,7 @@ class B = cardinality(P,1)</pre>
<li><a href="#RULEnotes">Notes</a></li>
<li><a href="#RULEextensions">Extensions</a></li>
</ol></p>
-<h3 id="wzxhzdk1202wzxhzdk1203overview-of-the-rule-engines"><a name="RULEoverview"></a>Overview of the rule engine(s)</h3>
+<h3 id="overview-of-the-rule-engines"><a name="RULEoverview"></a>Overview of the rule engine(s)<a class="headerlink" href="#overview-of-the-rule-engines" title="Permanent link">¶</a></h3>
<p><p>Jena includes a general purpose rule-based reasoner which is used to implement
both the RDFS and OWL reasoners but is also available for general use. This
reasoner supports rule-based inference over RDF graphs and provides forward
@@ -1434,7 +1445,7 @@ class B = cardinality(P,1)</pre>
tabled datalog engine - they can be run separately or the forward engine can
be used to prime the backward engine which in turn will be used to answer queries.</p>
<p>The various engine configurations are all accessible through a single parameterized
- reasoner <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/GenericRuleReasoner.html">GenericRuleReasoner</a></code>.
+ reasoner <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/GenericRuleReasoner.html">GenericRuleReasoner</a></code>.
At a minimum a <code>GenericRuleReasoner</code> requires a ruleset to define
its behaviour. A <code>GenericRuleReasoner</code> instance with a ruleset can
be used like any of the other reasoners described above - that is it can be
@@ -1444,10 +1455,10 @@ class B = cardinality(P,1)</pre>
The current release includes a starting set of primitives which are sufficient
for the RDFS and OWL implementations but is easily extensible.</p>
<p>[<a href="#rules">rule index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1224wzxhzdk1225rule-syntax-and-structure"><a name="RULEsyntax"></a>Rule syntax and structure</h3>
-<p><p>A rule for the rule-based reasoner is defined by a Java <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/Rule.html">Rule</a></code>
+<h3 id="rule-syntax-and-structure"><a name="RULEsyntax"></a>Rule syntax and structure<a class="headerlink" href="#rule-syntax-and-structure" title="Permanent link">¶</a></h3>
+<p><p>A rule for the rule-based reasoner is defined by a Java <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/Rule.html">Rule</a></code>
object with a list of body terms (premises), a list of head terms (conclusions)
- and an optional name and optional direction. Each term or <a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/ClauseEntry.html"><code>ClauseEntry</code></a>
+ and an optional name and optional direction. Each term or <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/ClauseEntry.html"><code>ClauseEntry</code></a>
is either a triple pattern, an extended triple pattern or a call to a builtin
primitive. A rule set is simply a List of Rules.</p>
<p>For convenience a rather simple parser is included with Rule which allows rules
@@ -1485,7 +1496,7 @@ class B = cardinality(P,1)</pre>
multiple triples and allows a rule to collect those triples together in one
place.</p>
<p>To keep rules readable qname syntax is supported for URI refs. The set of known
- prefixes is those registered with the <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/util/PrintUtil.html">PrintUtil</a></code>
+ prefixes is those registered with the <code><a href="/documentation/javadoc/jena/org/apache/jena/util/PrintUtil.html">PrintUtil</a></code>
object. This initially knows about rdf, rdfs, owl, xsd and a test namespace
eg, but more mappings can be registered in java code. In addition it is possible to
define additional prefix mappings in the rule file, see below. </p>
@@ -1554,7 +1565,7 @@ a single extra rule is:
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk1403wzxhzdk1404forward-chaining-engine"><a name="RULEforward"></a>Forward chaining engine</h3>
+<h3 id="forward-chaining-engine"><a name="RULEforward"></a>Forward chaining engine<a class="headerlink" href="#forward-chaining-engine" title="Permanent link">¶</a></h3>
<p><p>If the rule reasoner is configured to run in forward mode then only the forward
chaining engine will be used. The first time the inference Model is queried
(or when an explicit <code>prepare()</code> call is made, see <a href="#processingControl">above</a>)
@@ -1593,7 +1604,7 @@ a single extra rule is:
done to the default RETE engine.</p></p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk1436wzxhzdk1437backward-chaining-engine"><a name="RULEbackward"></a>Backward chaining engine</h3>
+<h3 id="backward-chaining-engine"><a name="RULEbackward"></a>Backward chaining engine<a class="headerlink" href="#backward-chaining-engine" title="Permanent link">¶</a></h3>
<p><p>If the rule reasoner is run in backward chaining mode it uses a logic programming
(LP) engine with a similar execution strategy to Prolog engines. When the inference
Model is queried then the query is translated into a goal and the engine attempts
@@ -1622,7 +1633,7 @@ triple(s1, p1, o1) :- triple(sb1, pb1, o
<p>Because the order of triples in a Model is not defined then this is one violation
to strict top-to-bottom execution. Essentially all ground facts are consulted
before all rule clauses but the ordering of ground facts is arbitrary.</p></p>
-<h4 id="tabling">Tabling</h4>
+<h4 id="tabling">Tabling<a class="headerlink" href="#tabling" title="Permanent link">¶</a></h4>
<p><p>The LP engine supports tabling. When a goal is tabled then all previously computed
matches to that goal are recorded (memoized) and used when satisfying future
similar goals. When such a tabled goal is called and all known answers have
@@ -1659,7 +1670,7 @@ triple(s1, p1, o1) :- triple(sb1, pb1, o
might be run in either backward or forward mode then they should be limited to a single consequent each.
</p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1500wzxhzdk1501hybrid-rule-engine"><a name="RULEhybrid"></a>Hybrid rule engine</h3>
+<h3 id="hybrid-rule-engine"><a name="RULEhybrid"></a>Hybrid rule engine<a class="headerlink" href="#hybrid-rule-engine" title="Permanent link">¶</a></h3>
<p><p>The rule reasoner has the option of employing both of the individual rule engines
in conjunction. When run in this <i>hybrid</i> mode the data flows look something
like this: </p>
@@ -1700,7 +1711,7 @@ might be run in either backward or forwa
removing backward rules in response to the data changes.</p></p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk1532wzxhzdk1533genericrulereasoner-configuration"><a name="RULEconfiguration"></a>GenericRuleReasoner configuration</h3>
+<h3 id="genericrulereasoner-configuration"><a name="RULEconfiguration"></a>GenericRuleReasoner configuration<a class="headerlink" href="#genericrulereasoner-configuration" title="Permanent link">¶</a></h3>
<p><p>As with the other reasoners there are a set of parameters, identified by RDF
properties, to control behaviour of the <code>GenericRuleReasoner</code>. These
parameters can be set using the <code>Reasoner.setParameter</code> call or passed
@@ -1716,7 +1727,7 @@ Reasoner reasoner = new GenericRuleReaso
a file name which should be loadable from either the classpath or relative to
the current working directory.<br>
</p></p>
-<h4 id="summary-of-parameters_1">Summary of parameters</h4>
+<h4 id="summary-of-parameters_1">Summary of parameters<a class="headerlink" href="#summary-of-parameters_1" title="Permanent link">¶</a></h4>
<p><table width="90%" border="1" cellspacing="0" cellpadding="0">
<tr>
<td width="26%"><b>Parameter</b></td>
@@ -1801,7 +1812,7 @@ Reasoner reasoner = new GenericRuleReaso
</tr>
</table>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1670wzxhzdk1671builtin-primitives"><a name="RULEbuiltins"></a>Builtin primitives</h3>
+<h3 id="builtin-primitives"><a name="RULEbuiltins"></a>Builtin primitives<a class="headerlink" href="#builtin-primitives" title="Permanent link">¶</a></h3>
<p><p>The procedural primitives which can be called by the rules are each implemented
by a Java object stored in a registry. Additional primitives can be created
and registered - see below for more details.</p>
@@ -2018,7 +2029,7 @@ do not "pollute" the inference results.<
</tr>
</table>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1911wzxhzdk1912example"><a name="RULEexamples"></a>Example</h3>
+<h3 id="example"><a name="RULEexamples"></a>Example<a class="headerlink" href="#example" title="Permanent link">¶</a></h3>
<p><p>As a simple illustration suppose we wish to create a simple ontology language
in which we can declare one property as being the concatenation of two others
and to build a rule reasoner to implement this.</p>
@@ -2049,7 +2060,7 @@ while (list.hasNext()) {
<pre><i>A * </em> =>
- [urn:x-hp:eg/A, urn:x-hp:eg/p, urn:x-hp:eg/B]
- [urn:x-hp:eg/A, urn:x-hp:eg/r, urn:x-hp:eg/C]</i></pre></p>
-<h4 id="example-2">Example 2</h4>
+<h4 id="example-2">Example 2<a class="headerlink" href="#example-2" title="Permanent link">¶</a></h4>
<p><p>As a second example, we'll look at ways to define a property as being both
symmetric and transitive. Of course, this can be done directly in OWL but there
are times when one might wish to do this outside of the full OWL rule set and,
@@ -2111,7 +2122,7 @@ while (i.hasNext()) {
[ (?A ?P ?C) <- (?A ?P ?B), (?B ?P ?C) ]
] </pre>
<p>[<a href="#rules">rule index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1988wzxhzdk1989combining-rdfsowl-with-custom-rules"><a name="RDFSPlusRules"></a>Combining RDFS/OWL with custom rules</h3>
+<h3 id="combining-rdfsowl-with-custom-rules"><a name="RDFSPlusRules"></a>Combining RDFS/OWL with custom rules<a class="headerlink" href="#combining-rdfsowl-with-custom-rules" title="Permanent link">¶</a></h3>
<p><p>Sometimes one wishes to write generic inference rules but combine them
with some RDFS or OWL infernece. With the current Jena architecture limited forms of this
is possible but you need to be aware of the limitations.</p>
@@ -2175,7 +2186,7 @@ while (i.hasNext()) {
<p>[<a href="#rules">rule index</a>] [<a href="#index">main index</a>]</p>
-<h3 id="wzxhzdk1998wzxhzdk1999notes"><a name="RULEnotes"></a>Notes</h3>
+<h3 id="notes"><a name="RULEnotes"></a>Notes<a class="headerlink" href="#notes" title="Permanent link">¶</a></h3>
<p><p>One final aspect of the general rule engine to mention is that of validation
rules. We described earlier how reasoners can implement a <code>validate</code>
call which returns a set of error reports and warnings about inconsistencies
@@ -2205,39 +2216,39 @@ while (i.hasNext()) {
<p>Future extensions will improve the formatting capabilities and flexibility
of this mechanism. </p>
<p>[<a href="#rules">Rule index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk2042wzxhzdk2043extensions"><a name="RULEextensions"></a>Extensions</h3>
+<h3 id="extensions"><a name="RULEextensions"></a>Extensions<a class="headerlink" href="#extensions" title="Permanent link">¶</a></h3>
<p><p>There are several places at which the rule system can be extended by application
code.</p></p>
-<h4 id="rule-syntax">Rule syntax</h4>
+<h4 id="rule-syntax">Rule syntax<a class="headerlink" href="#rule-syntax" title="Permanent link">¶</a></h4>
<p><p>First, as mentioned earlier, the rule engines themselves only see rules in
terms of the Rule Java object. Thus applications are free to define an alternative
rule syntax so long as it can be compiled into Rule objects.</p></p>
-<h4 id="builtins">Builtins</h4>
+<h4 id="builtins">Builtins<a class="headerlink" href="#builtins" title="Permanent link">¶</a></h4>
<p><p>Second, the set of procedural builtins can be extended. A builtin should implement
- the <a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/Builtin.html"><code>Builtin</code></a>
- interface. The easiest way to achieve this is by subclassing <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/builtins/BaseBuiltin.html">BaseBuiltin</a></code>
+ the <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/Builtin.html"><code>Builtin</code></a>
+ interface. The easiest way to achieve this is by subclassing <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/builtins/BaseBuiltin.html">BaseBuiltin</a></code>
and defining a name (<code>getName</code>), the number of arguments expected
(<code>getArgLength</code>) and one or both of <code>bodyCall</code> and <code>headAction</code>.
The <code>bodyCall</code> method is used when the builtin is invoked in the
body of a rule clause and should return true or false according to whether the
test passes. In both cases the arguments may be variables or bound values and
- the supplied <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/RuleContext.html">RuleContext</a></code>
+ the supplied <code><a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/RuleContext.html">RuleContext</a></code>
object can be used to dereference bound variables and to bind new variables.
</p>
<p>Once the Builtin has been defined then an instance of it needs to be registered
- with <a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/BuiltinRegistry.html"><code>BuiltinRegistry</code></a>
+ with <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/BuiltinRegistry.html"><code>BuiltinRegistry</code></a>
for it to be seen by the rule parser and interpreters.</p>
<p>The easiest way to experiment with this is to look at the examples in the builtins
directory. </p></p>
-<h4 id="preprocessing-hooks">Preprocessing hooks</h4>
+<h4 id="preprocessing-hooks">Preprocessing hooks<a class="headerlink" href="#preprocessing-hooks" title="Permanent link">¶</a></h4>
<p><p>The rule reasoner can optionally run a sequence of procedural preprocessing
hooks over the data at the time the inference graph is <i>prepared</i>. These
procedural hooks can be used to perform tests or translations which are slow
or inconvenient to express in rule form. See <code>GenericRuleReasoner.addPreprocessingHook</code>
- and the <a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/RulePreprocessHook.html"><code>RulePreprocessHook</code></a>
+ and the <a href="/documentation/javadoc/jena/org/apache/jena/reasoner/rulesys/RulePreprocessHook.html"><code>RulePreprocessHook</code></a>
class for more details.</p>
<p>[<a href="#index">Index</a>]</p></p>
-<h2 id="wzxhzdk2094wzxhzdk2095extending-the-inference-support"><a name="extensions"></a>Extending the inference support</h2>
+<h2 id="extending-the-inference-support"><a name="extensions"></a>Extending the inference support<a class="headerlink" href="#extending-the-inference-support" title="Permanent link">¶</a></h2>
<p><p>Apart from the extension points in the rule reasoner discussed above, the intention
is that it should be possible to plug external inference engines into Jena.
The core interfaces of <code>InfGraph</code> and <code>Reasoner</code> are kept
@@ -2248,7 +2259,7 @@ while (i.hasNext()) {
freely available, reasoner to both validate the machinery and to provide an
example of how this extension can be done.</p>
<p>[<a href="#index">Index</a>]</p></p>
-<h2 id="wzxhzdk2110wzxhzdk2111futures"><a name="futures"></a>Futures</h2>
+<h2 id="futures"><a name="futures"></a>Futures<a class="headerlink" href="#futures" title="Permanent link">¶</a></h2>
<p><p>Contributions for the following areas would be very welcome:</p>
<ul>
<li>Develop a custom equality reasoner which can handle the "owl:sameAs"
Modified: websites/staging/jena/trunk/content/documentation/io/DOM2Jena.java
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/DOM2Jena.java (original)
+++ websites/staging/jena/trunk/content/documentation/io/DOM2Jena.java Tue Jul 14 12:52:14 2015
@@ -6,8 +6,8 @@ import org.xml.sax.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
-import com.hp.hpl.jena.rdf.arp.*;
-import com.hp.hpl.jena.rdf.model.*;
+import org.apache.jena.rdf.arp.*;
+import org.apache.jena.rdf.model.*;
/**
* @author Jeremy J. Carroll
Modified: websites/staging/jena/trunk/content/documentation/io/arp_sax.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/arp_sax.html (original)
+++ websites/staging/jena/trunk/content/documentation/io/arp_sax.html Tue Jul 14 12:52:14 2015
@@ -144,13 +144,24 @@
<div class="col-md-12">
<div id="breadcrumbs"></div>
<h1 class="title">SAX Input into Jena and ARP</h1>
- <p>Normally, both ARP and Jena are used to read files either from the
+ <style type="text/css">
+/* The following code is added by mdx_elementid.py
+ It was originally lifted from http://subversion.apache.org/style/site.css */
+/*
+ * Hide class="elementid-permalink", except when an enclosing heading
+ * has the :hover property.
+ */
+.headerlink, .elementid-permalink {
+ visibility: hidden;
+}
+h2:hover > .headerlink, h3:hover > .headerlink, h1:hover > .headerlink, h6:hover > .headerlink, h4:hover > .headerlink, h5:hover > .headerlink, dt:hover > .elementid-permalink { visibility: visible }</style>
+<p>Normally, both ARP and Jena are used to read files either from the
local machine or from the Web. A different use case, addressed
here, is when the XML source is available in-memory in some way. In
these cases, ARP and Jena can be used as a SAX event handler,
turning SAX events into triples, or a DOM tree can be parsed into a
Jena Model.</p>
-<h2 id="contents">Contents</h2>
+<h2 id="contents">Contents<a class="headerlink" href="#contents" title="Permanent link">¶</a></h2>
<ul>
<li><a href="#overview">Overview</a></li>
<li><a href="#sample-code">Sample Code</a></li>
@@ -161,24 +172,24 @@ Jena Model.</p>
<li><a href="#using-your-own-triple-handler">Using your own triple handler</a></li>
<li><a href="#using-a-dom-as-input">Using a DOM as input</a></li>
</ul>
-<h2 id="1-overview">1. Overview</h2>
+<h2 id="1-overview">1. Overview<a class="headerlink" href="#1-overview" title="Permanent link">¶</a></h2>
<p>To read an arbitrary SAX source as triples to be added into a Jena
model, it is not possible to use a
-<code>Model.</code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#read(java.io.InputStream,%20java.lang.String)"><code>read</code></a>()
+<code>Model.</code><a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/Model.html#read(java.io.InputStream,%20java.lang.String)"><code>read</code></a>()
operation. Instead, you construct a SAX event handler of class
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2Model.html"><code>SAX2Model</code></a>,
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2Model.html"><code>SAX2Model</code></a>,
using the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2Model.html#create(java.lang.String,%20com.hp.hpl.jena.rdf.model.Model)"><code>create</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2Model.html#create(java.lang.String,%20org.apache.jena.rdf.model.Model)"><code>create</code></a>
method, install these as the handler on your SAX event source, and
then stream the SAX events. It is possible to have fine-grained
control over the SAX events, for instance, by inserting or deleting
events, before passing them to the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2Model.html"><code>SAX2Model</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2Model.html"><code>SAX2Model</code></a>
handler.</p>
-<h2 id="sample-code">Sample Code</h2>
+<h2 id="sample-code">Sample Code<a class="headerlink" href="#sample-code" title="Permanent link">¶</a></h2>
<p>This code uses the Xerces parser as a SAX event stream, and adds
the triple to a
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> using
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/Model.html"><code>Model</code></a> using
default options.</p>
<div class="codehilite"><pre><span class="c1">// Use your own SAX source.</span>
<span class="n">XMLReader</span> <span class="n">saxParser</span> <span class="o">=</span> <span class="k">new</span> <span class="n">SAXParser</span><span class="p">();</span>
@@ -211,12 +222,12 @@ default options.</p>
</pre></div>
-<h2 id="initializing-sax-event-source">Initializing SAX event source</h2>
+<h2 id="initializing-sax-event-source">Initializing SAX event source<a class="headerlink" href="#initializing-sax-event-source" title="Permanent link">¶</a></h2>
<p>If your SAX event source is a subclass of <code>XMLReader</code>, then the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html#installHandlers(org.xml.sax.XMLReader,%20com.hp.hpl.jena.rdf.arp.XMLHandler)">installHandlers</a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html#installHandlers(org.xml.sax.XMLReader,%20org.apache.jena.rdf.arp.XMLHandler)">installHandlers</a>
static method can be used as shown in the sample. Otherwise, you
have to do it yourself. The
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html#installHandlers(org.xml.sax.XMLReader,%20com.hp.hpl.jena.rdf.arp.XMLHandler)"><code>installHandlers</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html#installHandlers(org.xml.sax.XMLReader,%20org.apache.jena.rdf.arp.XMLHandler)"><code>installHandlers</code></a>
code is like this:</p>
<div class="codehilite"><pre><span class="n">static</span> <span class="n">public</span> <span class="n">void</span> <span class="n">installHandlers</span><span class="p">(</span><span class="n">XMLReader</span> <span class="n">rdr</span><span class="p">,</span> <span class="n">XMLHandler</span> <span class="n">sax2rdf</span><span class="p">)</span>
<span class="n">throws</span> <span class="n">SAXException</span>
@@ -238,87 +249,87 @@ code is like this:</p>
<p>For some other SAX source, the exact code will differ, but the
required operations are as above.</p>
-<h2 id="error-handler">Error Handler</h2>
-<p>The <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2Model.html">SAX2Model</a>
+<h2 id="error-handler">Error Handler<a class="headerlink" href="#error-handler" title="Permanent link">¶</a></h2>
+<p>The <a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2Model.html">SAX2Model</a>
handler supports the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html#setErrorHandler(com.hp.hpl.jena.rdf.model.RDFErrorHandler)">setErrorHandler</a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/RDFReader.html#setErrorHandler(org.apache.jena.rdf.model.RDFErrorHandler)">setErrorHandler</a>
method, from the Jena
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html">RDFReader</a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/RDFReader.html">RDFReader</a>
interface. This is used in the same way as that method to control
error reporting.</p>
<p>A specific fatal error, new in Jena 2.3, is ERR_INTERRUPTED, which
indicates that the current Thread received an interrupt. This
allows long jobs to be aborted on user request.</p>
-<h2 id="options">Options</h2>
-<p>The <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2Model.html"><code>SAX2Model</code></a>
+<h2 id="options">Options<a class="headerlink" href="#options" title="Permanent link">¶</a></h2>
+<p>The <a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2Model.html"><code>SAX2Model</code></a>
handler supports the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html#setProperty(java.lang.String,%20java.lang.Object)"><code>setProperty</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/RDFReader.html#setProperty(java.lang.String,%20java.lang.Object)"><code>setProperty</code></a>
method, from the Jena
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFReader.html"><code>RDFReader</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/model/RDFReader.html"><code>RDFReader</code></a>
interface. This is used in nearly the same way to have fine grain
control over ARPs behaviour, particularly over error reporting, see
the <a href="iohowto.html#arp_properties">I/O howto</a>. Setting SAX or
Xerces properties cannot be done using this method.</p>
-<h2 id="xml-lang-and-namespaces">XML Lang and Namespaces</h2>
+<h2 id="xml-lang-and-namespaces">XML Lang and Namespaces<a class="headerlink" href="#xml-lang-and-namespaces" title="Permanent link">¶</a></h2>
<p>If you are only treating some document subset as RDF/XML then it is
necessary to ensure that ARP knows the correct value for <code>xml:lang</code>
and desirable that it knows the correct mappings of namespace
prefixes.</p>
<p>There is a second version of the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2Model.html#create(java.lang.String,%20com.hp.hpl.jena.rdf.model.Model,%20java.lang.String)"><code>create</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2Model.html#create(java.lang.String,%20org.apache.jena.rdf.model.Model,%20java.lang.String)"><code>create</code></a>
method, which allows specification of the <code>xml:lang</code> value from the
outer context. If this is inappropriate it is possible, but hard
work, to synthesis an appropriate SAX event.</p>
<p>For the namespaces prefixes, it is possible to call the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html#startPrefixMapping(java.lang.String,%20java.lang.String)"><code>startPrefixMapping</code></a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html#startPrefixMapping(java.lang.String,%20java.lang.String)"><code>startPrefixMapping</code></a>
SAX event, before passing the other SAX events, to declare each
namespace, one by one. Failure to do this is permitted, but, for
instance, a Jena Model will then not know the (advisory) namespace
prefix bindings. These should be paired with endPrefixMapping
events, but nothing untoward is likely if such code is omitted.</p>
-<h2 id="using-your-own-triple-handler">Using your own triple handler</h2>
+<h2 id="using-your-own-triple-handler">Using your own triple handler<a class="headerlink" href="#using-your-own-triple-handler" title="Permanent link">¶</a></h2>
<p>As with ARP, it is possible to use this functionality, without
using other Jena features, in particular, without using a Jena
Model. Instead of using the class SAX2Model, you use its superclass
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html">SAX2RDF</a>. The
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html#create(java.lang.String)">create</a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html">SAX2RDF</a>. The
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html#create(java.lang.String)">create</a>
method on this class does not provide any means of specifying what
to do with the triples. Instead, the class implements the
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html">ARPConfig</a>
+<a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html">ARPConfig</a>
interface, which permits the setting of handlers and parser
options, as described in the documentation for using
<a href="standalone.html">ARP without Jena</a>.</p>
<p>Thus you need to:</p>
<ol>
<li>Create a SAX2RDF using
- <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/SAX2RDF.html#create(java.lang.String)">SAX2RDF.create()</a></li>
+ <a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/SAX2RDF.html#create(java.lang.String)">SAX2RDF.create()</a></li>
<li>Attach your StatementHandler and SAXErrorHandler and optionally
your NamespaceHandler and ExtendedHandler to the SAX2RDF instance.</li>
<li>Install the SAX2RDF instance as the SAX handler on your SAX
source.</li>
<li>Follow the remainder of the code sample above.</li>
</ol>
-<h2 id="using-a-dom-as-input">Using a DOM as Input</h2>
+<h2 id="using-a-dom-as-input">Using a DOM as Input<a class="headerlink" href="#using-a-dom-as-input" title="Permanent link">¶</a></h2>
<p>None of the approaches listed here work with Java 1.4.1_04. We
suggest using Java 1.4.2_04 or greater for this functionality.
This issue has no impact on any other Jena functionality.</p>
-<h3 id="using-a-dom-as-input-to-jena">Using a DOM as Input to Jena</h3>
-<p>The <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/DOM2Model.html"><code>DOM2Model</code></a>
+<h3 id="using-a-dom-as-input-to-jena">Using a DOM as Input to Jena<a class="headerlink" href="#using-a-dom-as-input-to-jena" title="Permanent link">¶</a></h3>
+<p>The <a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/DOM2Model.html"><code>DOM2Model</code></a>
subclass of SAX2Model, allows the parsing of a DOM using ARP. The
procedure to follow is:</p>
<ul>
<li>Construct a <code>DOM2Model</code>, using a factory method such as
- <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/DOM2Model.html#createD2M(java.lang.String,%20com.hp.hpl.jena.rdf.model.Model)"><code>createD2M</code></a>,
+ <a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/DOM2Model.html#createD2M(java.lang.String,%20org.apache.jena.rdf.model.Model)"><code>createD2M</code></a>,
specifying the xml:base of the document to be loaded, the Model to
load into, optionally the xml:lang value (particularly useful if
using a DOM Node from within a Document).</li>
<li>Set any properties, error handlers etc. on the <code>DOM2Model</code>
object.</li>
<li>The DOM is parsed simply by calling the
- <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/DOM2Model.html#load(org.w3c.dom.Node)"><code>load(Node)</code></a>
+ <a href="/documentation/javadoc/jena/org/apache/jena/rdf/arp/DOM2Model.html#load(org.w3c.dom.Node)"><code>load(Node)</code></a>
method.</li>
</ul>
-<h3 id="using-a-dom-as-input-to-arp">Using a DOM as Input to ARP</h3>
+<h3 id="using-a-dom-as-input-to-arp">Using a DOM as Input to ARP<a class="headerlink" href="#using-a-dom-as-input-to-arp" title="Permanent link">¶</a></h3>
<p>DOM2Model is a subclass of SAX2RDF, and handlers etc. can be set on
the DOM2Model as for SAX2RDF. Using a null model as the argument to
the factory indicates this usage.</p>