Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.hp.hpl.jena.rdf.model
Interface Model

All Superinterfaces:
  Lock, ModelCon, ModelGraphInterface, ModelLock, PrefixMapping, RDFReaderF, RDFWriterF

All Known Subinterfaces:
  InfModel, OntModel

All Known Implementing Classes:
  com.hp.hpl.jena.rdf.model.impl.ModelCom, ModelRDB, MonitorModel

    public interface Model

extends ModelCon, ModelGraphInterface, RDFReaderF, RDFWriterF, PrefixMapping, ModelLock

An RDF Model.

An RDF model is a set of Statements. Methods are provided for creating resources, properties and literals and the Statements which link them, for adding statements to and removing them from a model, for querying a model and set operations for combining models.

Models may create Resources [URI nodes and bnodes]. Creating a Resource does not make the Resource visible to the model; Resources are only "in" Models if Statements about them are added to the Model. Similarly the only way to "remove" a Resource from a Model is to remove all the Statements that mention it.

When a Resource or Literal is created by a Model, the Model is free to re-use an existing Resource or Literal object with the correct values, or it may create a fresh one. [All Jena RDFNodes and Statements are immutable, so this is generally safe.]

This interface defines a set of primitive methods. A set of convenience methods which extends this interface, e.g. performing automatic type conversions and support for enhanced resources, is defined in `ModelCon`.

## System Properties

### Firewalls and Proxies

Some of the methods, e.g. the read methods, may have to traverse a firewall. This can be accomplished using the standard java method of setting system properties. To use a socks proxy, include on the java command line:

> -DsocksProxyHost=[your-proxy-domain-name-or-ip-address]

To use an http proxy, include on the command line:

> -DproxySet=true -DproxyHost=[your-proxy] -DproxyPort=[your-proxy-port-number]

Alternatively, these properties can be set programatically, e.g.

`

       System.getProperties().put("proxySet","true");
       System.getProperties().put("proxyHost","proxy.hostname");
       System.getProperties().put("proxyPort",port_number);

`

Version:
  $Name: $ $Revision: 1.72 $Date: 2008/03/14 16:07:38 $'
Author:
  bwm

Nested Class Summary

Nested classes/interfaces inherited from interface com.hp.hpl.jena.shared.PrefixMapping
`PrefixMapping.Factory, PrefixMapping.IllegalPrefixException, PrefixMapping.JenaLockedException`

Field Summary

Fields inherited from interface com.hp.hpl.jena.shared.PrefixMapping
`Extended, Standard`

Fields inherited from interface com.hp.hpl.jena.rdf.model.ModelLock
`READ, WRITE`

Method Summary
`Model` | `abort()` Abort the current transaction and abandon any changes in progress.
`Model` | `add(java.util.List statements)` add all the statements in the List to this Model, going through the bulk update interface (which means turning them into triples in one form or another).
`Model` | `add(Model m)` Add all the statements in another model to this model, including the reified statements.
`Model` | `add(Model m, boolean suppressReifications)` Add all the statements of the given model m to this model.
`Model` | `add(Statement s)` Add a statement to this model.
`Model` | `add(Statement[] statements)` Add all the statements to the Model, using through the bulk update interface.
`Model` | `add(StmtIterator iter)` Add all the statements returned by an iterator to this model.
`Model` | `begin()` Begin a new transation.
`void` | `close()` Close the Model and free up resources held.
`Model` | `commit()` Commit the current transaction.
`boolean` | `contains(Resource s, Property p)` Determine whether this model contains any statements with a given subject and property.
`boolean` | `contains(Resource s, Property p, RDFNode o)` Determine if an (S, P, O) pattern is present in this model, with null allowed to represent a wildcard match.
`boolean` | `contains(Statement s)` Determine if a statement is present in this model.
`boolean` | `containsAll(Model model)` Determine if all of the statements in a model are also contained in this model.
`boolean` | `containsAll(StmtIterator iter)` Determine if all of the statements returned by an iterator are contained in this model.
`boolean` | `containsAny(Model model)` Determine if any of the statements in a model are also contained in this model.
`boolean` | `containsAny(StmtIterator iter)` Determine if any of the statements returned by an iterator are contained in this model.
`boolean` | `containsResource(RDFNode r)` determine if the RDFNode r appears in any statement of this model.
`RDFList` | `createList()` Answer a new empty list.
`RDFList` | `createList(java.util.Iterator members)` Answer a new list containing the resources from the given iterator, in order.
`RDFList` | `createList(RDFNode[] members)` Answer a new list containing the nodes from the given array, in order
`Literal` | `createLiteral(java.lang.String v, boolean wellFormed)` Create a literal from a String value.
`Literal` | `createLiteral(java.lang.String v, java.lang.String language)` Create an untyped literal from a String value with a specified language.
`Property` | `createProperty(java.lang.String nameSpace, java.lang.String localName)` Create a property with a given URI composed from a namespace part and a localname part by concatenating the strings.
`ReifiedStatement` | `createReifiedStatement(Statement s)` Answer a ReifiedStatement that encodes _s_ and belongs to this Model.
`ReifiedStatement` | `createReifiedStatement(java.lang.String uri, Statement s)` answer a ReifiedStatement that encodes _s_, belongs to this Model, and is a Resource with that _uri_.
`Resource` | `createResource()` Create a new anonymous resource whose model is this model.
`Resource` | `createResource(AnonId id)` Create a blank node resource with a specified identifier.
`Resource` | `createResource(java.lang.String uri)` Create a new resource associated with this model.
`Statement` | `createStatement(Resource s, Property p, RDFNode o)` Create a Statement instance.
`Literal` | `createTypedLiteral(java.lang.Object value)` Build a typed literal label from its value form using whatever datatype is currently registered as the the default representation for this java class.
`Literal` | `createTypedLiteral(java.lang.Object value, RDFDatatype dtype)` Build a typed literal from its value form.
`Literal` | `createTypedLiteral(java.lang.String lex, RDFDatatype dtype)` Build a typed literal from its lexical form.
`Model` | `difference(Model model)` Create a new, independant, model containing all the statements in this model which are not in another.
`boolean` | `equals(java.lang.Object m)` Test whether the given object `m` is a model that is equal to this model, which is true iff the underlying graphs are identical Java objects.
`java.lang.Object` | `executeInTransaction(Command cmd)` Execute the command `cmd` inside a transaction.
`Resource` | `getAnyReifiedStatement(Statement s)` Find or create a `ReifiedStatement` corresponding to a Statement.
`Lock` | `getLock()` Get the model lock for this model.
`Statement` | `getProperty(Resource s, Property p)` Answer a statement (s, p, ?
`Property` | `getProperty(java.lang.String nameSpace, java.lang.String localName)` Return a Property instance with the given URI in this model.
`ReificationStyle` | `getReificationStyle()` Answer the reification style of the model.
`Statement` | `getRequiredProperty(Resource s, Property p)` Return a statement with given subject and property.
`Resource` | `getResource(java.lang.String uri)` Return a Resource instance with the given URI in this model.
`boolean` | `independent()` Determine whether this model is independent.
`Model` | `intersection(Model model)` Create a new, independant, model containing all the statements which are in both this model and another.
`boolean` | `isClosed()` Answer true iff .close() has been called on this Model.
`boolean` | `isEmpty()` Answer true iff the model contains no explicit statements (ie it's size is zero, listStatements() would deliver the empty iterator).
`boolean` | `isIsomorphicWith(Model g)` Compare this Model with another for equality ignoring the labels on bNodes.
`boolean` | `isReified(Statement s)` Determine if this Statement has been reified in this Model.
`NsIterator` | `listNameSpaces()` (You probably don't want this method; more likely you want the PrefixMapping methods that Model supports.)
`NodeIterator` | `listObjects()` List all objects in a model.
`NodeIterator` | `listObjectsOfProperty(Property p)` List all objects of a given property. .remove() is not implemented on this iterator.
`NodeIterator` | `listObjectsOfProperty(Resource s, Property p)` List the values of a property of a resource.
`RSIterator` | `listReifiedStatements()` answer an iterator delivering all the reified statements "in" this model
`RSIterator` | `listReifiedStatements(Statement st)` answer an iterator delivering all the reified statements "in" this model that match the statement _st_.
`ResIterator` | `listResourcesWithProperty(Property p)` Answer an iterator [with no duplicates] over all the resources in this model that have property `p`.
`ResIterator` | `listResourcesWithProperty(Property p, RDFNode o)` Answer an iterator [with no duplicates] over all the resources in this model that have property `p` with value `o`.
`StmtIterator` | `listStatements()` List all statements.
`StmtIterator` | `listStatements(Resource s, Property p, RDFNode o)` Find all the statements matching a pattern.
`StmtIterator` | `listStatements(Selector s)` List the statements matching a selector.
`ResIterator` | `listSubjects()` List all resources which are subjects of statements.
`ResIterator` | `listSubjectsWithProperty(Property p)` An alias for `istResourcesWithProperty(Property)`, retained for backward compatability.
`ResIterator` | `listSubjectsWithProperty(Property p, RDFNode o)` An alias for `listResourcesWithProperty`, retained for backward compatability.
`Model` | `notifyEvent(java.lang.Object e)` Notify any listeners that the event e has occurred.
`Model` | `query(Selector s)` Create a new model containing the statements matching a query.
`Model` | `read(java.io.InputStream in, java.lang.String base)` Add statements from an RDF/XML serialization.
`Model` | `read(java.io.InputStream in, java.lang.String base, java.lang.String lang)` Add RDF statements represented in language `lang` to the model.
`Model` | `read(java.io.Reader reader, java.lang.String base)` Using this method is often a mistake.
`Model` | `read(java.io.Reader reader, java.lang.String base, java.lang.String lang)` Using this method is often a mistake.
`Model` | `read(java.lang.String url)` Add the RDF statements from an XML document.
`Model` | `read(java.lang.String url, java.lang.String lang)` Add statements from a serializion in language `lang` to the model.
`Model` | `read(java.lang.String url, java.lang.String base, java.lang.String lang)` Read into this model the RDF at `url`, using `baseURI` as the base URI if it is non-null.
`Model` | `register(ModelChangedListener listener)` Register a listener for model-changed events on this model.
`Model` | `remove(java.util.List statements)` Remove all the statements in the list from this model, using the bulk update interface.
`Model` | `remove(Statement s)` Removes a statement.
`Model` | `remove(Statement[] statements)` Remove all the statements from the Model, using the bulk update interface.
`Model` | `removeAll()` Remove all the statements from this model.
`Model` | `removeAll(Resource s, Property p, RDFNode r)` Remove all the statements matching (s, p, o) from this model.
`void` | `removeAllReifications(Statement s)` Remove all reifications (ie implicit reification quads) of _s_.
`void` | `removeReification(ReifiedStatement rs)` Remove a particular reificiation.
`long` | `size()` size will return the number of statements in a concrete model, for a virtualized model such as one created by an inference engine, it will return an estimated lower bound for the numberof statements in the model but it is possible for a subsequent listStatements on such a model to discover more statements than size() indicated.
`boolean` | `supportsSetOperations()` Determine whether this model supports set operations.
`boolean` | `supportsTransactions()` Determine whether this model supports transactions.
`Model` | `union(Model model)` Create a new, independant, model containing all the statements in this model together with all of those in another given model.
`Model` | `unregister(ModelChangedListener listener)` Unregister a listener from model-changed events on this model.
`Model` | `write(java.io.OutputStream out)` Write a serialization of this model as an XML document.
`Model` | `write(java.io.OutputStream out, java.lang.String lang)` Write a serialized represention of this model in a specified language.
`Model` | `write(java.io.OutputStream out, java.lang.String lang, java.lang.String base)` Write a serialized represention of a model in a specified language.
`Model` | `write(java.io.Writer writer)` Write the model as an XML document.
`Model` | `write(java.io.Writer writer, java.lang.String lang)` Write a serialized represention of a model in a specified language.
`Model` | `write(java.io.Writer writer, java.lang.String lang, java.lang.String base)` Write a serialized represention of a model in a specified language.

Methods inherited from interface com.hp.hpl.jena.rdf.model.ModelCon
`add, add, add, add, add, add, addLiteral, addLiteral, addLiteral, addLiteral, addLiteral, addLiteral, addLiteral, contains, contains, containsLiteral, containsLiteral, containsLiteral, containsLiteral, containsLiteral, containsLiteral, containsLiteral, createAlt, createAlt, createBag, createBag, createLiteral, createLiteralStatement, createLiteralStatement, createLiteralStatement, createLiteralStatement, createLiteralStatement, createLiteralStatement, createLiteralStatement, createProperty, createResource, createResource, createResource, createResource, createSeq, createSeq, createStatement, createStatement, createStatement, createStatement, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, createTypedLiteral, getAlt, getAlt, getBag, getBag, getProperty, getRDFNode, getResource, getSeq, getSeq, listLiteralStatements, listLiteralStatements, listLiteralStatements, listLiteralStatements, listlLiteralStatements, listResourcesWithProperty, listResourcesWithProperty, listResourcesWithProperty, listResourcesWithProperty, listResourcesWithProperty, listResourcesWithProperty, listStatements, listStatements, listSubjectsWithProperty, listSubjectsWithProperty, remove, remove, remove, remove`

Methods inherited from interface com.hp.hpl.jena.rdf.model.ModelGraphInterface
`asRDFNode, asStatement, getGraph, queryHandler`

Methods inherited from interface com.hp.hpl.jena.rdf.model.RDFReaderF
`getReader, getReader, setReaderClassName`

Methods inherited from interface com.hp.hpl.jena.rdf.model.RDFWriterF
`getWriter, getWriter, setWriterClassName`

Methods inherited from interface com.hp.hpl.jena.shared.PrefixMapping
`expandPrefix, getNsPrefixMap, getNsPrefixURI, getNsURIPrefix, lock, qnameFor, removeNsPrefix, samePrefixMappingAs, setNsPrefix, setNsPrefixes, setNsPrefixes, shortForm, withDefaultMappings`

Methods inherited from interface com.hp.hpl.jena.shared.Lock
`enterCriticalSection, leaveCriticalSection`

Method Detail

### size

    long size()

  size will return the number of statements in a concrete model, for a virtualized model such as one created by an inference engine, it will return an estimated lower bound for the numberof statements in the model but it is possible for a subsequent listStatements on such a model to discover more statements than size() indicated.

  Returns:
    the number of statements in a concrete model or an estimated lower bound on the number of statements in an virtualized model

### isEmpty

    boolean isEmpty()

  Answer true iff the model contains no explicit statements (ie it's size is zero, listStatements() would deliver the empty iterator).

  Returns:
    true iff the model contains no explicit statements.

### listSubjects

    ResIterator listSubjects()

  List all resources which are subjects of statements.

  Subsequent operations on those resource may modify this model.

  Returns:
    an iterator over a set of resources which are subjects of statements in the model. .remove() is not implemented on this iterator.

### listNameSpaces

    NsIterator listNameSpaces()

  (You probably don't want this method; more likely you want the PrefixMapping methods that Model supports.) List the namespaces used by predicates and types in the model. This method is really intended for use by the RDF/XML writer, which needs to know these namespaces to generate correct and vaguely pretty XML.

  The namespaces returned are those of (a) every URI used as a property in the model and (b) those of every URI that appears as the object of an rdf:type statement.

  Note that the notion of "namespace" used here is not that of an XML prefix-namespace, but just of the minimal legal left part of a URI (see Util.splitNamespace for details). If you want the RDF/XML (or N3) namespaces, treat the Model as a PrefixMapping.

  Returns:
    an iterator over every predicate and type namespace
  See Also:
    `PrefixMapping`

### getResource

    Resource getResource(java.lang.String uri)

  Return a Resource instance with the given URI in this model. This method behaves identically to `createResource(String)` and exists as legacy: createResource is now capable of, and allowed to, reuse existing objects.

  Subsequent operations on the returned object may modify this model.

  Parameters:
    `uri` - the URI of the resource
  Returns:
    a resource instance

### getProperty

    Property getProperty(java.lang.String nameSpace,
                         java.lang.String localName)

  Return a Property instance with the given URI in this model. This method behaves identically to `createProperty(String,String)` and exists as legacy: createProperty is now capable of, and allowed to, reuse existing objects.

  Subsequent operations on the returned property may modify this model.

  Parameters:
    `nameSpace` - the RDF namespace of the property
    `localName` - the localName of the property in its namespace
  Returns:
    a property linked to this model

### createResource

    Resource createResource()

  Create a new anonymous resource whose model is this model. This bnode will have a new AnonId distinct from any allocated by any other call of this method.

  Subsequent operations on the returned resource may modify this model.

  Returns:
    a new anonymous resource linked to this model.

### createResource

    Resource createResource(AnonId id)

  Create a blank node resource with a specified identifier. The resulting bnode will be equal to any other bnode with the same AnonId (even if they are in separate models - be warned). The intended use for this method is to allow bnode round-tripping between Jena models and other representations.

  This method may return an existing bnode with the correct AnonId and model, or it may construct a fresh one, as it sees fit.

  Operations on the result may modify this model

  Parameters:
    `id` - the identifier to use for this blank node
  Returns:
    a blank node with that identifier

### createResource

    Resource createResource(java.lang.String uri)

  Create a new resource associated with this model. If the uri string is null, this creates a bnode, as per `createResource()`. Otherwise it creates a URI node. A URI resource is .equals() to any other URI Resource with the same URI (even in a different model - be warned).

  This method may return an existing Resource with the correct URI and model, or it may construct a fresh one, as it sees fit.

  Operations on the result Resource may change this model.

  Parameters:
    `uri` - the URI of the resource to be created
  Returns:
    a new resource linked to this model.

### createProperty

    Property createProperty(java.lang.String nameSpace,
                            java.lang.String localName)

  Create a property with a given URI composed from a namespace part and a localname part by concatenating the strings.

  This method may return an existing property with the correct URI and model, or it may construct a fresh one, as it sees fit.

  Subsequent operations on the returned property may modify this model.

  Parameters:
    `nameSpace` - the nameSpace of the property
    `localName` - the name of the property within its namespace
  Returns:
    a property instance

### createLiteral

    Literal createLiteral(java.lang.String v,
                          java.lang.String language)

  Create an untyped literal from a String value with a specified language.

  Parameters:
    `v` - the lexical form of the literal
    `language` - the language associated with the literal
  Returns:
    a new literal representing the value v with the given language

### createLiteral

    Literal createLiteral(java.lang.String v,
                          boolean wellFormed)

  Create a literal from a String value. An existing literal of the right value may be returned, or a fresh one created. The use of the wellFormed flag is to create typed literals of type rdf:XMLLiteral, without error checking. This should only be use when the lexical form is known to already be in exclusive canonical XML.

  Parameters:
    `v` - the lexical form of the literal
    `wellFormed` - true if the Literal is well formed XML, in the lexical space of rdf:XMLLiteral
  Returns:
    a new literal

### createTypedLiteral

    Literal createTypedLiteral(java.lang.String lex,
                               RDFDatatype dtype)

  Build a typed literal from its lexical form. The lexical form will be parsed now and the value stored. If the form is not legal this will throw an exception.

  Note that in preview releases of Jena2 it was also possible to specify a language type. Changes to the RDF specification mean that this is no longer legal except for plain literals. To create a plain literal with a language tag use `createLiteral`.

  Parameters:
    `lex` - the lexical form of the literal
    `dtype` - the type of the literal, null for old style "plain" literals
  Throws:
    `DatatypeFormatException` - if lex is not a legal form of dtype

### createTypedLiteral

    Literal createTypedLiteral(java.lang.Object value,
                               RDFDatatype dtype)

  Build a typed literal from its value form.

  Note that in preview releases of Jena2 it was also possible to specify a language type. Changes to the RDF specification mean that this is no longer legal except for plain literals. To create a plain literal with a language tag use `createLiteral`.

  Parameters:
    `value` - the value of the literal
    `dtype` - the type of the literal, null for old style "plain" literals

### createTypedLiteral

    Literal createTypedLiteral(java.lang.Object value)

  Build a typed literal label from its value form using whatever datatype is currently registered as the the default representation for this java class. No language tag is supplied.

  Specified by:
    `createTypedLiteral` in interface `ModelCon`
  Parameters:
    `value` - the literal value to encapsulate
  Returns:
    a new literal representing the value v

### createStatement

    Statement createStatement(Resource s,
                              Property p,
                              RDFNode o)

  Create a Statement instance. (Creating a statement does not add it to the set of statements in the model; see Model::add). This method may return an existing Statement with the correct components and model, or it may construct a fresh one, as it sees fit.

  Subsequent operations on the statement or any of its parts may modify this model.

  Parameters:
    `s` - the subject of the statement
    `p` - the predicate of the statement
    `o` - the object of the statement
  Returns:
    the new statement

### createList

    RDFList createList()

  Answer a new empty list. This is equivalent to a list consisting only of `rdf:nil`.

  Returns:
    An RDF-encoded list of no elements

### createList

    RDFList createList(java.util.Iterator members)

  Answer a new list containing the resources from the given iterator, in order.

  Parameters:
    `members` - An iterator, each value of which is expected to be an RDFNode
  Returns:
    An RDF-encoded list of the elements of the iterator

### createList

    RDFList createList(RDFNode[] members)

  Answer a new list containing the nodes from the given array, in order

  Parameters:
    `members` - An array of RDF nodes that will be the members of the list
  Returns:
    An RDF-encoded list

### add

    Model add(Statement s)

  Add a statement to this model.

  Parameters:
    `s` - The statement to be added.
  Returns:
    This model.

### add

    Model add(Statement[] statements)

  Add all the statements to the Model, using through the bulk update interface.

  Parameters:
    `statements` - the array of statements to add
  Returns:
    this model, to allow cascading

### remove

    Model remove(Statement[] statements)

  Remove all the statements from the Model, using the bulk update interface.

  Parameters:
    `statements` - the array of statements to be added
  Returns:
    this model, to allow cascading

### add

    Model add(java.util.List statements)

  add all the statements in the List to this Model, going through the bulk update interface (which means turning them into triples in one form or another).

  Parameters:
    `statements` - a List of Statements
  Returns:
    this model, to allow cascading

### remove

    Model remove(java.util.List statements)

  Remove all the statements in the list from this model, using the bulk update interface.

  Parameters:
    `statements` - a List of Statements to remove
  Returns:
    this model, to allow cascading

### add

    Model add(StmtIterator iter)

  Add all the statements returned by an iterator to this model.

  Parameters:
    `iter` - An iterator which returns the statements to be added.
  Returns:
    this model

### add

    Model add(Model m)

  Add all the statements in another model to this model, including the reified statements.

  Parameters:
    `m` - The model whose statements are to be added.
  Returns:
    this model

### add

    Model add(Model m,
              boolean suppressReifications)

  Add all the statements of the given model m to this model. Optionally supress the addition of reified statements.

  Parameters:
    `m` - the model containing the statements to add
    `suppressReifications` - true to suppress adding reified statements
  Returns:
    this model for cascading

### read

    Model read(java.lang.String url)

  Add the RDF statements from an XML document. Uses content negotiation to request appropriate mime types.

  See `Model` for a description of how to traverse a firewall.

  Parameters:
    `url` - of the document containing the RDF statements.
  Returns:
    this model

### read

    Model read(java.io.InputStream in,
               java.lang.String base)

  Add statements from an RDF/XML serialization.

  Parameters:
    `in` - the source of the RDF/XML
    `base` - the base to use when converting relative to absolute uri's. The base URI may be null if there are no relative URIs to convert. A base URI of "" may permit relative URIs to be used in the model unconverted.
  Returns:
    the current model

### read

    Model read(java.io.InputStream in,
               java.lang.String base,
               java.lang.String lang)

  Add RDF statements represented in language `lang` to the model.
  Predefined values for `lang` are "RDF/XML", "N-TRIPLE", "TURTLE" (or "TTL") and "N3". `null` represents the default language, "RDF/XML". "RDF/XML-ABBREV" is a synonym for "RDF/XML".

  Parameters:
    `base` - the base uri to be used when converting relative URI's to absolute URI's. The base URI may be null if there are no relative URIs to convert. A base URI of "" may permit relative URIs to be used in the model.
    `lang` - the langauge of the serialization `null` selects the default
    `in` - the source of the input serialization
  Returns:
    this model

### read

    Model read(java.io.Reader reader,
               java.lang.String base)

  Using this method is often a mistake. Add statements from an RDF/XML serialization. It is generally better to use an InputStream if possible. `read(InputStream,String)`, otherwise there is a danger of a mismatch between the character encoding of say the FileReader and the character encoding of the data in the file.

  Parameters:
    `reader` - the source of the RDF/XML
    `base` - the base to use when converting relative to absolute uri's. The base URI may be null if there are no relative URIs to convert. A base URI of "" may permit relative URIs to be used in the model. * @return the current model

### read

    Model read(java.lang.String url,
               java.lang.String lang)

  Add statements from a serializion in language `lang` to the model.
  Predefined values for `lang` are "RDF/XML", "N-TRIPLE", "TURTLE" (or "TTL") and "N3". `null` represents the default language, "RDF/XML". "RDF/XML-ABBREV" is a synonym for "RDF/XML".

  See `Model` for a description of how to traverse a firewall.

  Parameters:
    `url` - a string representation of the url to read from
    `lang` - the language of the serialization
  Returns:
    this model

### read

    Model read(java.io.Reader reader,
               java.lang.String base,
               java.lang.String lang)

  Using this method is often a mistake. Add RDF statements represented in language `lang` to the model.
  Predefined values for `lang` are "RDF/XML", "N-TRIPLE", "TURTLE" (or "TTL") and "N3". `null` represents the default language, "RDF/XML". "RDF/XML-ABBREV" is a synonym for "RDF/XML".
  It is generally better to use an InputStream if possible. `read(InputStream,String)`, otherwise there is a danger of a mismatch between the character encoding of say the FileReader and the character encoding of the data in the file.

  Parameters:
    `base` - the base uri to be used when converting relative URI's to absolute URI's. The base URI may be null if there are no relative URIs to convert. A base URI of "" may permit relative URIs to be used in the model.
    `lang` - the langauge of the serialization `null` selects the default
    `reader` - the source of the input serialization
  Returns:
    this model

### read

    Model read(java.lang.String url,
               java.lang.String base,
               java.lang.String lang)

  Read into this model the RDF at `url`, using `baseURI` as the base URI if it is non-null. The RDF is assumed to be RDF/XML unless `lang` is non-null, in which case it names the language to be used. Answer this model.

### write

    Model write(java.io.Writer writer)

  Write the model as an XML document. It is often better to use an OutputStream rather than a Writer, since this will avoid character encoding errors.

  Parameters:
    `writer` - A writer to which the XML will be written
  Returns:
    this model

### write

    Model write(java.io.Writer writer,
                java.lang.String lang)

  Write a serialized represention of a model in a specified language. It is often better to use an OutputStream rather than a Writer, since this will avoid character encoding errors.

  The language in which to write the model is specified by the `lang` argument. Predefined values are "RDF/XML", "RDF/XML-ABBREV", "N-TRIPLE", "TURTLE", (and "TTL") and "N3". The default value, represented by `null` is "RDF/XML".

  Parameters:
    `writer` - The output writer
    `lang` - The output language
  Returns:
    this model

### write

    Model write(java.io.Writer writer,
                java.lang.String lang,
                java.lang.String base)

  Write a serialized represention of a model in a specified language. It is often better to use an OutputStream rather than a Writer, since this will avoid character encoding errors.

  The language in which to write the model is specified by the `lang` argument. Predefined values are "RDF/XML", "RDF/XML-ABBREV", "N-TRIPLE", "TURTLE", (and "TTL") and "N3". The default value, represented by `null`, is "RDF/XML".

  Parameters:
    `writer` - The output writer
    `base` - The base uri for relative URI calculations. `null` means use only absolute URI's.
    `lang` - The language in which the RDF should be written
  Returns:
    this model

### write

    Model write(java.io.OutputStream out)

  Write a serialization of this model as an XML document.

  The language in which to write the model is specified by the `lang` argument. Predefined values are "RDF/XML", "RDF/XML-ABBREV", "N-TRIPLE" and "N3". The default value is represented by `null` is "RDF/XML".

  Parameters:
    `out` - The output stream to which the XML will be written
  Returns:
    This model

### write

    Model write(java.io.OutputStream out,
                java.lang.String lang)

  Write a serialized represention of this model in a specified language.

  The language in which to write the model is specified by the `lang` argument. Predefined values are "RDF/XML", "RDF/XML-ABBREV", "N-TRIPLE", "TURTLE", (and "TTL") and "N3". The default value, represented by `null`, is "RDF/XML".

  Parameters:
    `out` - The output stream to which the RDF is written
    `lang` - The output langauge
  Returns:
    This model

### write

    Model write(java.io.OutputStream out,
                java.lang.String lang,
                java.lang.String base)

  Write a serialized represention of a model in a specified language.

  The language in which to write the model is specified by the `lang` argument. Predefined values are "RDF/XML", "RDF/XML-ABBREV", "N-TRIPLE", "TURTLE", (and "TTL") and "N3". The default value, represented by `null`, is "RDF/XML".

  Parameters:
    `out` - The output stream to which the RDF is written
    `base` - The base uri to use when writing relative URI's. `null` means use only absolute URI's. This is used for relative URIs that would be resolved against the document retrieval URL. For some values of `lang`, this value may be included in the output.
    `lang` - The language in which the RDF should be written
  Returns:
    This model

### remove

    Model remove(Statement s)

  Removes a statement.

  The statement with the same subject, predicate and object as that supplied will be removed from the model.

  Parameters:
    `s` - The statement to be removed.
  Returns:
    this model

### getRequiredProperty

    Statement getRequiredProperty(Resource s,
                                  Property p)

  Return a statement with given subject and property.

  If more than one statement witht the given subject and property exists in the model, it is undefined which will be returned. If none exist, an exception is thrown.

  Parameters:
    `s` - The subject of the statement to be returned.
    `p` - The property of the statement to be returned.
  Returns:
    A statement from the model with the given subject and property.
  Throws:
    `PropertyNotFoundException`

### getProperty

    Statement getProperty(Resource s,
                          Property p)

  Answer a statement (s, p, ?O) from this model. If none exist, return null; if several exist, pick one arbitrarily.

  Parameters:
    `s` - the subject of the statement to return
    `p` - the predicate of the statement to return
  Returns:
    some statement (s, p, ?O) or null if none can be found

### listSubjectsWithProperty

    ResIterator listSubjectsWithProperty(Property p)

  An alias for `istResourcesWithProperty(Property)`, retained for backward compatability. It may be deprecated in later releases.

### listResourcesWithProperty

    ResIterator listResourcesWithProperty(Property p)

  Answer an iterator [with no duplicates] over all the resources in this model that have property `p`. `remove()` is not implemented on this iterator.

### listSubjectsWithProperty

    ResIterator listSubjectsWithProperty(Property p,
                                         RDFNode o)

  An alias for `listResourcesWithProperty`, retained for backward compatability. It may be deprecated in later releases.

### listResourcesWithProperty

    ResIterator listResourcesWithProperty(Property p,
                                          RDFNode o)

  Answer an iterator [with no duplicates] over all the resources in this model that have property `p` with value `o`. `remove()` is not implemented on this iterator.

### listObjects

    NodeIterator listObjects()

  List all objects in a model.

  Returns:
    an iterator over the objects. .remove() is not implemented on this iterator.

### listObjectsOfProperty

    NodeIterator listObjectsOfProperty(Property p)

  List all objects of a given property. .remove() is not implemented on this iterator.

  Parameters:
    `p` - The predicate sought
  Returns:
    an iterator over the objects

### listObjectsOfProperty

    NodeIterator listObjectsOfProperty(Resource s,
                                       Property p)

  List the values of a property of a resource.

  Parameters:
    `p` - The predicate sought
  Returns:
    an iterator over the objects. .remove() is not implemented on this iterator.

### contains

    boolean contains(Resource s,
                     Property p)

  Determine whether this model contains any statements with a given subject and property.

  Parameters:
    `s` - The subject sought (null for any).
    `p` - The predicate sought (null for any).
  Returns:
    true if there exists within this model a statement with subject s and property p, false otherwise

### containsResource

    boolean containsResource(RDFNode r)

  determine if the RDFNode r appears in any statement of this model. (containsRDFNode is a horrible name, and in any case, even literals will be resources one day)

  Parameters:
    `r` - the RDFNode to be searched for
  Returns:
    true iff r appears as some subject, predicate, or object

### contains

    boolean contains(Resource s,
                     Property p,
                     RDFNode o)

  Determine if an (S, P, O) pattern is present in this model, with null allowed to represent a wildcard match.

  Parameters:
    `s` - The subject of the statment tested (null as wildcard).
    `p` - The predicate of the statement tested (null as wildcard).
    `o` - The object of the statement tested (null as wildcard).
  Returns:
    true if the statement with subject s, property p and object o is in the model, false otherwise

### contains

    boolean contains(Statement s)

  Determine if a statement is present in this model.

  Parameters:
    `s` - The statement tested.
  Returns:
    true if the statement s is in this model, false otherwise

### containsAny

    boolean containsAny(StmtIterator iter)

  Determine if any of the statements returned by an iterator are contained in this model.

  Parameters:
    `iter` - an iterator of the statements to be tested
  Returns:
    true if any of the statements returns by iter are contained in this model and false otherwise.

### containsAll

    boolean containsAll(StmtIterator iter)

  Determine if all of the statements returned by an iterator are contained in this model.

  Parameters:
    `iter` - an iterator of the statements to be tested
  Returns:
    true if any of the statements returns by iter are contained in this model and false otherwise.

### containsAny

    boolean containsAny(Model model)

  Determine if any of the statements in a model are also contained in this model.

  Parameters:
    `model` - the model containing the statements to be tested
  Returns:
    true if any of the statements in model are also contained in this model and false otherwise.

### containsAll

    boolean containsAll(Model model)

  Determine if all of the statements in a model are also contained in this model.

  Parameters:
    `model` - the model containing the statements to be tested
  Returns:
    true if all of the statements in model are also contained in this model and false otherwise.

### isReified

    boolean isReified(Statement s)

  Determine if this Statement has been reified in this Model.

  Parameters:
    `s` - The statement tested.
  Returns:
    true iff a ReifiedStatement(s) has been created in this model

### getAnyReifiedStatement

    Resource getAnyReifiedStatement(Statement s)

  Find or create a `ReifiedStatement` corresponding to a Statement.

  Parameters:
    `s` - Statement which may or may not already be reified
  Returns:
    a Resource [ReifiedStatement] that reifies the specified Statement.

### removeAllReifications

    void removeAllReifications(Statement s)

  Remove all reifications (ie implicit reification quads) of _s_.

### removeReification

    void removeReification(ReifiedStatement rs)

  Remove a particular reificiation.

### listStatements

    StmtIterator listStatements()

  List all statements.

  Subsequent operations on those statements may modify this model.

  Returns:
    an iterator over all statements in the model.

### listStatements

    StmtIterator listStatements(Selector s)

  List the statements matching a selector.

  A statment is considered to match if the `test` method of s returns true when called on s.

  Parameters:
    `s` - A selector object. .
  Returns:
    an iterator over the matching statements

### listStatements

    StmtIterator listStatements(Resource s,
                                Property p,
                                RDFNode o)

  Find all the statements matching a pattern.

  Return an iterator over all the statements in a model that match a pattern. The statements selected are those whose subject matches the `subject` argument, whose predicate matches the `predicate` argument and whose object matches the `object` argument. If an argument is `null` it matches anything.

  Parameters:
    `s` - The subject sought
    `p` - The predicate sought
    `o` - The value sought
  Returns:
    an iterator over the subjects

### createReifiedStatement

    ReifiedStatement createReifiedStatement(Statement s)

  Answer a ReifiedStatement that encodes _s_ and belongs to this Model.
  result.getModel() == this
  result.getStatement() .equals ( s )

### createReifiedStatement

    ReifiedStatement createReifiedStatement(java.lang.String uri,
                                            Statement s)

  answer a ReifiedStatement that encodes _s_, belongs to this Model, and is a Resource with that _uri_.

### listReifiedStatements

    RSIterator listReifiedStatements()

  answer an iterator delivering all the reified statements "in" this model

### listReifiedStatements

    RSIterator listReifiedStatements(Statement st)

  answer an iterator delivering all the reified statements "in" this model that match the statement _st_.

### getReificationStyle

    ReificationStyle getReificationStyle()

  Answer the reification style of the model.

  Returns:
    the reification style

### query

    Model query(Selector s)

  Create a new model containing the statements matching a query.

  A statment is considered to match if the `test` method of s returns true when called on s.

  Parameters:
    `s` - A selector object. .
  Returns:
    an iterator over the matching statements

### union

    Model union(Model model)

  Create a new, independant, model containing all the statements in this model together with all of those in another given model. By independant we mean that changes to the result model do not affect the operand models, and vice versa.

  The new model need not be of the same type as either this model or the argument model: typically it will be a memory-based model, even if this model is a database model.

  Parameters:
    `model` - The other model whose statements are to be included.
  Returns:
    A new model containing all the statements that are in either model

### intersection

    Model intersection(Model model)

  Create a new, independant, model containing all the statements which are in both this model and another. As models are sets of statements, a statement contained in both models will only appear once in the resulting model. The new model need not be of the same type as either this model or the argument model: typically it will be a memory-based model.

  Parameters:
    `model` - The other model.
  Returns:
    A new model containing all the statements that are in both models.

### difference

    Model difference(Model model)

  Create a new, independant, model containing all the statements in this model which are not in another. The new model need not be of the same type as either this model or the argument model: typically it will be a memory-based model.

  Parameters:
    `model` - the other model whose statements are to be excluded.
  Returns:
    a new model containing all the statements in this model that are not in the given model.

### equals

    boolean equals(java.lang.Object m)

  Test whether the given object `m` is a model that is equal to this model, which is true iff the underlying graphs are identical Java objects. This is not the same test as comparing whether two models have the same structure (i.e. contain the same set of statements). To test for strucutural equivalence, see `isIsomorphicWith(com.hp.hpl.jena.rdf.model.Model)`.

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `m` - the model to be compared
  Returns:
    true if `m` shares a graph object with this model
  See Also:
    `isIsomorphicWith(Model)`

### begin

    Model begin()

  Begin a new transation.

  All changes made to a model within a transaction, will either be made, or none of them will be made.

  Returns:
    this model to enable cascading.

### abort

    Model abort()

  Abort the current transaction and abandon any changes in progress.

  Returns:
    this model to enable cascading.

### commit

    Model commit()

  Commit the current transaction.

  Returns:
    this model to enable cascading.

### executeInTransaction

    java.lang.Object executeInTransaction(Command cmd)

  Execute the command `cmd` inside a transaction. If it completes, commit the transaction and return the result; if it fails (by throwing an exception), abort the transaction and throw an exception.

### independent

    boolean independent()

  Determine whether this model is independent.

  For efficiency reasons, some implementations may create models which which are dependent on others, i.e. a change in one model may cause a change in another. If this is the case this method will return false, otherwise it will return true.

  Returns:
    true if this model is indepdent of others

### supportsTransactions

    boolean supportsTransactions()

  Determine whether this model supports transactions.

  Returns:
    true if this model supports transactions.

### supportsSetOperations

    boolean supportsSetOperations()

  Determine whether this model supports set operations.

  Returns:
    true if this model supports set operations.

### isIsomorphicWith

    boolean isIsomorphicWith(Model g)

  Compare this Model with another for equality ignoring the labels on bNodes. See RDF Concepts.

  Two models are isomorphic when each statement in one can be matched with a statement in the other. Statements which are identical match.

  Special treatment is given to anonymous nodes. A binding is a one to one mapping which maps each anonymous node in `this` model to an anonymous node in `model`. Two statements s1 and s2 match under a binding if if s1.subject is anonymous and s2.subject is anonymous and the binding maps s1.subject to s2.subject.

  Two models are isomorphic if there is a binding that allows all the statements in one model to match a a statement in the other.

  Parameters:
    `g` - Compare against this.
  Returns:
    boolean True if the two RDF graphs are isomorphic.

### close

    void close()

  Close the Model and free up resources held.

  Not all implementations of Model require this method to be called. But some do, so in general its best to call it when done with the object, rather than leave it to the finalizer.

### getLock

    Lock getLock()

  Get the model lock for this model. See also the convenience operations enterCriticalSection and leaveCriticalSection.

  Returns:
    The ModelLock object associated with this model
  See Also:
    `ModelLock`

### register

    Model register(ModelChangedListener listener)

  Register a listener for model-changed events on this model. The methods on the listener will be called when API add/remove calls on the model succeed [in whole or in part].

  The same listener may be registered many times; if so, it's methods will be called as many times as it's registered for each event.

  Returns:
    this model, for cascading
  See Also:
    `ModelChangedListener`

### unregister

    Model unregister(ModelChangedListener listener)

  Unregister a listener from model-changed events on this model. The listener is dtached from the model. The model is returned to permit cascading. If the listener is not attached to the model, then nothing happens.

  Returns:
    this model, for cascading
  See Also:
    `ModelChangedListener`

### notifyEvent

    Model notifyEvent(java.lang.Object e)

  Notify any listeners that the event e has occurred.

  Parameters:
    `e` - the event that has occurred

### removeAll

    Model removeAll()

  Remove all the statements from this model.

### removeAll

    Model removeAll(Resource s,
                    Property p,
                    RDFNode r)

  Remove all the statements matching (s, p, o) from this model.

### isClosed

    boolean isClosed()

  Answer true iff .close() has been called on this Model.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP