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 2012/05/15 00:27:50 UTC
svn commit: r817646 - in /websites/staging/jena/trunk/content: ./
documentation/ documentation/assembler/ documentation/inference/
documentation/io/ documentation/notes/ documentation/ontology/
documentation/query/ documentation/sdb/ documentation/serv...
Author: buildbot
Date: Mon May 14 22:27:48 2012
New Revision: 817646
Log:
Staging update by buildbot for jena
Modified:
websites/staging/jena/trunk/content/ (props changed)
websites/staging/jena/trunk/content/documentation/assembler/assembler-howto.html
websites/staging/jena/trunk/content/documentation/index.html
websites/staging/jena/trunk/content/documentation/inference/index.html
websites/staging/jena/trunk/content/documentation/io/iohowto.html
websites/staging/jena/trunk/content/documentation/notes/concurrency-howto.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/typed-literals.html
websites/staging/jena/trunk/content/documentation/ontology/index.html
websites/staging/jena/trunk/content/documentation/query/arq-query-eval.html
websites/staging/jena/trunk/content/documentation/query/cmds.html
websites/staging/jena/trunk/content/documentation/query/extension.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/logging.html
websites/staging/jena/trunk/content/documentation/query/support.html
websites/staging/jena/trunk/content/documentation/query/support_request.html
websites/staging/jena/trunk/content/documentation/query/writing_functions.html
websites/staging/jena/trunk/content/documentation/sdb/databases_supported.html
websites/staging/jena/trunk/content/documentation/sdb/index.html
websites/staging/jena/trunk/content/documentation/sdb/installation.html
websites/staging/jena/trunk/content/documentation/serving_data/index.html
websites/staging/jena/trunk/content/documentation/serving_data/soh.html
websites/staging/jena/trunk/content/documentation/tdb/java_api.html
websites/staging/jena/trunk/content/documentation/tdb/optimizer.html
websites/staging/jena/trunk/content/documentation/tools/eyeball-getting-started.html
websites/staging/jena/trunk/content/tutorials/rdf_api.html
websites/staging/jena/trunk/content/tutorials/sparql_basic_patterns.html
Propchange: websites/staging/jena/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Mon May 14 22:27:48 2012
@@ -1 +1 @@
-1337964
+1338462
Modified: websites/staging/jena/trunk/content/documentation/assembler/assembler-howto.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/assembler/assembler-howto.html (original)
+++ websites/staging/jena/trunk/content/documentation/assembler/assembler-howto.html Mon May 14 22:27:48 2012
@@ -331,7 +331,7 @@ by an explicit <code>ja:contentEncoding<
the content of the string. The only encodings permitted are "N3"
and "RDF/XML". For example:</p>
<div class="codehilite"><pre><span class="err">eg:literal-content-example</span>
- <span class="err">ja:literalContent</span> <span class="err">"\_:it</span> <span class="err">dc:title</span> <span class="err">'Interesting</span> <span class="err">Times'"</span>
+ <span class="err">ja:literalContent</span> <span class="err">"_:it</span> <span class="err">dc:title</span> <span class="err">'Interesting</span> <span class="err">Times'"</span>
<span class="err">.</span>
</pre></div>
@@ -435,12 +435,15 @@ example.</p>
<p>Because Jena's access to external reasoners goes through the same
API as for its internal reasoners, you can access a DIG reasoner
(such as Pellet running as a server) using an Assembler
-specification:
- eg:external-inference-example
- ja:reasoner [<a href="http://jena.hpl.hp.com/2003/JenaReasoner#extReasonerURL">http://jena.hpl.hp.com/2003/JenaReasoner#extReasonerURL</a>
- <a href="http://localhost:2004/">http://localhost:2004/</a> ;
- ja:reasonerURL <a href="http://jena.hpl.hp.com/2003/DIGReasoner">http://jena.hpl.hp.com/2003/DIGReasoner</a>]
- .</p>
+specification:</p>
+<div class="codehilite"><pre><span class="err">eg:</span><span class="kd">extern</span><span class="err">al-inference-example</span>
+ <span class="err">ja:reasoner</span> <span class="err">[<http:</span><span class="c1">//jena.hpl.hp.com/2003/JenaReasoner#extReasonerURL></span>
+ <span class="err"><http:</span><span class="c1">//localhost:2004/> ;</span>
+ <span class="err">ja:reasonerURL</span> <span class="err"><http:</span><span class="c1">//jena.hpl.hp.com/2003/DIGReasoner>]</span>
+ <span class="err">.</span>
+</pre></div>
+
+
<p>If there's a DIG server running locally on port 2004, this
specification will create a DIG inference model that uses it.</p>
<p>The internal rule reasoner can be supplied with rules written
@@ -705,7 +708,7 @@ which is a path to policy files as descr
documentation. If absent, the usual default path is applied.</p>
<p>If the sub-model of the assembler specification reachable from the
DocumentManager resource contains any OntDocumentManager
-<code>DOC\_MGR\_POLICY</code> or <code>ONTOLOGY\_SPEC</code> objects, they will be
+<code>DOC_MGR_POLICY</code> or <code>ONTOLOGY_SPEC</code> objects, they will be
interpreted by the constructed document manager object.</p>
<div class="codehilite"><pre><span class="err">ja:FileManager</span> <span class="err">a</span> <span class="err">rdfs:Class</span> <span class="err">;</span>
<span class="err">rdfs:subClassOf</span> <span class="err">[owl:onProperty</span> <span class="err">ja:locationMapper;</span> <span class="err">owl:maxCardinality</span> <span class="err">1]</span> <span class="err">;</span>
Modified: websites/staging/jena/trunk/content/documentation/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/index.html Mon May 14 22:27:48 2012
@@ -159,23 +159,23 @@
<h1 class="title">Jena documentation overview</h1>
<p>This section contains detailed information about the various Jena
sub-systems, aimed at developers using Jena. For more general introductions,
-please refer to the <a href="/getting_started">Getting started</a> and <a href="/tutorials">Tutorial</a>
+please refer to the <a href="/getting_started/">Getting started</a> and <a href="/tutorials/">Tutorial</a>
sections.</p>
<h2 id="documentation-index">Documentation index</h2>
<ul>
-<li><a href="./rdf">The RDF API</a> - the core RDF API in Jena</li>
-<li><a href="./query">SPARQL</a> - querying and updating RDF models using the SPARQL standards</li>
-<li><a href="./assembler">Assembler</a> - describing recipes for constructing Jena models declaratively using RDF</li>
-<li><a href="./inference">Inference</a> - using the Jena rules engine and other inference algorithms to derive consequences from RDF models</li>
-<li><a href="./javadoc">Javadoc</a> - JavaDoc generated from the Jena source</li>
-<li><a href="./larq">LARQ</a> - enhanced indexes using Lucene for more efficient searching of text literals in Jena models</li>
-<li><a href="./io">I/O</a> - notes on input and output of triples to and from Jena models</li>
-<li><a href="./notes">How-To's</a> - various topic-specific how-to documents</li>
-<li><a href="./ontology">Ontology</a> - support for handling OWL models in Jena</li>
-<li><a href="./sdb">SQL DB</a> - constructing persistent Jena models using SQL databases as the storage layer</li>
-<li><a href="./tdb">TDB</a> - a fast persistent triple store that stores directly to disk without requiring a relational store</li>
-<li><a href="./serving_data">Serving RDF data</a> - servers which can present RDF data and answer SPARQL queries over HTTP</li>
-<li><a href="./tools">Tools</a> - various command-line tools and utilities to help developers manage RDF data and other aspects of Jena</li>
+<li><a href="./rdf/">The RDF API</a> - the core RDF API in Jena</li>
+<li><a href="./query/">SPARQL</a> - querying and updating RDF models using the SPARQL standards</li>
+<li><a href="./assembler/">Assembler</a> - describing recipes for constructing Jena models declaratively using RDF</li>
+<li><a href="./inference/">Inference</a> - using the Jena rules engine and other inference algorithms to derive consequences from RDF models</li>
+<li><a href="./javadoc/">Javadoc</a> - JavaDoc generated from the Jena source</li>
+<li><a href="./larq/">LARQ</a> - enhanced indexes using Lucene for more efficient searching of text literals in Jena models</li>
+<li><a href="./io/">I/O</a> - notes on input and output of triples to and from Jena models</li>
+<li><a href="./notes/">How-To's</a> - various topic-specific how-to documents</li>
+<li><a href="./ontology/">Ontology</a> - support for handling OWL models in Jena</li>
+<li><a href="./sdb/">SQL DB</a> - constructing persistent Jena models using SQL databases as the storage layer</li>
+<li><a href="./tdb/">TDB</a> - a fast persistent triple store that stores directly to disk without requiring a relational store</li>
+<li><a href="./serving_data/">Serving RDF data</a> - servers which can present RDF data and answer SPARQL queries over HTTP</li>
+<li><a href="./tools/">Tools</a> - various command-line tools and utilities to help developers manage RDF data and other aspects of Jena</li>
</ul>
</div>
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 Mon May 14 22:27:48 2012
@@ -163,7 +163,7 @@
and OWL inference supplied with Jena.</p>
<p> Not all of the fine details of the API are covered here: refer to the Jena
- <a href="../javadoc/index.html">Javadoc</a> to get the full details of the capabilities
+ <a href="/documentation/javadoc/jena/">Javadoc</a> to get the full details of the capabilities
of the API. </p>
<p> Note that this is a preliminary version of this document, some errors or inconsistencies
@@ -199,7 +199,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="../javadoc/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/com/hp/hpl/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
@@ -208,7 +208,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="../javadoc/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/com/hp/hpl/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
@@ -263,12 +263,12 @@
<h3 id="wzxhzdk183wzxhzdk184generic-reasoner-api"><a name="reasonerAPI"></a>Generic reasoner API</h3>
<h4 id="finding-a-reasoner">Finding a reasoner</h4>
<p><p>For each type of reasoner there is a factory class (which conforms to the interface
- <code><a href="../javadoc/com/hp/hpl/jena/reasoner/ReasonerFactory.html">ReasonerFactory</a></code>)
+ <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/ReasonerFactory.html">ReasonerFactory</a></code>)
an instance of which can be used to create instances of the <code>associated
- <a href="../javadoc/com/hp/hpl/jena/reasoner/Reasoner.html">Reasoner</a></code>.
+ <a href="/documentation/javadoc/jena/com/hp/hpl/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="../javadoc/com/hp/hpl/jena/reasoner/ReasonerRegistry.html">ReasonerRegistry</a></code>
+ a global <code><a href="/documentation/javadoc/jena/com/hp/hpl/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>,
@@ -295,7 +295,7 @@
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="../javadoc/com/hp/hpl/jena/vocabulary/ReasonerVocabulary.html">ReasonerVocabulary</a></code>
+ below and are predefined in the <code><a href="/documentation/javadoc/jena/com/hp/hpl/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",
@@ -313,7 +313,7 @@
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="../javadoc/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
+ the <a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>
methods, particularly <code>ModelFactory.createInfModel</code>. </p></p>
<h4 id="accessing-inferences">Accessing inferences</h4>
<p><p>Finally, having created a inference model then any API operations which access
@@ -363,8 +363,8 @@
in the statements directly to that model.</p>
<p>If we wanted to use a different reasoner which is not available as a convenience
- method or wanted to configure one we would change line [1]. For example, to
- create the same set up manually we could replace [1] by:</p>
+ method or wanted to configure one we would change line \[1\]. For example, to
+ create the same set up manually we could replace \[1\] by:</p>
<pre> Reasoner reasoner = ReasonerRegistry.getRDFSReasoner();
@@ -527,21 +527,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="../javadoc/com/hp/hpl/jena/vocabulary/ReasonerVocabulary.html"><code>ReasonerVocabulary</code></a>.</p>
+ in <a href="/documentation/javadoc/jena/com/hp/hpl/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="wzxhzdk428wzxhzdk429derivations"><a name="derivations"></a>Derivations</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="../javadoc/com/hp/hpl/jena/reasoner/Derivation.html"><code>Derviation</code></a>
+ method. This returns a iterator over a set <a href="/documentation/javadoc/jena/com/hp/hpl/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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/RuleDerivation.html">RuleDerivation</a></code>.</p>
+ can be accessed - see <code><a href="/documentation/javadoc/jena/com/hp/hpl/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
@@ -894,12 +894,11 @@ that is not compatible with 13</i></pre>
<p>The current release includes a default OWL reasoner and two small/faster configurations.
Each of the configurations is intended to be a sound implementation of a subset of OWL/full semantics
but none of them is complete (in the technical sense). For complete OWL DL reasoning use
-an external DL reasoner such as Pellet, Racer or FaCT. The <a href="../how-to/dig-reasoner.html">jena DIG interface</a> makes it
-easy to connect to any reasoner that supports the DIG standard. Performance (especially memory use) of the fuller reasoner
+an external DL reasoner such as Pellet, Racer or FaCT. Performance (especially memory use) of the fuller reasoner
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="wzxhzdk999wzxhzdk1000owl-coverage"><a name="OWLcoverage"></a>OWL coverage</h3>
+<h3 id="wzxhzdk997wzxhzdk998owl-coverage"><a name="OWLcoverage"></a>OWL coverage</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
@@ -1118,9 +1117,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="wzxhzdk1249wzxhzdk1250owl-configuration"><a name="OWLconfiguration"></a>OWL Configuration</h3>
+<h3 id="wzxhzdk1247wzxhzdk1248owl-configuration"><a name="OWLconfiguration"></a>OWL Configuration</h3>
<p><p>This reasoner is accessed using <code>ModelFactory.createOntologyModel</code>
- with the prebuilt <a href="../javadoc/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>
+ with the prebuilt <a href="/documentation/javadoc/jena/com/hp/hpl/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>
@@ -1155,7 +1154,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="wzxhzdk1315wzxhzdk1316owl-example"><a name="OWLexamples"></a>OWL Example</h3>
+<h3 id="wzxhzdk1313wzxhzdk1314owl-example"><a name="OWLexamples"></a>OWL Example</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>
@@ -1244,7 +1243,7 @@ Implicated node: eg:bigNameSpecialMB</i>
referencing two motherboards which are explicitly defined to be different resources
and thus violate the FunctionProperty nature of <code>hasMotherBoard</code>.</p>
<p>[<a href="#owl">OWL index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk1424wzxhzdk1425owl-notes-and-limitations"><a name="OWLnotes"></a>OWL notes and limitations</h3>
+<h3 id="wzxhzdk1422wzxhzdk1423owl-notes-and-limitations"><a name="OWLnotes"></a>OWL notes and limitations</h3>
<h4 id="comprehension-axioms">Comprehension axioms</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
@@ -1315,16 +1314,16 @@ 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="wzxhzdk1463wzxhzdk1464daml-support"><a name="daml"></a>DAML support</h2>
+<h2 id="wzxhzdk1461wzxhzdk1462daml-support"><a name="daml"></a>DAML support</h2>
<p><p>This is minimal legacy support. The DAMLMicroReasoner is
essentially the RDFS reasoner augmented by axioms declaring the equivalence
between the DAML constructs and their RDFS aliases. It is invoked using the
- prebuilt <a href="../javadoc/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>
+ prebuilt <a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>
<code>DAML_MEM_RULE_INF.</code></p>
<p>There are <u><b>no</b></u> plans to go beyond this and offer more complete
DAML inference support.</p>
<p>[<a href="#index">index</a>]</p></p>
-<h2 id="wzxhzdk1483wzxhzdk1484the-transitive-reasoner"><a name="transitive"></a>The transitive reasoner</h2>
+<h2 id="wzxhzdk1481wzxhzdk1482the-transitive-reasoner"><a name="transitive"></a>The transitive reasoner</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>.
@@ -1340,7 +1339,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="wzxhzdk1505wzxhzdk1506the-general-purpose-rule-engine"><a name="rules"></a>The general purpose rule engine</h2>
+<h2 id="wzxhzdk1503wzxhzdk1504the-general-purpose-rule-engine"><a name="rules"></a>The general purpose rule engine</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>
@@ -1354,7 +1353,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="wzxhzdk1553wzxhzdk1554overview-of-the-rule-engines"><a name="RULEoverview"></a>Overview of the rule engine(s)</h3>
+<h3 id="wzxhzdk1551wzxhzdk1552overview-of-the-rule-engines"><a name="RULEoverview"></a>Overview of the rule engine(s)</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
@@ -1363,7 +1362,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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/GenericRuleReasoner.html">GenericRuleReasoner</a></code>.
+ reasoner <code><a href="/documentation/javadoc/jena/com/hp/hpl/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
@@ -1373,10 +1372,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="wzxhzdk1575wzxhzdk1576rule-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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/Rule.html">Rule</a></code>
+<h3 id="wzxhzdk1573wzxhzdk1574rule-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>
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="../javadoc/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/com/hp/hpl/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
@@ -1414,7 +1413,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="../javadoc/com/hp/hpl/jena/util/PrintUtil.html">PrintUtil</a></code>
+ prefixes is those registered with the <code><a href="/documentation/javadoc/jena/com/hp/hpl/jena/util/PrintUtil.html">PrintUtil</a></code>
object. This initially knows about rdf, rdfs, owl, daml, 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>
@@ -2156,18 +2155,18 @@ while (i.hasNext()) {
####Builtins
<p>Second, the set of procedural builtins can be extended. A builtin should implement
- the <a href="../javadoc/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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/builtins/BaseBuiltin.html">BaseBuiltin</a></code>
+ 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>
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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/RuleContext.html">RuleContext</a></code>
+ the supplied <code><a href="/documentation/javadoc/jena/com/hp/hpl/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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/BuiltinRegistry.html"><code>BuiltinRegistry</code></a>
+ with <a href="/documentation/javadoc/jena/com/hp/hpl/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>
@@ -2177,7 +2176,7 @@ while (i.hasNext()) {
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="../javadoc/com/hp/hpl/jena/reasoner/rulesys/RulePreprocessHook.html"><code>RulePreprocessHook</code></a>
+ and the <a href="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/RulePreprocessHook.html"><code>RulePreprocessHook</code></a>
class for more details.</p>
<p>[<a href="#index">Index</a>]</p>
Modified: websites/staging/jena/trunk/content/documentation/io/iohowto.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/iohowto.html (original)
+++ websites/staging/jena/trunk/content/documentation/io/iohowto.html Mon May 14 22:27:48 2012
@@ -331,9 +331,9 @@ encodings on the classpath. This jar is
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://java.sun.com/j2se/1.4.2/docs/guide/intl/encoding.doc.html">1.4.2</a>,
+<a href="http://docs.oracle.com/javase/1.4.2/docs/guide/intl/encoding.doc.html">1.4.2</a>,
and
-<a href="http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html">1.5.0</a>.
+<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>
@@ -726,7 +726,7 @@ invocation.
<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="www.w3.org/TR/rdf-syntax-grammar">http://www.w3.org/TR/rdf-syntax-grammar</a>
+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>
Modified: websites/staging/jena/trunk/content/documentation/notes/concurrency-howto.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/notes/concurrency-howto.html (original)
+++ websites/staging/jena/trunk/content/documentation/notes/concurrency-howto.html Mon May 14 22:27:48 2012
@@ -181,9 +181,9 @@ the application burden is not high.</p>
<li>Multiple applications accessing the same persistent model
(typically, a database).</li>
</ul>
-<p>Transactions are provided by persistent models: see
+<p>Transactions are provided by persistent models: see
the <a href="/documentation/tdb/tdb_transactions.html">TDB documentation</a>
-and the <a href="/documenation/sdb/index.html">SDB documentation</a>
+and the <a href="/documentation/sdb/index.html">SDB documentation</a>
and for details.</p>
<p>This note describes the support for same-JVM, multi-threaded
applications.</p>
Modified: websites/staging/jena/trunk/content/documentation/notes/model-factory.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/notes/model-factory.html (original)
+++ websites/staging/jena/trunk/content/documentation/notes/model-factory.html Mon May 14 22:27:48 2012
@@ -258,39 +258,10 @@ specified reification style.</p>
although they are not required. We shall not discuss them further
in this document; consult the Javadoc for appropriate details.</p>
<h2 id="database-model-creation">Database model creation</h2>
-<p>Jena allows models to be created within databases. For an extensive
-discussion of the available options and controls, see the
-<a href="../DB/index.html">database howto documents</a>. The current
-ModelFactory interface only provides simple access to database
-model creation.
-ModelFactory creation of models takes place through RDB
-ModelMakers:</p>
-<ul>
-<li><code>createModelRDBMaker(IDBConnection c)</code></li>
-</ul>
-<p>delivers a ModelMaker that makes (or finds) models by name in the
-Jena model database attached to the connection <code>c</code>. Models from an
-RDB maker are "just like" memory-based models, except that they can
-be much larger, are likely to be significantly slower, and persist
-over application termination.
-The connection can be created in two ways:</p>
-<ul>
-<li>
-<p><code>ModelFactory.createSimpleRDBConnection(url,user,pass,type)</code>:
-creates a connection to the database with the given JDBC url, the
-given user and password, and the database type.</p>
-</li>
-<li>
-<p><code>ModelFactory.createSimpleRDBConnection()</code>: creates a connection to
-the database, taking the URL from the system property
-<strong>jena.db.url</strong>, the user name from <strong>jena.db.user</strong>, the password
-from <strong>jena.db.password</strong>, and the database type from
-<strong>jena.db.type</strong>.</p>
-</li>
-</ul>
-<p>Details of these fields can be found in the database documentation,
-as well as direct ways to construct connections if required, and
-additional operations on RDB Models that may be useful.</p>
+<p><em>Note:</em> this section previously referred to creating database models
+with RDB, a now obsolete Jena features. For methods of creating models
+with <a href="/documentation/sdb/index.html">SDB</a> and <a href="/documentation/tdb/index.html">TDB</a>
+please see the relevant reference sections.</p>
<h2 id="inference-model-creation">Inference model creation</h2>
<p>An important feature of Jena is support for different kinds of
inference over RDF-based models (used for RDFS, OWL, and DAML).
Modified: websites/staging/jena/trunk/content/documentation/notes/rdf-frames.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/notes/rdf-frames.html (original)
+++ websites/staging/jena/trunk/content/documentation/notes/rdf-frames.html Mon May 14 22:27:48 2012
@@ -352,7 +352,7 @@ converse for properties:</p>
<p>All of the above API methods return a Jena
-<a href="../javadoc/com/hp/hpl/jena/util/iterator/ExtendedIterator.html"><code>ExtendedIterator</code></a>.</p>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/util/iterator/ExtendedIterator.html"><code>ExtendedIterator</code></a>.</p>
<p><strong>Note a change from the Jena 2.1 interface:</strong> the optional Boolean
parameter on <code>listDeclaredProperties</code> has changed name from <code>all</code>
(Jena 2.1 and earlier) to <code>direct</code> (Jena 2.2 and later). The
Modified: websites/staging/jena/trunk/content/documentation/notes/typed-literals.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/notes/typed-literals.html (original)
+++ websites/staging/jena/trunk/content/documentation/notes/typed-literals.html Mon May 14 22:27:48 2012
@@ -281,7 +281,7 @@ made it impossible to cache literals in
<h2 id="how-datatypes-are-represented">How datatypes are represented</h2>
<p>Datatypes for typed literals are represented by instances of the
interface
-<a href="/documentation/javadoc/com/hp/hpl/jena/datatypes/RDFDatatype.html"><code>com.hp.hpl.jena.datatypes.RDFDatatype</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/datatypes/RDFDatatype.html"><code>com.hp.hpl.jena.datatypes.RDFDatatype</code></a>.
Instances of this interface can be used to parse and serialized
typed data, test for equality and test if a typed or lexical value
is a legal value for this datatype.</p>
@@ -333,7 +333,7 @@ base64Binary date time dateTime duration
gYearMonth gMonthDay</p>
</blockquote>
<p>These are all available as static member variables from
-<a href="/documentation/javadoc/com/hp/hpl/jena/datatypes/xsd/XSDDatatype.html"><code>com.hp.hpl.jena.datatypes.xsd.XSDDatatype</code></a>.</p>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/datatypes/xsd/XSDDatatype.html"><code>com.hp.hpl.jena.datatypes.xsd.XSDDatatype</code></a>.</p>
<p>Of these types, the following are registered as the default type to
use to represent certain Java classes:</p>
<table>
@@ -464,7 +464,7 @@ then tries to create and use two instanc
standard for how to map the datatype URI to a datatype definition.</p>
<p>Within Jena2 we allow new datatypes to be created and registered by
using the
-<a href="/documentation/javadoc/com/hp/hpl/jena/datatypes/TypeMapper.html"><code>TypeMapper</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/datatypes/TypeMapper.html"><code>TypeMapper</code></a>
class.</p>
<p>The easiest way to define a new RDFDatatype is to subclass
BaseDatatype and define implementations for parse, unparse and
Modified: websites/staging/jena/trunk/content/documentation/ontology/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/ontology/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/ontology/index.html Mon May 14 22:27:48 2012
@@ -161,7 +161,7 @@
ontology API, including some of the common tasks you may need
to perform. We
won't go into all of the many details of the API here: you should
-expect to refer to the <a href="/java/documentation/javadoc/">Javadoc</a> to
+expect to refer to the <a href="/documentation/javadoc/jena/">Javadoc</a> to
get full details of the capabilities of the API.</p>
<h3 id="prerequisites">Prerequisites</h3>
<p>We'll assume that you have a basic familiarity with RDF and with
@@ -387,17 +387,17 @@ profile is it <code>owl:ObjectProperty</
profile it is <code>null</code> since RDFS does not define object properties.</p>
<p>The profile is bound to an <em>ontology model</em>, which is an extended
version of Jena's
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> class.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a> class.
The base <code>Model</code> allows access to the statements in a collection of
RDF data.
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntModel.html"><code>OntModel</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModel.html"><code>OntModel</code></a>
extends this by adding support for the kinds of constructs expected to
be in an ontology: classes (in a class hierarchy), properties (in a
property hierarchy) and individuals.</p>
<p>When you're working with an
ontology in Jena, all of the state information remains encoded as
RDF triples (accessed as Jena
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/Statement.html"><code>Statement</code>s</a>) stored in the RDF
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Statement.html"><code>Statement</code>s</a>) stored in the RDF
model. The ontology API
doesn't change the RDF representation of ontologies. What it does
do is add a set of convenience classes and methods that make it
@@ -540,7 +540,7 @@ API throughout the rest of this document
<p>An ontology model is an extension of the Jena RDF model,
providing extra capabilities for handling ontologies. Ontology
models are created through the Jena
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>.
The simplest way to create an ontology model is as follows:</p>
<div class="codehilite"><pre><span class="n">OntModel</span> <span class="n">m</span> <span class="o">=</span> <span class="n">ModelFactory</span><span class="o">.</span><span class="n">createOntologyModel</span><span class="p">();</span>
</pre></div>
@@ -604,7 +604,7 @@ various language profiles are:</p>
</tbody>
</table>
<p>These URI's are used to look-up the language profile from the
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/ProfileRegistry.html"><code>ProfileRegistry</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/ProfileRegistry.html"><code>ProfileRegistry</code></a>.
The profile registry contains public constant declarations so
that you do not have to remember these URI's. Please note that the
URI's denoting OWL Lite and OWL DL are not officially sanctioned by
@@ -618,7 +618,7 @@ either of:</p>
<p>Beyond these basic choices, the complexities of configuring an
ontology model are wrapped up in a recipe object called
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>.
This specification allows complete control over the configuration
choices for the ontology model, including the language profile in
use, the reasoner, and the means of handling compound documents. A
@@ -759,7 +759,7 @@ number of common recipes are pre-declare
<p>For details of reasoner capabilities, please see the
<a href="../inference">inference documentation</a> and the Javadoc
for
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntModelSpec.html">OntModelSpec</a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModelSpec.html">OntModelSpec</a>.
See also further discussion <a href="#inference-intro">below</a>.</p>
<p><strong>Note:</strong> it is primarily the choice of reasoner, rather than the
choice of language profile, which determines which entailments are
@@ -935,7 +935,7 @@ a simple interface that allows different
on demand. For the database case, this may include passing the
database user-name and password and other connection parameters.
New model makers can be created with the
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>.</p>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/ModelFactory.html"><code>ModelFactory</code></a>.</p>
<p>There are two cases in which we may want to create storage for
models on-demand. The first is when creating the <code>OntModel</code> for the
first time. Some variants of <code>createOntologyModel</code> will allocate
@@ -958,7 +958,7 @@ programming interface (<code>Model</code
data structure (<code>Graph</code>). Hence some potential confusion in that
Figure 4, above, refers to a structure containing graphs, but we
use a
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/ModelMaker.html"><code>ModelMaker</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/ModelMaker.html"><code>ModelMaker</code></a>
to generate new stores. The document manager extracts the
appropriate graph from the containing model. Except in cases where
you are extending Jena's internal structures, you should think of
@@ -985,7 +985,7 @@ fail just because it temporarily does no
because a previously published ontology has been moved.
To alleviate these commonly
experienced problems, we can use Jena's
-<a href="/documentation/javadoc/com/hp/hpl/jena/util/FileManager.html"><code>FileManager</code></a> to
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/util/FileManager.html"><code>FileManager</code></a> to
manage local indirections, so that an attempt to import a
document from a given published URL means that a local copy of the
document is loaded instead. This may be a file on the local disk, or simply a
@@ -1065,14 +1065,14 @@ by calling <code>clearCache()</code>.</p
<h2 id="the-generic-ontology-type-ontresource">The generic ontology type: OntResource</h2>
<p>All of the classes in the ontology API that represent ontology
values have
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntResource.html"><code>OntResource</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntResource.html"><code>OntResource</code></a>
as a common super-class. This makes <code>OntResource</code> a good place to
put shared functionality for all such classes, and makes a handy
common return value for general methods. The Java interface
<code>OntResource</code> extends Jena's RDF
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/Resource.html"><code>Resource</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Resource.html"><code>Resource</code></a>
interface, so any general method that accepts a resource or an
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/RDFNode.html"><code>RDFNode</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFNode.html"><code>RDFNode</code></a>
will also accept an <code>OntResource</code>, and consequently, any other
ontology value.</p>
<p>Some of the common attributes of ontology resources that are
@@ -1246,7 +1246,7 @@ returned.</p>
<h2 id="ontology-classes-and-basic-class-expressions">Ontology classes and basic class expressions</h2>
<p>Classes are the basic building blocks of an ontology. A simple
class is represented in Jena by an
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntClass.html">OntClass</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntClass.html">OntClass</a>
object. As <a href="#rdf-polymorphism">mentioned above</a>, an ontology class
is a facet of an RDF resource. One way, therefore, to get an
ontology class is to convert a plain RDF resource into
@@ -1388,11 +1388,11 @@ of Java classes that allow you to conven
properties represented in an ontology model.</p>
<p>A property in an ontology model is an extension of the core Jena
API class
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/Property.html"><code>Property</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Property.html"><code>Property</code></a>
and allows access to the additional information that can be
asserted about properties in an ontology language. The common API
super-class for representing ontology properties in Java is
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntProperty.html"><code>OntProperty</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntProperty.html"><code>OntProperty</code></a>.
Again, using the pattern of add, set, get, list, has, and remove
methods, we can access the following attributes of an
<code>OntProperty</code>:</p>
@@ -1460,10 +1460,10 @@ perform more efficient reasoning over on
entailments, and so is useful when annotating ontology documents,
for example.</p>
<p>In Jena, the Java interfaces
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/ObjectProperty.html"><code>ObjectProperty</code></a>,
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/DatatypeProperty.html"><code>DatatypeProperty</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/ObjectProperty.html"><code>ObjectProperty</code></a>,
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/DatatypeProperty.html"><code>DatatypeProperty</code></a>
and
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/AnnotationProperty.html"><code>AnnotationProperty</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/AnnotationProperty.html"><code>AnnotationProperty</code></a>
are sub-types of <code>OntProperty</code>. However, they do not have any
behaviours (methods) particular to themselves. Their existence
allows the more complex sub-types of ObjectProperty – transitive
@@ -1481,7 +1481,7 @@ property, and individual <code>:jane</co
equivalent to stating that the property has a maximum cardinality
of one.</p>
<p>Being a functional property is represented through the
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/FunctionalProperty.html"><code>FunctionalProperty</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/FunctionalProperty.html"><code>FunctionalProperty</code></a>
facet of an ontology property object. If a property is declared
functional (test using the <code>isFunctional()</code> method), then the
method <code>asFunctionalProperty()</code> conveniently returns the functional property
@@ -1492,13 +1492,13 @@ parameter to the <code>createObjectPrope
<h3 id="other-property-types">Other property types</h3>
<p>There are several additional sub-types of ObjectProperty that
represent additional capabilities of ontology properties. A
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/TransitiveProperty.html"><code>TransitiveProperty</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/TransitiveProperty.html"><code>TransitiveProperty</code></a>
means that if p is transitive, and we know <code>:a p :b</code> and also
<code>b p :c</code>, we can infer that <code>:a p :c</code>. A
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/SymmetricProperty.html"><code>SymmetricProperty</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/SymmetricProperty.html"><code>SymmetricProperty</code></a>
means that if p is symmetric, and we know <code>:a p :b</code>, we can infer
<code>:b p :a</code>. An
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/InverseFunctionalProperty.html"><code>InverseFunctionalProperty</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/InverseFunctionalProperty.html"><code>InverseFunctionalProperty</code></a>
means that for any given range element, the domain value is unique.</p>
<p>Given that all properties are <code>RDFNode</code> objects, and therefore
support the <code>as()</code> method, you can use <code>as()</code> to change from an
@@ -1547,7 +1547,7 @@ expression: <em>restrictions</em> and <e
each in turn.</p>
<h3 id="restriction-class-expressions">Restriction class expressions</h3>
<p>A
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/Restriction.html">restriction</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/Restriction.html">restriction</a>
defines a class by reference to one of the properties of the
individuals that comprise the members of the class, and then
placing some constraint on that property. For example, in a simple
@@ -1752,9 +1752,9 @@ is even more compact:</p>
<p>Although lists are defined in the generic RDF model in Jena, they
are extensively used by the ontology API so we mention them here.
Full details of the methods defined are in the
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/RDFList.html"><code>RDFList javadoc</code></a>.</p>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFList.html"><code>RDFList javadoc</code></a>.</p>
<p>Various means of constructing lists are defined in
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a>, as
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html"><code>Model</code></a>, as
variants on <code>createList</code>. For example, we can construct a list of
three classes as follows:</p>
<div class="codehilite"><pre><span class="n">OntModel</span> <span class="n">m</span> <span class="o">=</span> <span class="n">ModelFactory</span><span class="o">.</span><span class="n">createOntModel</span><span class="p">();</span>
@@ -1783,7 +1783,7 @@ in the list is not considered significan
<p>Finally, a resource which is a cell in a list sequence will accept
<code>.as( RDFList.class )</code></p>
<p>Once the list has been created or obtained from the model,
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/RDFList.html"><code>RDFList</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/RDFList.html"><code>RDFList</code></a>
methods may be used to access members of the list, iterate over the
list, and so forth. For example:</p>
<div class="codehilite"><pre><span class="n">System</span><span class="o">.</span><span class="n">out</span><span class="o">.</span><span class="n">println</span><span class="p">(</span> <span class="s">"List has "</span> <span class="o">+</span> <span class="n">myRDFList</span><span class="o">.</span><span class="n">size</span><span class="p">()</span> <span class="o">+</span> <span class="s">" members:"</span> <span class="p">);</span>
@@ -1860,7 +1860,7 @@ that <code>m</code> is a model into whic
<p>Union and intersection class expressions are very similar, so
Jena defines a common super-class
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/BooleanClassDescription.html"><code>BooleanClassDescription</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/BooleanClassDescription.html"><code>BooleanClassDescription</code></a>.
This class provides access to the <em>operands</em> to the expression. In
the intersection example above, the operands are the two restrictions. The
<code>BooleanClassDescription</code> class allows us to set the operands
@@ -1875,7 +1875,7 @@ class. Recall that a class is a set of i
to define the members of the <em>implicitly</em>: for example, "the class
of UK conferences". Sometimes it is convenient to define a class
<em>explicitly</em>, by stating the individuals the class contains. An
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/EnumeratedClass.html">enumerated class</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/EnumeratedClass.html">enumerated class</a>
is exactly the class whose members are the given individuals. For
example, we know that the class of PrimaryColours contains exactly
red, green and blue, and no others.</p>
@@ -1914,7 +1914,7 @@ following:</p>
<p>An OWL <code>DataRange</code> is similar to an enumerated class, except that the members
of the <code>DataRange</code> are literal values, such as integers, dates or strings. See the
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/DataRange.html"><code>DataRange</code> javadoc</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/DataRange.html"><code>DataRange</code> javadoc</a>
for more details.</p>
<h3 id="listing-classes">Listing classes</h3>
<p>In many applications, we need to inspect the set of classes
@@ -1945,7 +1945,7 @@ get a list of named hierarchy root class
that lie closest to the top of the hierarchy (alternatively: the
shallowest fringe of the hierarchy consisting solely of named
classes), use the
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntTools.html">OntTools</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntTools.html">OntTools</a>
method <code>namedHierarchyRoots()</code>.</p>
<p>You should also note that it is important to close the iterators
returned from the <code>list...</code> methods, particularly when the underlying
@@ -1971,7 +1971,7 @@ declarations. In OWL Lite and DL, the la
instance data that the application is working with are kept
separate, by definition of the language. Jena therefore supports a
simple notion of an
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/Individual.html"><code>Individual</code></a>,
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/Individual.html"><code>Individual</code></a>,
which is essentially an alias for <code>Resource</code>. While <code>Individual</code>s
are largely synonymous with <code>Resource</code>s, they do provide an
programming interface that is consistent with the other Java
@@ -2021,7 +2021,7 @@ the <em>base URI</em> of the document co
URI may be stated in the document through an <code>xml:base</code> declaration
in the XML preamble. The base URI can also be specified when
reading the document via Jena's Model API (see the <code>read()</code> methods
-on <a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntModel.html"><code>OntModel</code></a>
+on <a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModel.html"><code>OntModel</code></a>
for reference).</p>
<p>We can attach various meta-data statements to this object to
indicate attributes of the ontology as a whole. The Java object
@@ -2059,7 +2059,7 @@ contains common meta-data properties, su
version information.</p>
<p>In the Jena API, the ontology's metadata properties can be accessed
through the
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/Ontology.html"><code>Ontology</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/Ontology.html"><code>Ontology</code></a>
interface. Suppose we wish to know the list of URI's that the
ontology imports. First we must obtain the resource representing the
ontology itself:</p>
@@ -2160,7 +2160,7 @@ capabilities are supported, and what the
performance are.</p>
<p>The reasoner attached to an ontology model, if any, is specified
through the
-<a href="/documentation/javadoc/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>.
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>.
The methods <code>setReasoner()</code> and <code>setReasonerFactory()</code> on the model
spec are used to specify a reasoner. The setReasoner variant is
intended for use on a specification which will only be used to
@@ -2185,7 +2185,7 @@ considerably.</p>
<p>Jena's inference machinery defines some specialised services that
are not exposed through the addition of extra triples to the model.
These are exposed by the
-<a href="/documentation/javadoc/com/hp/hpl/jena/rdf/model/InfModel.html"><code>InfModel</code></a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/InfModel.html"><code>InfModel</code></a>
interface; for convenience OntModel extends this interface to make
these services directly available to the user. Please note that
calling inference-specific methods on an ontology model that does
@@ -2213,10 +2213,8 @@ of the ontology model:</p>
</pre></div>
-<p>See also the note on
-<a href="common-problems.html#aBox-tBox">combining a-box and t-box data</a>
-using the OntModel.</p>
<h2 id="working-with-persistent-ontologies">Working with persistent ontologies</h2>
+<p><em>TODO:</em> update this section to refer specifically to TDB.</p>
<p>A common way to work with ontology data is to load the ontology
axioms and instances at run-time from a set of source documents.
This is a very flexible approach, but has limitations. In
@@ -2230,11 +2228,10 @@ computer's main memory, but at the expen
database interaction) to retrieve and update RDF data from the
model. In this section we briefly discuss using the ontology API with
Jena's persistent database models.</p>
-<p>For information on setting-up and accessing the database models
-themselves, see the <a href="../DB/index.html">DB documentation</a>.
-For one method of using a
-persistent database to manage ontology imports, see
-<a href="http://www.iandickinson.me.uk/articles/jena-tip-db-import/">this article</a>.</p>
+<p>For information on setting-up and accessing the persistent models
+themselves, please see the
+<a href="/documentation/sdb/index.html">SDB</a> and <a href="/documentation/tdb/index.html">TDB</a>
+reference sections.</p>
<p>There are two somewhat separate requirements for persistently
storing ontology data. The first is making the main or base model
itself persistent. The second is re-using or creating persistent
Modified: websites/staging/jena/trunk/content/documentation/query/arq-query-eval.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/arq-query-eval.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/arq-query-eval.html Mon May 14 22:27:48 2012
@@ -168,7 +168,7 @@ incorporate custom code into a query.
<a href="extension.html#value-functions">Custom filter functions</a> and
<a href="extension.html#property-functio-ns">property functions</a> p-rovi-de ways
to add application specific code. The
-<a href="lucene-arq.html">free text search</a> capabilities, using Apache
+<a href="/documentation/larq/">free text search</a> capabilities, using Apache
Lucene, are provided via a property function. Custom filter
functions and property functions should be used where possible.</p>
<p>Jena itself can be extended by providing a new implementation of
@@ -257,7 +257,7 @@ empty graph pattern).</p>
the internal data-structure for the algebra.</p>
<p>The <a href="http://www.sparql.org/validator.html">online SPARQL validator</a>
at <a href="http://sparql.org/">sparql.org</a> can be used to see the algebra
-expression for a SPARQL query. This validator is also include in
+expression for a SPARQL query. This validator is also include in
<a href="../serving_data/">Fuseki</a>.</p>
<h3 id="high-level-optimization-and-transformations">High-Level Optimization and Transformations</h3>
<p>There is a collection of transformations that can be applied to the
@@ -618,7 +618,6 @@ intercept evaluation initialization.Â
requires the evaluation of a sub-class of <code>OpExt</code>, the <code>eval</code>
method is called. SDB uses this to introduce an operator that is
implemented in SQL.</p>
-<p><a href="index.html">ARQ documentation index</a></p>
</div>
<div id="footer">
Modified: websites/staging/jena/trunk/content/documentation/query/cmds.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/cmds.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/cmds.html Mon May 14 22:27:48 2012
@@ -285,15 +285,15 @@ clause). Indicates whether an evaluation
form.</li>
</ul>
<h3 id="arqlarqbuilder"><code>arq.larqbuilder</code></h3>
-<p>Build or update a <a href="lucene-arq.html">LARQ index</a>. If a dataset is
+<p>Build or update a <a href="/documentation/larq/">LARQ index</a>. If a dataset is
given to the command, all graphs are indexed. if a single graph is
given to the command, that graph is indexed.</p>
<ul>
<li><code>--larq</code> : Name of the directory for the Lucene index files.</li>
<li><code>--subjects</code> : By default literals are indexed against the
- literal RDF node (<a href="cmds.htm#lPattern_1">pattern 1</a>). Using this
+ literal RDF node (<a href="cmds.html#lPattern_1">pattern 1</a>). Using this
argument cause the subject RDF terms to be indexed
- (<a href="cmds.htm#lPattern_2">pattern 2</a>).</li>
+ (<a href="cmds.html#lPattern_2">pattern 2</a>).</li>
<li>Dataset description using <code>--data FILE</code> or <code>--desc.</code></li>
</ul>
<h3 id="arqlarq"><code>arq.larq</code></h3>
@@ -302,7 +302,6 @@ as appropriate).</p>
<ul>
<li><code>--larq</code> : Name of the directory for the Lucene index files.</li>
</ul>
-<p><a href="index.html">ARQ documentation index</a></p>
</div>
<div id="footer">
Modified: websites/staging/jena/trunk/content/documentation/query/extension.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/extension.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/extension.html Mon May 14 22:27:48 2012
@@ -182,7 +182,7 @@ functionality and remain within SPARQL.
<a href="library-propfunc.html">property function library</a>. Applications
can
<a href="writing_propfunc.html">write and register their own property functions</a>.</p>
-<p>The <a href="lucene-arq.html">free text support in ARQ</a> is provided by
+<p>The <a href="/documentation/larq/">free text support in ARQ</a> is provided by
<a href="http://lucene.apache.org/java/docs/index.html">Lucene</a>, using
property functions.</p>
<h2 id="filter-functions">Filter Functions</h2>
@@ -291,9 +291,6 @@ portable - use with care.</p>
<span class="n">_:b0</span> <span class="c1"># A blank node in the query - a variable</span>
</pre></div>
-
-
-<p><a href="index.html">ARQ documentation index</a></p>
</div>
<div id="footer">
Modified: websites/staging/jena/trunk/content/documentation/query/java-uri.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/java-uri.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/java-uri.html Mon May 14 22:27:48 2012
@@ -190,7 +190,6 @@ in the Java package com.hp.hpl.jena.spar
mapped loader includes a partial rewrite rule turning http URLs
starting with that namespace into java: URIs using the package
name.</p>
-<p><a href="documentation.html">ARQ documentation index</a></p>
</div>
<div id="footer">
Modified: websites/staging/jena/trunk/content/documentation/query/library-function.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/library-function.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/library-function.html Mon May 14 22:27:48 2012
@@ -163,7 +163,7 @@ function by URI (or prefixed name) in FI
provides a function library and supports application-provided
functions. Functions and property functions can be
<a href="extension.html">registered or dynamically loaded</a>.</p>
-<p>See also the <a href="lucene-arq.html">free text search</a> page.</p>
+<p>See also the <a href="/documentation/larq/">free text search</a> page.</p>
<p>See also the <a href="library-propfunc.html">property functions</a> library
page.</p>
<p>Applications can also
@@ -396,7 +396,6 @@ functions.</p>
</tr>
</tbody>
</table>
-<p><a href="index.html">ARQ documentation index</a></p>
</div>
<div id="footer">
Modified: websites/staging/jena/trunk/content/documentation/query/logging.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/logging.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/logging.html Mon May 14 22:27:48 2012
@@ -158,7 +158,7 @@
<div id="content">
<h1 class="title">ARQ - Logging</h1>
<p>ARQ uses
-<a href="http://jakarta.apache.org/commons/logging/">Apache Commons Logging</a>
+<a href="http://commons.apache.org/logging/">Apache Commons Logging</a>
as the API and ships with
<a href="http://logging.apache.org/log4j/docs/">Log4J</a> as a deployment
system. You can use Java 1.4 logging instead.</p>
Modified: websites/staging/jena/trunk/content/documentation/query/support.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/support.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/support.html Mon May 14 22:27:48 2012
@@ -159,10 +159,10 @@
<h1 class="title">ARQ â Support</h1>
<p>Read the following first:</p>
<ul>
-<li><a href="FAQ.html">Frequently Asked Questions</a></li>
+<li><a href="faq.html">Frequently Asked Questions</a></li>
<li>Submitting a
<a href="support_request.html">support request or bug reports</a></li>
-<li>The <a href="documentation.html">documentation</a></li>
+<li>The <a href="index.html">documentation</a></li>
</ul>
<p>Support for ARQ is provided via the Jena mailing list
<<a href="mailto:users@jena.apache.org">mailto:users@jena.apache.org</a>>.</p>
Modified: websites/staging/jena/trunk/content/documentation/query/support_request.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/support_request.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/support_request.html Mon May 14 22:27:48 2012
@@ -165,8 +165,8 @@ problem. State what you expected to happ
happen.</p>
<p>It also a good idea to check the documentation.</p>
<ul>
-<li><a href="FAQ.html">ARQ FAQ</a></li>
-<li><a href="documentation.html">ARQ Documentation</a></li>
+<li><a href="faq.html">ARQ FAQ</a></li>
+<li><a href="index.html">ARQ Documentation</a></li>
</ul>
<h3 id="parse-errors">Parse Errors</h3>
<p>The SPARQL parser outputs a line and column number - it is usually
Modified: websites/staging/jena/trunk/content/documentation/query/writing_functions.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/writing_functions.html (original)
+++ websites/staging/jena/trunk/content/documentation/query/writing_functions.html Mon May 14 22:27:48 2012
@@ -185,9 +185,9 @@ forms to allow for the special exception
argument. It should not access a graph nor return different values
for the same arguments (to allow expression optimization). Usually,
these requirements can be better met with a
-<a href="writing_propfunc.html">property function</a>. Functions can't bind a
+<a href="library-propfunc.html">property function</a>. Functions can't bind a
variables; this would be done in a
-<a href="writing_propfunc.html">property function</a> as well.</p>
+<a href="library-propfunc.html">property function</a> as well.</p>
<p>Example: (this is the max function in the standard ARQ library):</p>
<div class="codehilite"><pre><span class="n">public</span> <span class="n">class</span> <span class="n">max</span> <span class="n">extends</span> <span class="n">FunctionBase2</span>
<span class="p">{</span>
Modified: websites/staging/jena/trunk/content/documentation/sdb/databases_supported.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/sdb/databases_supported.html (original)
+++ websites/staging/jena/trunk/content/documentation/sdb/databases_supported.html Mon May 14 22:27:48 2012
@@ -186,7 +186,7 @@
<td>v5.0.22</td>
</tr>
<tr>
-<td><a href="http://db.apache.org/derby" title="http://db.apache.org/derby">Apache Derby</a></td>
+<td><a href="http://db.apache.org/derby/" title="http://db.apache.org/derby/">Apache Derby</a></td>
<td>v10.2.2.0</td>
</tr>
<tr>
Modified: websites/staging/jena/trunk/content/documentation/sdb/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/sdb/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/sdb/index.html Mon May 14 22:27:48 2012
@@ -182,7 +182,7 @@ line scripts and via the Jena API.</p>
<p>SDB is distributed from the Apache Jena project. See the
<a href="/download/">downloads page</a> for details.</p>
<h2 id="subversion">Subversion</h2>
-<p><a href="https://svn.apache.org/repos/asf/jena/jena-sdb">SDB subversion repository</a>
+<p><a href="https://svn.apache.org/repos/asf/jena/trunk/jena-sdb">SDB subversion repository</a>
at Apache.</p>
<h2 id="support">Support</h2>
<p><a href="/help_and_support">Support and questions</a></p>
Modified: websites/staging/jena/trunk/content/documentation/sdb/installation.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/sdb/installation.html (original)
+++ websites/staging/jena/trunk/content/documentation/sdb/installation.html Mon May 14 22:27:48 2012
@@ -168,8 +168,8 @@ tuned according to the database document
<a href="store_description.html" title="SDB/Store Description">store description</a>:
there are examples in the <code>Store/</code> directory.</p>
<p>A database must be created before the tests can be run.
-<a href="notesmssql.html" title="SDB/NotesMSSQL">Microsoft SQL server</a> and
-<a href="notespostgresql.html" title="SDB/NotesPostgreSQL">PostgreSQL</a> need
+<a href="db_notes.html#ms-sql">Microsoft SQL server</a> and
+<a href="db_notes.html#postgresql">PostgreSQL</a> need
specific database options set when a database is created.</p>
<p>To use in a Java application, put all the jar files in <code>lib/</code> on
the build and classpath of your application. See the
Modified: websites/staging/jena/trunk/content/documentation/serving_data/index.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/serving_data/index.html (original)
+++ websites/staging/jena/trunk/content/documentation/serving_data/index.html Mon May 14 22:27:48 2012
@@ -253,8 +253,7 @@ download.</p>
</ul>
<p>For the control panel:</p>
<ol>
-<li>In a browser, go to
- <a href="http://localhost:3030/"><code>http://localhost:3030/</code></a></li>
+<li>In a browser, go to <code>http://localhost:3030/</code></li>
<li>Click on "Control Panel</li>
<li>Select the dataset (if set up above, there is only one choice).</li>
</ol>
@@ -429,14 +428,14 @@ unnamed graph, use:</p>
<h2 id="fuseki-server-and-general-dataset-descriptions">Fuseki Server and general dataset descriptions</h2>
<p>The Fuseki server can be given an
-<a href="assembler.html">assembler description</a>
+<a href="/documentation/assembler/">assembler description</a>
to build a variety of model and datasets types.</p>
<div class="codehilite"><pre><span class="n">fuseki</span><span class="o">-</span><span class="n">server</span> <span class="o">--</span><span class="n">desc</span> <span class="n">assembler</span><span class="o">.</span><span class="n">ttl</span> <span class="o">/</span><span class="n">ds</span>
</pre></div>
<p>Full details of setting up models assembler is given in the
-<a href="assembler.html">assembler documentation</a>.</p>
+<a href="/documentation/assembler/">assembler documentation</a>.</p>
<p>A general dataset is described by:</p>
<div class="codehilite"><pre><span class="c1"># Dataset of default graph and one named graph.</span>
<span class="sr"><#dataset></span> <span class="n">rdf:type</span> <span class="n">ja:RDFDataset</span><span class="err">Â </span><span class="p">;</span>
Modified: websites/staging/jena/trunk/content/documentation/serving_data/soh.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/serving_data/soh.html (original)
+++ websites/staging/jena/trunk/content/documentation/serving_data/soh.html Mon May 14 22:27:48 2012
@@ -224,7 +224,7 @@ information about using SOH with some se
documentation for each server for authoritative information.</p>
<p>If you have details for other servers, <a href="/getting_involved/index.html">get involved</a></p>
<h3 id="fuseki">Fuseki</h3>
-<p>If a <a href="fuseki.html">Fuseki</a> server is run with the
+<p>If a <a href="index.html">Fuseki</a> server is run with the
command:</p>
<div class="codehilite"><pre><span class="n">fuseki</span><span class="o">-</span><span class="n">server</span> <span class="o">--</span><span class="n">mem</span> <span class="o">/</span><span class="n">dataset</span>
</pre></div>
Modified: websites/staging/jena/trunk/content/documentation/tdb/java_api.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/tdb/java_api.html (original)
+++ websites/staging/jena/trunk/content/documentation/tdb/java_api.html Mon May 14 22:27:48 2012
@@ -173,7 +173,7 @@ it as for any other model or dataset.</p
<li><a href="#concurrency">Concurrency</a></li>
<li><a href="#caching-and-synchronization">Caching and synchronization</a></li>
</ul>
-<p>TDB also supports <a href="transactions">tdb_transsactions.html</a>.</p>
+<p>TDB also supports <a href="tdb_transactions.html">transactions</a>.</p>
<h2 id="constructing-a-model-or-dataset">Constructing a model or dataset</h2>
<p>The class <code>TDBFactory</code> contains the static factory methods for
creating and connecting to a TDB-backed graph or an RDF dataset.
@@ -228,7 +228,7 @@ for details.</p>
than just using the Jena update operations.</p>
<p>It is accessed through the command line utility <code>tdbloader</code>.</p>
<h2 id="concurrency">Concurrency</h2>
-<p>TDB support <a href="transactions">tdb_transactions.html</a>, which is the preferred
+<p>TDB support <a href="tdb_transactions.html">transactions</a>, which is the preferred
way to work. It is possible to act directly on the dataset without transaction
with a Multiple Reader or Single Writer (MRSW) policy for
concurrency access. Applications are expected to adhere to this
@@ -237,8 +237,8 @@ policy - it is not automatically checked
database is making read operations and no updates to the dataset
are possible while an iterator is being used.</p>
<h2 id="caching-and-synchronization">Caching and synchronization</h2>
-<p>If used non-transactionally, then the application must be aware of
-the caching and synchronization used by TDB. TDB employs caching at
+<p>If used non-transactionally, then the application must be aware of
+the caching and synchronization used by TDB. TDB employs caching at
various levels, from RDF terms to disk
blocks. It is important to flush all caches to make the file state
consistent with the cached states because some caches are
Modified: websites/staging/jena/trunk/content/documentation/tdb/optimizer.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/tdb/optimizer.html (original)
+++ websites/staging/jena/trunk/content/documentation/tdb/optimizer.html Mon May 14 22:27:48 2012
@@ -317,7 +317,7 @@ using the constants in <code>Explain.Inf
<h2 id="statistics-rule-file">Statistics Rule File</h2>
-<p>The syntax is <a href="sse.html" title="SSE">SSE</a>, a simple format that uses
+<p>The syntax is <code>SSE</code>, a simple format that uses
<a href="http://www.w3.org/TeamSubmission/turtle/" title="http://www.w3.org/TeamSubmission/turtle/">Turtle</a>-syntax
for RDF terms, keywords for other terms (for example, the stats
marks a statistics data structure), and forms a tree data
@@ -349,9 +349,9 @@ structure.</p>
<p>This example statistics file contains some metadata about
statistics (time and date the file was generated, size of graph),
the frequence count for two predicates
-<a href="http://example/p" title="http://example/p">http://example/p</a> (written
+<code>http://example/p</code> (written
using a prefixed name) and
-<a href="http://example/q" title="http://example/q">http://example/q</a> (written in
+<code>http://example/q</code> (written in
full).</p>
<p>The numbers are the estimated counts. They do not have to be exact
- they guide the optimizer in choosing one execution plan over
Modified: websites/staging/jena/trunk/content/documentation/tools/eyeball-getting-started.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/tools/eyeball-getting-started.html (original)
+++ websites/staging/jena/trunk/content/documentation/tools/eyeball-getting-started.html Mon May 14 22:27:48 2012
@@ -164,12 +164,12 @@ for common problems. It is user-extensib
<ul>
<li>The <a href="eyeball-guide.html">brief guide</a>.</li>
<li>The <a href="eyeball-manual.html">manual</a>.</li>
-<li>The <a href="/documentation/javadoc/eyeball/index.html">JavaDoc</a>.</li>
+<li>The <a href="#todo/documentation/javadoc/eyeball/index.html">JavaDoc</a>.</li>
</ul>
<h2 id="getting-the-eyeball-release">Getting the Eyeball release</h2>
<!--Please see the [downloads page](/download/) for details.-->
-<p><b>Download from SourceForge:
+<p><b>Download from SourceForge:
<a href="http://sourceforge.net/projects/jena/files/Eyeball/Eyeball%202.3/">Eyeball distribution</a>
This predates the move of Jena to Apache and is not an Apache release.
</b></p>
Modified: websites/staging/jena/trunk/content/tutorials/rdf_api.html
==============================================================================
--- websites/staging/jena/trunk/content/tutorials/rdf_api.html (original)
+++ websites/staging/jena/trunk/content/tutorials/rdf_api.html Mon May 14 22:27:48 2012
@@ -181,8 +181,7 @@ model.</p>
<p>An implementation of the Jena API, including the working source code for
all the examples used in this tutorial can be downloaded from
-<a href="http://incubator.apache.org/jena/download/">
-"http://incubator.apache.org/jena/download/</a>.</p>
+<a href="http://jena.apache.org/download/"><code>jena.apache.org/download/</code></a>.</p>
<p></p>
@@ -1134,9 +1133,9 @@ should be reasonably clear that the Mode
intersection and difference of the Models can be computed in a similar
manner, using the methods <code>.intersection(Model)</code> and
<code>.difference(Model)</code>; see the
-<a href="../../javadoc/com/hp/hpl/jena/rdf/model/Model.html#difference(com.hp.hpl.jena.rdf.model.Model)">difference</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#difference(com.hp.hpl.jena.rdf.model.Model)">difference</a>
and
-<a href="../../javadoc/com/hp/hpl/jena/rdf/model/Model.html#intersection(com.hp.hpl.jena.rdf.model.Model)">intersection</a>
+<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/model/Model.html#intersection(com.hp.hpl.jena.rdf.model.Model)">intersection</a>
Javadocs for more details.
</p>
Modified: websites/staging/jena/trunk/content/tutorials/sparql_basic_patterns.html
==============================================================================
--- websites/staging/jena/trunk/content/tutorials/sparql_basic_patterns.html (original)
+++ websites/staging/jena/trunk/content/tutorials/sparql_basic_patterns.html Mon May 14 22:27:48 2012
@@ -239,7 +239,7 @@ is but uses the RDF rule for turning a q
concatenating the parts.</p>
<h3 id="blank-nodes">Blank Nodes</h3>
<p>Change the query just a little to return y as well
-(<a href="q-bp4.rq">q-bp4.rq</a>) :</p>
+(<a href="sparql_data/q-bp4.rq">q-bp4.rq</a>) :</p>
<div class="codehilite"><pre><span class="n">PREFIX</span> <span class="n">vcard:</span> <span class="sr"><http://www.w3.org/2001/vcard-rdf/3.0#></span>
<span class="n">SELECT</span> <span class="p">?</span><span class="n">y</span> <span class="p">?</span><span class="n">givenName</span>