jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From build...@apache.org
Subject svn commit: r842959 - in /websites/staging/jena/trunk/content: ./ documentation/assembler/ documentation/inference/ documentation/io/ documentation/notes/ documentation/ontology/ documentation/tools/ tutorials/
Date Tue, 18 Dec 2012 10:54:59 GMT
Author: buildbot
Date: Tue Dec 18 10:54:57 2012
New Revision: 842959

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/inference/index.html
    websites/staging/jena/trunk/content/documentation/io/features.html
    websites/staging/jena/trunk/content/documentation/io/iohowto.html
    websites/staging/jena/trunk/content/documentation/notes/model-factory.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/tools/eyeball-guide.html
    websites/staging/jena/trunk/content/documentation/tools/schemagen.html
    websites/staging/jena/trunk/content/tutorials/rdf_api.html

Propchange: websites/staging/jena/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Tue Dec 18 10:54:57 2012
@@ -1 +1 @@
-1414127
+1423404

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 Tue Dec 18 10:54:57 2012
@@ -651,7 +651,6 @@ appropriate properties:</p>
 <li>OWL DL: http://www.w3.org/TR/owl-features/#term_OWLDL</li>
 <li>OWL Lite: http://www.w3.org/TR/owl-features/#term_OWLLite</li>
 <li>RDFS: http://www.w3.org/2000/01/rdf-schema#</li>
-<li>DAML: http://www.daml.org/2001/03/daml+oil#</li>
 </ul>
 </li>
 </ul>

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 Dec 18 10:54:57 2012
@@ -176,13 +176,12 @@
   <li><a href="#api">The inference API</a></li>
   <li><a href="#rdfs">The RDFS reasoner</a></li>
   <li><a href="#owl">The OWL reasoner</a></li>
-  <li><a href="#daml">DAML support</a></li>
   <li><a href="#transitive">The transitive reasoner</a></li>
   <li><a href="#rules">The general purpose rule engine</a></li>
   <li><a href="#extensions">Extending the inference support</a></li>
   <li><a href="#futures">Futures</a></li>
 </ol></p>
-<h2 id="wzxhzdk60wzxhzdk61overview-of-inference-support"><a name="overview"></a>Overview of inference support</h2>
+<h2 id="wzxhzdk56wzxhzdk57overview-of-inference-support"><a name="overview"></a>Overview of inference support</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
@@ -228,25 +227,20 @@
   provides convenient access to prebuilt instances of the main supplied reasoners.</p></p>
 <h3 id="available-reasoners">Available reasoners</h3>
 <p><p>Included in the Jena distribution are a number of predefined reasoners:</p>
-<dl>
-  <dt>Transitive reasoner</dt>
-  <dd>Provides support for storing and traversing class and property lattices.
+<ol>
+  <li>Transitive reasoner: Provides support for storing and traversing class and property lattices.
     This implements just the <i>transitive</i> and <i>reflexive</i> properties
-    of <code>rdfs:subPropertyOf</code> and <code>rdfs:subClassOf</code>.</dd>
-  <dt>RDFS rule reasoner</dt>
-  <dd>Implements a configurable subset of the RDFS entailments.</dd>
-  <dt>OWL, OWL Mini, OWL Micro Reasoners</dt>
-  <dd>A set of useful but incomplete implementation of the OWL/Lite subset of the OWL/Full
-    language. </dd>
-  <dt>DAML micro reasoner</dt>
-  <dd>Used internally to enable the legacy DAML API to provide minimal (RDFS scale) inferencing.</dd>
-  <dt>Generic rule reasoner</dt>
-  <dd>A rule based reasoner that supports user defined rules. Forward chaining,
-    tabled backward chaining and hybrid execution strategies are supported.</dd>
-</dl></p>
+    of <code>rdfs:subPropertyOf</code> and <code>rdfs:subClassOf</code>.</li></p>
+<p><li>RDFS rule reasoner: Implements a configurable subset of the RDFS entailments.</li></p>
+<p><li>OWL, OWL Mini, OWL Micro Reasoners: 
+  A set of useful but incomplete implementation of the OWL/Lite subset of the OWL/Full
+    language. </li></p>
+<p><li>Generic rule reasoner: A rule based reasoner that supports user defined rules. Forward chaining,
+    tabled backward chaining and hybrid execution strategies are supported.</li>
+</ol></p>
 <p>[<a href="#index">index</a>]</p>
 
-<h2 id="wzxhzdk145wzxhzdk146the-inference-api"><a name="api"></a>The Inference API</h2>
+<h2 id="wzxhzdk129wzxhzdk130the-inference-api"><a name="api"></a>The Inference API</h2>
 <p><ol>
   <li><a href="#reasonerAPI">Generic reasoner API</a></li>
   <li><a href="#generalExamples">Small examples</a></li>
@@ -260,7 +254,7 @@
     - <a href="#tracing">Tracing</a> <br>
   </li>
 </ol></p>
-<h3 id="wzxhzdk183wzxhzdk184generic-reasoner-api"><a name="reasonerAPI"></a>Generic reasoner API</h3>
+<h3 id="wzxhzdk167wzxhzdk168generic-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="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/ReasonerFactory.html">ReasonerFactory</a></code>)
@@ -328,7 +322,7 @@
   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="wzxhzdk279wzxhzdk280some-small-examples"><a name="generalExamples"></a>Some small examples</h3>
+<h3 id="wzxhzdk263wzxhzdk264some-small-examples"><a name="generalExamples"></a>Some small examples</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
@@ -420,13 +414,13 @@
 
 <p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p>
 
-<h3 id="wzxhzdk319wzxhzdk320operations-on-inference-models"><a name="operationsOnInferenceModels"></a>Operations on inference models</h3>
+<h3 id="wzxhzdk303wzxhzdk304operations-on-inference-models"><a name="operationsOnInferenceModels"></a>Operations on inference models</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="wzxhzdk327wzxhzdk328validation"><a name="validation"></a>Validation</h4>
+<h4 id="wzxhzdk311wzxhzdk312validation"><a name="validation"></a>Validation</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
@@ -491,7 +485,7 @@
   an additional method <code>Report.isClean()</code> which returns true if the
   ontology is both valid (logically consistent) and generated no warnings (such
   as inconsistent classes).</p></p>
-<h4 id="wzxhzdk389wzxhzdk390extended-list-statements"><a name="extendedListStatements"></a>Extended list statements</h4>
+<h4 id="wzxhzdk373wzxhzdk374extended-list-statements"><a name="extendedListStatements"></a>Extended list statements</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
@@ -510,7 +504,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="wzxhzdk401wzxhzdk402direct-and-indirect-relationships"><a name="directRelations"></a>Direct and indirect relationships</h4>
+<h4 id="wzxhzdk385wzxhzdk386direct-and-indirect-relationships"><a name="directRelations"></a>Direct and indirect relationships</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
@@ -531,7 +525,7 @@
 <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>
+<h4 id="wzxhzdk412wzxhzdk413derivations"><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="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/Derivation.html"><code>Derviation</code></a>
@@ -577,7 +571,7 @@ Rule rule1 concluded (eg:A eg:p eg:D) &l
     Rule rule1 concluded (eg:B eg:p eg:D) &lt;-
         Fact (eg:B eg:p eg:C)
         Fact (eg:C eg:p eg:D)</i></pre></p>
-<h4 id="wzxhzdk471wzxhzdk472accessing-raw-data-and-deductions"><a name="rawAccess"></a>Accessing raw data and deductions</h4>
+<h4 id="wzxhzdk455wzxhzdk456accessing-raw-data-and-deductions"><a name="rawAccess"></a>Accessing raw data and deductions</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>
@@ -586,7 +580,7 @@ Rule rule1 concluded (eg:A eg:p eg:D) &l
 <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="wzxhzdk485wzxhzdk486processing-control"><a name="processingControl"></a>Processing control</h4>
+<h4 id="wzxhzdk469wzxhzdk470processing-control"><a name="processingControl"></a>Processing control</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
@@ -613,7 +607,7 @@ Rule rule1 concluded (eg:A eg:p eg:D) &l
   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="wzxhzdk515wzxhzdk516tracing"><a name="tracing"></a>Tracing</h4>
+<h4 id="wzxhzdk499wzxhzdk500tracing"><a name="tracing"></a>Tracing</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
@@ -627,14 +621,14 @@ Rule rule1 concluded (eg:A eg:p eg:D) &l
   its underlying InfGraph and calling <code>setTraceOn()</code> call. If you need
   to make use of this see the full javadoc for the relevant InfGraph implementation.</p>
 <p>[<a href="#api">API index</a>] [<a href="#index">main index</a>]</p></p>
-<h2 id="wzxhzdk535wzxhzdk536the-rdfs-reasoner"><a name="rdfs"></a>The RDFS reasoner</h2>
+<h2 id="wzxhzdk519wzxhzdk520the-rdfs-reasoner"><a name="rdfs"></a>The RDFS reasoner</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="wzxhzdk555wzxhzdk556rdfs-reasoner-intro-and-coverage"><a name="RDFSintro"></a>RDFS reasoner - intro and coverage</h3>
+<h3 id="wzxhzdk539wzxhzdk540rdfs-reasoner-intro-and-coverage"><a name="RDFSintro"></a>RDFS reasoner - intro and coverage</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>
@@ -660,7 +654,7 @@ Rule rule1 concluded (eg:A eg:p eg:D) &l
   additional bNode triples, even in <i>virtual</i> triple form, is negligible
   and so this has been deliberately omitted from the reasoner. </p>
 <p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk591wzxhzdk592rdfs-configuration"><a name="RDFSconfiguration"></a>RDFS configuration</h3>
+<h3 id="wzxhzdk575wzxhzdk576rdfs-configuration"><a name="RDFSconfiguration"></a>RDFS configuration</h3>
 <p><p>The RDFSRuleReasoner can be configured to work at three different compliance
   levels: </p>
 <dl>
@@ -748,7 +742,7 @@ Rule rule1 concluded (eg:A eg:p eg:D) &l
   </tr>
 </table>
 <p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk708wzxhzdk709rdfs-example"><a name="RDFSexamples"></a>RDFS Example</h3>
+<h3 id="wzxhzdk692wzxhzdk693rdfs-example"><a name="RDFSexamples"></a>RDFS Example</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>
@@ -823,7 +817,7 @@ that is not compatible with 13</i></pre>
 <p>because the age was given using an RDF plain litera where as the schema requires
   it to be a datatyped literal which is compatible with xsd:integer.</p>
 <p>[<a href="#rdfs">RDFS index</a>] [<a href="#index">main index</a>]</p></p>
-<h3 id="wzxhzdk875wzxhzdk876rdfs-implementation-and-performance-notes"><a name="RDFSnotes"></a>RDFS implementation and performance notes</h3>
+<h3 id="wzxhzdk859wzxhzdk860rdfs-implementation-and-performance-notes"><a name="RDFSnotes"></a>RDFS implementation and performance notes</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
@@ -881,7 +875,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="wzxhzdk963wzxhzdk964the-owl-reasoner"><a name="owl"></a>The OWL reasoner</h2>
+<h2 id="wzxhzdk947wzxhzdk948the-owl-reasoner"><a name="owl"></a>The OWL reasoner</h2>
 <p><ol>
   <li><a href="#OWLintro">OWL reasoner introduction</a></li>
   <li><a href="#OWLcoverage">OWL coverage</a></li>
@@ -898,7 +892,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="wzxhzdk997wzxhzdk998owl-coverage"><a name="OWLcoverage"></a>OWL coverage</h3>
+<h3 id="wzxhzdk981wzxhzdk982owl-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
@@ -1117,7 +1111,7 @@ 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="wzxhzdk1247wzxhzdk1248owl-configuration"><a name="OWLconfiguration"></a>OWL Configuration</h3>
+<h3 id="wzxhzdk1231wzxhzdk1232owl-configuration"><a name="OWLconfiguration"></a>OWL Configuration</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>
   <code>OWL_MEM_RULE_INF</code> or manually via <code>ReasonerRegistery.getOWLReasoner()</code>.</p>
@@ -1154,7 +1148,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="wzxhzdk1313wzxhzdk1314owl-example"><a name="OWLexamples"></a>OWL Example</h3>
+<h3 id="wzxhzdk1297wzxhzdk1298owl-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>
@@ -1243,7 +1237,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="wzxhzdk1422wzxhzdk1423owl-notes-and-limitations"><a name="OWLnotes"></a>OWL notes and limitations</h3>
+<h3 id="wzxhzdk1406wzxhzdk1407owl-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
@@ -1314,16 +1308,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="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="/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="wzxhzdk1481wzxhzdk1482the-transitive-reasoner"><a name="transitive"></a>The transitive reasoner</h2>
+<h2 id="wzxhzdk1445wzxhzdk1446the-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>.
@@ -1339,7 +1324,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="wzxhzdk1503wzxhzdk1504the-general-purpose-rule-engine"><a name="rules"></a>The general purpose rule engine</h2>
+<h2 id="wzxhzdk1467wzxhzdk1468the-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>
@@ -1353,7 +1338,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="wzxhzdk1551wzxhzdk1552overview-of-the-rule-engines"><a name="RULEoverview"></a>Overview of the rule engine(s)</h3>
+<h3 id="wzxhzdk1515wzxhzdk1516overview-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
@@ -1372,7 +1357,7 @@ 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="wzxhzdk1573wzxhzdk1574rule-syntax-and-structure"><a name="RULEsyntax"></a>Rule syntax and structure</h3>
+<h3 id="wzxhzdk1537wzxhzdk1538rule-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="/documentation/javadoc/jena/com/hp/hpl/jena/reasoner/rulesys/ClauseEntry.html"><code>ClauseEntry</code></a>
@@ -1414,7 +1399,7 @@ class B = cardinality(P,1)</pre>
   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>
-  object. This initially knows about rdf, rdfs, owl, daml, xsd and a test namespace
+  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>
 <p>Here are some example rules which illustrate most of these constructs:</p>

Modified: websites/staging/jena/trunk/content/documentation/io/features.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/io/features.html (original)
+++ websites/staging/jena/trunk/content/documentation/io/features.html Tue Dec 18 10:54:57 2012
@@ -164,9 +164,6 @@
     <a href="http://www.w3.org/TR/rdf-testcases">RDF Test Cases</a>
     Recommendations.</li>
 <li>Compliant with following standards and recommendations:<ul>
-<li><strong>daml:collection</strong><br />
-  <a href="http://www.daml.org/2001/03/reference.html#collection">rdf:parseType='daml:collection'</a>
-    is supported.</li>
 <li><strong>xml:lang</strong><br />
   <a href="http://www.w3.org/TR/REC-xml#sec-lang-tag">xml:lang</a> is fully
     supported, both in RDF/XML and any document embedding RDF/XML.

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 Tue Dec 18 10:54:57 2012
@@ -554,25 +554,23 @@ of "rdf:about", then the following code 
 
 
 <p>As a second example, suppose you wish to work in strict mode, but
-allow <code>"daml:collection"</code>, the following works:</p>
+ingore some specific warning or error, the following works:</p>
 <div class="codehilite"><pre> <span class="err">…</span>
  <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;error-mode&quot;</span><span class="p">,</span> <span class="s">&quot;strict&quot;</span> <span class="p">);</span>
- <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;IGN_DAML_COLLECTION&quot;</span><span class="p">,</span><span class="s">&quot;EM_IGNORE&quot;</span><span class="p">);</span>
+ <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;WARN_UNQUALIFIED_ATTRIBUTE&quot;</span><span class="p">,</span> <span class="s">&quot;EM_IGNORE&quot;</span><span class="p">);</span>
  <span class="err">…</span>
 </pre></div>
 
 
 <p>The other way round does not work.</p>
 <div class="codehilite"><pre> <span class="err">…</span>
- <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;IGN_DAML_COLLECTION&quot;</span><span class="p">,</span><span class="s">&quot;EM_IGNORE&quot;</span><span class="p">);</span>
+ <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;WARN_UNQUALIFIED_ATTRIBUTE&quot;</span><span class="p">,</span> <span class="s">&quot;EM_IGNORE&quot;</span><span class="p">);</span>
  <span class="n">arp</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;error-mode&quot;</span><span class="p">,</span> <span class="s">&quot;strict&quot;</span> <span class="p">);</span>
  <span class="err">…</span>
 </pre></div>
 
 
-<p>This is because in strict mode
-<a href="/documentation/javadoc/jena/com/hp/hpl/jena/rdf/arp/ARPErrorNumbers.html#IGN_DAML_COLLECTION"><code>IGN_DAML_COLLECTION</code></a>
-is treated as an error, and so the second call to <code>setProperty</code>
+<p>This is because in strict mode it is treated as an error, and so the second call to <code>setProperty</code>
 overwrites the effect of the first.</p>
 <p>The IRI rules and resolver can be set on a per-reader basis:</p>
 <div class="codehilite"><pre><span class="n">InputStream</span> <span class="n">in</span> <span class="o">=</span> <span class="o">...</span> <span class="p">;</span>
@@ -746,19 +744,7 @@ indicating grammar rules that will not b
 <li><a href="http://www.w3.org/TR/rdf-syntax-grammar#propertyAttr">propertyAttr</a>
  (<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/RDFSyntax.html#propertyAttr"><code>RDFSyntax.propertyAttr</code></a>)</li>
 </ul>
-<p>In addition <code>"daml:collection"</code>
-(<a href="/documentation/javadoc/jena/com/hp/hpl/jena/vocabulary/DAML_OIL.html#collection"><code>DAML_OIL.collection</code></a>)
-can be blocked. Blocking
-<a href="http://www.w3.org/TR/rdf-syntax-grammar#idAttr">idAttr</a> also
-blocks
-<a href="http://www.w3.org/TR/rdf-syntax-grammar#section-Reification">section-Reification</a>.
-By default, rule
-<a href="http://www.w3.org/TR/rdf-syntax-grammar#propertyAttr">propertyAttr</a>
-is blocked. For the basic writer (RDF/XML) only
-<a href="http://www.w3.org/TR/rdf-syntax-grammar#parseTypeLiteralPropertyElt">parseTypeLiteralPropertyElt</a>
-has any effect, since none of the other rules are implemented by
-that writer.
-</td>
+<p></td>
 <td><code>Resource[]</code> or <code>String</code></td>
 <td></td>
 </tr>
@@ -768,18 +754,21 @@ that writer.
 Only for the RDF/XML-ABBREV writer. This is a list of the types of
 the principal objects in the model. The writer will tend to create
 RDF/XML with resources of these types at the top level.</p>
-<p>Example usage showing the a value suitable for DAML+OIL output:</p>
+<p>Example usage showing the default settings:</p>
 <div class="codehilite"><pre><span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;prettyTypes&quot;</span><span class="p">,</span>
          <span class="k">new</span> <span class="n">Resource</span><span class="o">[]</span><span class="p">{</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">Ontology</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">Class</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">Datatype</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">Property</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">ObjectProperty</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">DatatypeProperty</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">TransitiveProperty</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">UnambigousProperty</span><span class="p">,</span>
-              <span class="n">DAML_OIL</span><span class="o">.</span><span class="n">UniqueProperty</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">Ontology</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">Datatype</span><span class="p">,</span>
+        <span class="n">RDFS</span><span class="o">.</span><span class="n">Datatype</span><span class="p">,</span>
+        <span class="n">RDFS</span><span class="o">.</span><span class="n">Class</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">Class</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">ObjectProperty</span><span class="p">,</span>
+        <span class="n">RDF</span><span class="o">.</span><span class="n">Property</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">DatatypeProperty</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">TransitiveProperty</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">SymmetricProperty</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">FunctionalProperty</span><span class="p">,</span>
+        <span class="n">OWL</span><span class="o">.</span><span class="n">InverseFunctionalProperty</span>
               <span class="p">});</span>
 </pre></div>
 
@@ -798,8 +787,7 @@ As an example,</p>
 <span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;showXMLDeclaration&quot;</span><span class="p">,</span><span class="s">&quot;true&quot;</span><span class="p">);</span>
 <span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;tab&quot;</span><span class="p">,</span><span class="s">&quot;1&quot;</span><span class="p">);</span>
 <span class="n">w</span><span class="o">.</span><span class="n">setProperty</span><span class="p">(</span><span class="s">&quot;blockRules&quot;</span><span class="p">,</span>
-  <span class="s">&quot;daml:collection,parseTypeLiteralPropertyElt,&quot;</span>
-  <span class="o">+</span><span class="s">&quot;parseTypeResourcePropertyElt,parseTypeCollectionPropertyElt&quot;</span><span class="p">);</span>
+  <span class="s">&quot;parseTypeResourcePropertyElt,parseTypeCollectionPropertyElt&quot;</span><span class="p">);</span>
 </pre></div>
 
 
@@ -899,15 +887,10 @@ may be interpreted as integer, boolean o
 <h2 id="conformance">Conformance</h2>
 <p>The RDF/XML I/O endeavours to conform with the
 <a href="http://www.w3.org/TR/rdf-syntax-grammar/">RDF Syntax Recommendation</a>.</p>
-<p>The parser must be set to strict mode. (Note that, the conformant
-behaviour for <code>rdf:parseType="daml:collection"</code> is to silently turn
-<code>"daml:collection"</code> into <code>"Literal"</code>).</p>
+<p>The parser must be set to strict mode.</p>
 <p>The RDF/XML writer is conformant, but does not exercise much of the
-grammar.</p>
-<p>The RDF/XML-ABBREV writer exercises all of the grammar and is
-conformant except that it uses the <code>daml:collection</code> construct for
-DAML ontologies. This non-conformant behaviour can be switched off
-using the <code>blockRules</code> property.</p>
+grammar.  The RDF/XML-ABBREV writer exercises all of the grammar and is
+conformant.</p>
 <h2 id="faster-rdfxml-io">Faster RDF/XML I/O</h2>
 <p>To optimise the speed of writing RDF/XML it is suggested that all
 URI processing is turned off. Also do not use RDF/XML-ABBREV. It is

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 Tue Dec 18 10:54:57 2012
@@ -264,7 +264,7 @@ with <a href="/documentation/sdb/index.h
 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).
+inference over RDF-based models (used for RDFS and OWL).
 Inference models are constructed by applying <em>reasoners</em> to
 <em>base models</em> and optionally <em>schema</em>. The statements deduced by
 the reasoner from the base model then appear in the inferred model
@@ -319,7 +319,7 @@ sub-property closure.</p>
 <h2 id="ontology-model-creation">Ontology model creation</h2>
 <p>An <em>ontology model</em> is one that presents RDF as an ontology -
 classes, individuals, different kinds of properties, and so forth.
-Jena supports RDFS, OWL, and DAML ontologies through <em>profiles</em>.
+Jena supports RDFS and OWL ontologies through <em>profiles</em>.
 There is extensive documentation on
 <a href="../ontology/index.html">Jena's ontology support</a>, so all we'll do
 here is summarise the creation methods.</p>

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 Tue Dec 18 10:54:57 2012
@@ -405,36 +405,9 @@ registers a new <code>RDFDatatype</code>
 serialize, test instances of that datatype.</p>
 <p>There is one difficult issue in here, what URI to give to the user
 defined datatype? This is not defined by XML Schema, nor RDF nor
-OWL. Jena2 adopts the position taken by DAML that the defined
+OWL. Jena2 adopts the position that the defined
 datatype should have the base URI of the schema file with a
 fragment identifier given by the datatype name.</p>
-<p>Thus the DAML example
-file<code>http://www.daml.org/2001/03/daml+oil-ex-dt</code> (a corrected copy
-of which is stored in <code>$JENA/testing/xsd/daml+oil-ex-dt.xsd</code>, where
-<code>$JENA</code> is your Jena install directory) defines several types such
-as "over12". The following code fragment will load this file and
-register the newly defined types:</p>
-<div class="codehilite"><pre><span class="n">String</span> <span class="n">uri</span> <span class="o">=</span> <span class="s">&quot;http://www.daml.org/2001/03/daml+oil-ex-DT&quot;</span><span class="p">;</span>
-<span class="n">String</span> <span class="n">filename</span> <span class="o">=</span> <span class="s">&quot;../jena2/testing/xsd/daml+oil-ex-dt.xsd&quot;</span><span class="p">;</span>
-<span class="n">TypeMapper</span> <span class="n">tm</span> <span class="o">=</span> <span class="n">TypeMapper</span><span class="o">.</span><span class="n">getInstance</span><span class="p">();</span>
-<span class="n">List</span> <span class="n">typenames</span> <span class="o">=</span> <span class="n">XSDDatatype</span><span class="o">.</span><span class="n">loadUserDefined</span><span class="p">(</span><span class="n">uri</span><span class="p">,</span> <span class="k">new</span> <span class="n">FileReader</span><span class="p">(</span><span class="n">filename</span><span class="p">),</span> <span class="n">null</span><span class="p">,</span> <span class="n">TM</span><span class="p">);</span>
-<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">&quot;Defined types are:&quot;</span><span class="p">);</span>
-<span class="k">for</span> <span class="p">(</span><span class="n">Iterator</span> <span class="n">i</span> <span class="o">=</span> <span class="n">typenames</span><span class="o">.</span><span class="n">iterator</span><span class="p">();</span> <span class="n">i</span><span class="o">.</span><span class="n">hasNext</span><span class="p">();</span> <span class="p">)</span> <span class="p">{</span>
-    <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">&quot; - &quot;</span> <span class="o">+</span> <span class="n">i</span><span class="o">.</span><span class="k">next</span><span class="p">());</span>
-<span class="p">}</span>
-</pre></div>
-
-
-<p>it produces the following output:</p>
-<div class="codehilite"><pre><span class="n">Defined</span> <span class="n">types</span> <span class="n">are:</span>
- <span class="o">-</span> <span class="n">http:</span><span class="sr">//</span><span class="n">www</span><span class="o">.</span><span class="n">daml</span><span class="o">.</span><span class="n">org</span><span class="sr">/2001/</span><span class="mo">03</span><span class="o">/</span><span class="n">daml</span><span class="o">+</span><span class="n">oil</span><span class="o">-</span><span class="n">ex</span><span class="o">-</span><span class="n">DT</span><span class="c1">#XSDEnumerationHeight</span>
- <span class="o">-</span> <span class="n">http:</span><span class="sr">//</span><span class="n">www</span><span class="o">.</span><span class="n">daml</span><span class="o">.</span><span class="n">org</span><span class="sr">/2001/</span><span class="mo">03</span><span class="o">/</span><span class="n">daml</span><span class="o">+</span><span class="n">oil</span><span class="o">-</span><span class="n">ex</span><span class="o">-</span><span class="n">DT</span><span class="c1">#over12</span>
- <span class="o">-</span> <span class="n">http:</span><span class="sr">//</span><span class="n">www</span><span class="o">.</span><span class="n">daml</span><span class="o">.</span><span class="n">org</span><span class="sr">/2001/</span><span class="mo">03</span><span class="o">/</span><span class="n">daml</span><span class="o">+</span><span class="n">oil</span><span class="o">-</span><span class="n">ex</span><span class="o">-</span><span class="n">DT</span><span class="c1">#over17</span>
- <span class="o">-</span> <span class="n">http:</span><span class="sr">//</span><span class="n">www</span><span class="o">.</span><span class="n">daml</span><span class="o">.</span><span class="n">org</span><span class="sr">/2001/</span><span class="mo">03</span><span class="o">/</span><span class="n">daml</span><span class="o">+</span><span class="n">oil</span><span class="o">-</span><span class="n">ex</span><span class="o">-</span><span class="n">DT</span><span class="c1">#over59</span>
- <span class="o">-</span> <span class="n">http:</span><span class="sr">//</span><span class="n">www</span><span class="o">.</span><span class="n">daml</span><span class="o">.</span><span class="n">org</span><span class="sr">/2001/</span><span class="mo">03</span><span class="o">/</span><span class="n">daml</span><span class="o">+</span><span class="n">oil</span><span class="o">-</span><span class="n">ex</span><span class="o">-</span><span class="n">DT</span><span class="c1">#clothingsize</span>
-</pre></div>
-
-
 <p>To illustrate working with the defined types, the following code
 then tries to create and use two instances of the over 12 type:</p>
 <div class="codehilite"><pre><span class="n">Model</span> <span class="n">m</span> <span class="o">=</span> <span class="n">ModelFactory</span><span class="o">.</span><span class="n">createDefaultModel</span><span class="p">();</span>

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 Tue Dec 18 10:54:57 2012
@@ -244,9 +244,8 @@ isn't &ndash; possible using Jena's onto
 support is limited to ontology formalisms built on top of RDF.
 Specifically this means <a href="http://en.wikipedia.org/wiki/RDFS">RDFS</a>,
 the varieties of
-<a href="http://en.wikipedia.org/wiki/Web_Ontology_Language">OWL</a>, and the
-now-obsolete <a href="http://en.wikipedia.org/wiki/DAML+OIL">DAML+OIL</a>. We
-will provide a very brief introduction to these languages here,
+<a href="http://en.wikipedia.org/wiki/Web_Ontology_Language">OWL</a>.
+We will provide a very brief introduction to these languages here,
 but please refer to the extensive on-line documentation for these
 formalisms for complete and authoritative details.</p>
 <h3 id="rdfs">RDFS</h3>
@@ -354,17 +353,6 @@ on an RDF foundation. This view uses RDF
 the RDF-centric view treats RDF triples as the core of the OWL
 formalism. While both views are valid, in Jena we take the
 RDF-centric view.</p>
-<h3 id="damloil">DAML+OIL</h3>
-<p>DAML+OIL is very similar to OWL Full. This is not surprising, since
-the W3C's Web Ontology Working Group, who designed OWL, took
-DAML+OIL as their starting point. Some constructions in OWL have
-been added to the capabilities of DAML+OIL, and one or two have
-been removed. For the purposes of this brief overview, however, the
-expressiveness of DAML+OIL is comparable to that of OWL.</p>
-<p><strong>Note:</strong> DAML+OIL is effectively now obsolete. While it is still
-possible to
-find some DAML ontologies on the web, our recommendation is that
-Jena developers stick to OWL and RDFS as ontology languages.</p>
 <h3 id="ontology-languages-and-the-jena-ontology-api">Ontology languages and the Jena Ontology API</h3>
 <p>As we outlined above, there are various different ontology languages
 available for representing ontology information on the semantic
@@ -375,14 +363,11 @@ development, independent of which ontolo
 in your programs.</p>
 <p>The Jena Ontology API is language-neutral: the Java class names are not
 specific to the underlying language. For example, the <code>OntClass</code>
-Java class can represent an OWL class, RDFS class, or DAML class.
+Java class can represent an OWL class or RDFS class.
 To represent the differences between the various representations,
 each of the ontology languages has a <em>profile</em>, which lists the
-permitted constructs and the names of the classes and properties.
-Thus in the DAML profile, the URI for object property is
-<code>daml:ObjectProperty</code> (short for
-<code>http://www.daml.org/2001/03/daml+oil#ObjectProperty</code>), in the OWL
-profile is it <code>owl:ObjectProperty</code> (short for
+permitted constructs and the names of the classes and properties.</p>
+<p>Thus in the OWL profile is it <code>owl:ObjectProperty</code> (short for
 <code>http://www.w3.org/2002/07/owl#ObjectProperty</code>) and in the RDFS
 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
@@ -586,10 +571,6 @@ various language profiles are:</p>
 <td><code>http://www.w3.org/2000/01/rdf-schema#</code></td>
 </tr>
 <tr>
-<td>DAML+OIL</td>
-<td><code>http://www.daml.org/2001/03/daml+oil#</code></td>
-</tr>
-<tr>
 <td>OWL Full</td>
 <td><code>http://www.w3.org/2002/07/owl#</code></td>
 </tr>
@@ -609,13 +590,6 @@ The profile registry contains public con
 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
 the OWL standard.</p>
-<p>To create an ontology model for handling DAML ontologies, use
-either of:</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> <span class="n">OntModelSpec</span><span class="o">.</span><span class="n">DAML_MEM</span> <span class="p">);</span>
-<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> <span class="n">ProfileRegistry</span><span class="o">.</span><span class="n">DAML_LANG</span> <span class="p">);</span>
-</pre></div>
-
-
 <p>Beyond these basic choices, the complexities of configuring an
 ontology model are wrapped up in a recipe object called
 <a href="/documentation/javadoc/jena/com/hp/hpl/jena/ontology/OntModelSpec.html"><code>OntModelSpec</code></a>.
@@ -713,30 +687,6 @@ number of common recipes are pre-declare
 <td>rule-based reasoner with OWL rules</td>
 </tr>
 <tr>
-<td>DAML_MEM</td>
-<td>DAML+OIL</td>
-<td>in-memory</td>
-<td>none</td>
-</tr>
-<tr>
-<td>DAML_MEM_TRANS_INF</td>
-<td>DAML+OIL</td>
-<td>in-memory</td>
-<td>transitive class-hierarchy inference</td>
-</tr>
-<tr>
-<td>DAML_MEM_RDFS_INF</td>
-<td>DAML+OIL</td>
-<td>in-memory</td>
-<td>rule reasoner with RDFS-level entailment-rules</td>
-</tr>
-<tr>
-<td>DAML_MEM_RULE_INF</td>
-<td>DAML+OIL</td>
-<td>in-memory</td>
-<td>rule-based reasoner with DAML rules</td>
-</tr>
-<tr>
 <td>RDFS_MEM</td>
 <td>RDFS</td>
 <td>in-memory</td>
@@ -763,9 +713,7 @@ for
 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
-seen by the ontology model. However, using an OWL reasoner with
-DAML source data will result in few additional entailments being
-seen by the ontology model.</p>
+seen by the ontology model. </p>
 <p>To create a model with a given specification, you should invoke the
 <code>ModelFactory</code> 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> <span class="o">&lt;</span><span class="n">model</span> <span class="n">spec</span><span class="o">&gt;</span> <span class="p">);</span>
@@ -789,7 +737,7 @@ and then update the copy as necessary:</
 
 
 <h2 id="compound-ontology-documents-and-imports-processing">Compound ontology documents and imports processing</h2>
-<p>The OWL and DAML ontology languages include some facilities for
+<p>The OWL ontology language includes some facilities for
 creating modular ontologies that can be re-used in a similar manner
 to software modules. In particular, one ontology can <em>import</em>
 another. Jena helps ontology developers to work with modular
@@ -831,7 +779,7 @@ a <code>java.io.Reader</code> argument w
 internationalised character sets, since the handling of character
 encoding by the Reader and by XML parsers is not compatible.</p>
 <p>By default, when an ontology model reads an ontology document, it
-will also locate and load the document's imports. An OWL or DAML
+will also locate and load the document's imports. An OWL
 document may contain an individual of class <code>Ontology</code>, which
 contains meta-data about that document itself. For example:</p>
 <div class="codehilite"><pre><span class="nt">&lt;owl:Ontology</span> <span class="na">rdf:about=</span><span class="s">&quot;&quot;</span><span class="nt">&gt;</span>
@@ -1277,7 +1225,7 @@ resource if possible, or create a new cl
 
 <p>You can use the create class method to create an anonymous class &ndash;
 a class description with no associated URI. Anonymous classes are
-often used when building more complex ontologies in OWL or DAML.
+often used when building more complex ontologies in OWL.
 They are less useful in RDFS.</p>
 <div class="codehilite"><pre><span class="n">OntClass</span> <span class="n">anonClass</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">createClass</span><span class="p">();</span>
 </pre></div>
@@ -1564,7 +1512,7 @@ cardinality | The property has exactly <
 min cardinality | The property has at least <em>n</em> values, for some positive integer n.
 max cardinality | The property has at most <em>n</em> values, for some positive integer n.</p>
 <p>Note that, at present, the Jena
-ontology API has only limited support for OWL2 and DAML's qualified
+ontology API has only limited support for OWL2's qualified
 cardinality restrictions (i.e. <code>cardinalityQ</code>, <code>minCardinalityQ</code>
 and <code>maxCardinalityQ</code>). Qualified cardinality restrictions are
 encapsulated in the interfaces <code>CardinalityQRestriction</code>,
@@ -1708,9 +1656,8 @@ Boolean class expressions, let's briefly
 <h3 id="list-expressions">List expressions</h3>
 <p>RDF originally had three container types: <code>Seq</code>, <code>Alt</code> and <code>Bag</code>.
 While useful, these are all open forms: it is not possible to say
-that a given container has a fixed number of values. The DAML+OIL
-standard introduced a fourth container type - lists - in order to
-have a closed collection. Lists have subsequently been added to the
+that a given container has a fixed number of values. 
+Lists have subsequently been added to the
 core RDF specification, and are used extensively in OWL. A list
 follows the well-known <em>cons cell</em> pattern from Lisp, Prolog and
 other list-handling languages. Each cell of a list is either the

Modified: websites/staging/jena/trunk/content/documentation/tools/eyeball-guide.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/tools/eyeball-guide.html (original)
+++ websites/staging/jena/trunk/content/documentation/tools/eyeball-guide.html Tue Dec 18 10:54:57 2012
@@ -326,7 +326,7 @@ problems. The first:</p>
 <p>This arises when a "standard" prefix has been bound to a namespace
 URI which isn't its usual one. The "standard" prefixes are taken
 from Jena's <code>PrefixMapping.Extended</code> and are currently:</p>
-<div class="codehilite"><pre><span class="o">**</span><span class="n">rdf</span><span class="p">,</span> <span class="n">rdfs</span><span class="p">,</span> <span class="n">daml</span><span class="p">,</span> <span class="n">owl</span><span class="p">,</span> <span class="n">xsd</span><span class="p">,</span> <span class="n">rss</span><span class="p">,</span> <span class="n">vcard</span><span class="o">**</span>
+<div class="codehilite"><pre><span class="o">**</span><span class="n">rdf</span><span class="p">,</span> <span class="n">rdfs</span><span class="p">,</span> <span class="n">owl</span><span class="p">,</span> <span class="n">xsd</span><span class="p">,</span> <span class="n">rss</span><span class="p">,</span> <span class="n">vcard</span><span class="o">**</span>
 </pre></div>
 
 

Modified: websites/staging/jena/trunk/content/documentation/tools/schemagen.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/tools/schemagen.html (original)
+++ websites/staging/jena/trunk/content/documentation/tools/schemagen.html Tue Dec 18 10:54:57 2012
@@ -157,8 +157,7 @@
 
   <div id="content">
     <h1 class="title">Jena schemagen HOWTO</h1>
-    <p>The <code>schemagen</code> provided with Jena is used to convert an OWL, DAML
-or RDFS vocabulary into a Java class file that contains static
+    <p>The <code>schemagen</code> provided with Jena is used to convert an OWL or RDFS vocabulary into a Java class file that contains static
 constants for the terms in the vocabulary. This documents outlines
 the use of schemagen, and the various options and templates that
 may be used to control the output.</p>
@@ -218,11 +217,6 @@ options is explained in detail below.</p
 <td>Template for writing out declarations of class resources.</td>
 </tr>
 <tr>
-<td><code>--daml</code></td>
-<td><code>sgen:daml</code></td>
-<td>Specify that the language of the source ontology is DAML+OIL.</td>
-</tr>
-<tr>
 <td><code>--declarations &lt;string\&gt;</code></td>
 <td><code>sgen:declarations</code></td>
 <td>Additional declarations to add at the top of the class.</td>
@@ -370,7 +364,7 @@ options is explained in detail below.</p
 </tbody>
 </table>
 <h2 id="what-does-schemagen-do">What does schemagen do?</h2>
-<p>RDFS, OWL and DAML+OIL provide a very convenient means to define a
+<p>RDFS and OWL provide a very convenient means to define a
 controlled vocabulary or ontology. For general ontology processing,
 Jena provides various API's to allow the source files to be read in
 and manipulated. However, when developing an application, it is
@@ -500,8 +494,8 @@ public class Deputy <span class="err">{<
 
 
 <h2 id="general-principles">General principles</h2>
-<p>In essence, schemagen will load a single vocabulary file (imports
-processing is switched off in DAML and OWL), and generate a Java
+<p>In essence, schemagen will load a single vocabulary file,
+and generate a Java
 class that contains static constants for the named classes,
 properties and instances of the vocabulary. Most of the generated
 components of the output Java file can be controlled by option
@@ -870,8 +864,8 @@ defined by that ontology. They may appea
 definitions of other terms. Schemagen assumes that there is one
 primary namespace for each document, and it is names from that
 namespace that will appear in the generated Java file.</p>
-<p>In an OWL or DAML+OIL ontology, this namespace is computed by
-finding the owl:Ontology or daml:Ontology element, and using its
+<p>In an OWL ontology, this namespace is computed by
+finding the owl:Ontology element, and using its
 namespace as the primary namespace of the ontology. This may not be
 available (it is not, for example, a part of RDFS) or correct, so
 the namespace may be specified directly with the <code>-a</code> option or in
@@ -974,12 +968,12 @@ the encoding configuration option.</p>
 </table>
 <p>By default, the Java class generated by schemagen will generate
 constants that are plain RDF Resource, Property or Literal
-constants. When working with OWL, DAML, or RDFS ontologies, it may
+constants. When working with OWL or RDFS ontologies, it may
 be more convenient to have constants that are OntClass,
 ObjectProperty, DatatypeProperty and Individual Java objects. To
 generate these ontology constants, rather than plain RDF constants,
 set the ontology configuration option.</p>
-<p>Furthermore, since Jena can handle input ontologies in DAML+OIL,
+<p>Furthermore, since Jena can handle input ontologies in
 OWL (the default), and RDFS, it is necessary to be able to specify
 which language is being processed. This will affect both the
 parsing of the input documents, and the language profile selected
@@ -994,24 +988,6 @@ for the constants in the generated Java 
 <tbody>
 <tr>
 <td><strong>Command line</strong></td>
-<td><code>--daml</code></td>
-</tr>
-<tr>
-<td><strong>Config file</strong></td>
-<td><code>&lt;sgen:daml rdf:datatype="&amp;xsd;boolean"\&gt;true&lt;/sgen:daml\&gt;</code></td>
-</tr>
-</tbody>
-</table>
-<table>
-<thead>
-<tr>
-<th></th>
-<th></th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><strong>Command line</strong></td>
 <td><code>--owl</code></td>
 </tr>
 <tr>
@@ -1047,10 +1023,7 @@ the generated Java class, even if that f
 asserted in the input model. From Jena 2.2 onwards, this option is
 now <strong>off by default</strong>. If correct handling of an input document by
 schemagen requires the use of inference rules, this must be
-specified by the <code>inference</code> option. In particular, some DAML+OIL
-input files may require the use of this option, to ensure that
-synonyms such as <code>daml:Class</code> and <code>rdfs:Class</code> are recognised
-correctly.</p>
+specified by the <code>inference</code> option. </p>
 <table>
 <thead>
 <tr>

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 Tue Dec 18 10:54:57 2012
@@ -284,7 +284,7 @@ types of Model are also available from M
 The property is provided by a "constant" class VCARD which holds objects
 representing all the definitions in the VCARD schema.  Jena provides constant
 classes for other well known schemas, such as RDF and RDF schema themselves,
-Dublin Core and DAML.</p>
+Dublin Core and OWL.</p>
 
 <p>The code to create the resource and add the property, can be more
 compactly written in a cascading style:</p>



Mime
View raw message