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
Class ModelFactory

    java.lang.Object
      com.hp.hpl.jena.rdf.model.ModelFactoryBase
          com.hp.hpl.jena.rdf.model.ModelFactory

    public class ModelFactory

extends ModelFactoryBase

ModelFactory provides methods for creating standard kinds of Model. (ModelFactoryBase is helper functions for it).

Field Summary
`static ReificationStyle` | `Convenient` The convenient reification style; quadlets contribute to reified statements, but are invisible to listStatements().
`static ReificationStyle` | `Minimal` The minimal reification style; quadlets do not contribute to reified statements, and are visible to listStatements().
`static ReificationStyle` | `Standard` The standard reification style; quadlets contribute to reified statements, and are visible to listStatements().

Method Summary
`static Model` | `assembleModelFrom(Model singleRoot)` Answer a Model constructed from the single resource in `singleRoot` of type `ja:Model`.
`static Model` | `assembleModelFrom(Resource root)` Answer a Model as described the the Assembler specification rooted at the Resource `root` in its Model.
`static Model` | `createDefaultModel()` Answer a fresh Model with the default specification and Standard reification style [reification triples contribute to ReifiedStatements, and are visible to listStatements, etc].
`static Model` | `createDefaultModel(ReificationStyle style)` Answer a new memory-based model with the given reification style
`static ModelMaker` | `createFileModelMaker(java.lang.String root)` Answer a ModelMaker that constructs memory-based Models that are backed by files in the root directory.
`static ModelMaker` | `createFileModelMaker(java.lang.String root, ReificationStyle style)` Answer a ModelMaker that constructs memory-based Models that are backed by files in the root directory.
`static InfModel` | `createInfModel(InfGraph g)` Build an inference model from an InfGraph.
`static InfModel` | `createInfModel(Reasoner reasoner, Model model)` Build an inferred model by attaching the given RDF model to the given reasoner.
`static InfModel` | `createInfModel(Reasoner reasoner, Model schema, Model model)` Build an inferred model by attaching the given RDF model to the given reasoner.
`static ModelMaker` | `createMemModelMaker()` Answer a ModelMaker that constructs memory-based Models that do not persist past JVM termination.
`static ModelMaker` | `createMemModelMaker(ReificationStyle style)` Answer a ModelMaker that constructs memory-based Models that do not persist past JVM termination, with the given reification style.
`static Model` | `createModelForGraph(Graph g)` Answer a model that encapsulates the given graph.
`static ModelMaker` | `createModelRDBMaker(IDBConnection c)` Answer a ModelMaker that accesses database-backed Models on the database at the other end of the connection c with the usual Standard reification style.
`static ModelMaker` | `createModelRDBMaker(IDBConnection c, ReificationStyle style)` Answer a ModelMaker that accesses database-backed Models on the database at the other end of the connection c with the given reification style.
`static Model` | `createNonreifyingModel()` construct a new memory-based model that does not capture reification triples (but still handles reifyAs() and .as(ReifiedStatement).
`static OntModel` | `createOntologyModel()` Answer a new ontology model which will process in-memory models of ontologies expressed the default ontology language (OWL).
`static OntModel` | `createOntologyModel(OntModelSpec spec)` Answer a new ontology model constructed according to the specification, which includes a ModelMaker which will create the necessary base model.
`static OntModel` | `createOntologyModel(OntModelSpec spec, Model base)` Answer a new ontology model, constructed according to the given ontology model specification, and starting with the ontology data in the given model.
`static OntModel` | `createOntologyModel(OntModelSpec spec, ModelMaker maker, Model base)` Answer a new ontology model which will process in-memory models of ontologies expressed the default ontology language (OWL).
`static OntModel` | `createOntologyModel(java.lang.String languageURI)` Answer a new ontology model which will process in-memory models of ontologies in the given language.
`static InfModel` | `createRDFSModel(Model model)` Return a Model through which all the RDFS entailments derivable from the given model are accessible.
`static InfModel` | `createRDFSModel(Model schema, Model model)` Return a Model through which all the RDFS entailments derivable from the given data and schema models are accessible.
`static IDBConnection` | `createSimpleRDBConnection()` Answer a plain IDBConnection to a database, with the arguments implicitly supplied by system properties: The database URL - jena.db.url The user - jena.db.user, or fails back to "test" The password - jena.db.password, or fails back to "" The db type - jena.db.type, or guessed from the URL
`static IDBConnection` | `createSimpleRDBConnection(java.lang.String url, java.lang.String user, java.lang.String password, java.lang.String dbType)` Answer a plain IDBConnection to a database with the given URL, with the given user having the given password.
`static Model` | `createUnion(Model m1, Model m2)` Answer a new model that is the dynamic union of two other models.
`static java.util.Set` | `findAssemblerRoots(Model m)` Answer a Set of resources present in `m` that are explicitly or implicitly of type ja:Object, ie, suitable as roots for `assemblerModelFrom`.
`static PrefixMapping` | `getDefaultModelPrefixes()` Answer the current default model prefixes PrefixMapping object.
`static PrefixMapping` | `setDefaultModelPrefixes(PrefixMapping pm)` Each Model created by ModelFactory has a default set of prefix mappings.
`static Model` | `withHiddenStatements(Model m)` Answer a read-only Model with all the statements of this Model and any statements "hidden" by reification.

Methods inherited from class com.hp.hpl.jena.rdf.model.ModelFactoryBase
`extractType, guessDBConcurrent, guessDBDriver, guessDBPassword, guessDBType, guessDBURL, guessDBUser`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### Standard

    public static final ReificationStyle Standard

  The standard reification style; quadlets contribute to reified statements, and are visible to listStatements().

### Convenient

    public static final ReificationStyle Convenient

  The convenient reification style; quadlets contribute to reified statements, but are invisible to listStatements().

### Minimal

    public static final ReificationStyle Minimal

  The minimal reification style; quadlets do not contribute to reified statements, and are visible to listStatements().

Method Detail

### setDefaultModelPrefixes

    public static PrefixMapping setDefaultModelPrefixes(PrefixMapping pm)

  Each Model created by ModelFactory has a default set of prefix mappings. These mappings are copied from a (static) default PrefixMapping which is set by setDefaultModelPrefixes. It is the reference to a PrefixMapping that is retained, not a copy of it, so a user may set the defaults with this method and continue to modify it; the modifications will appear in the next model to be created.

  When a Model is created from an existing Graph, the prefixes of that Graph are not disturbed; only ones not present in the Graph are added.

  Parameters:
    `pm` - the default prefixes to use
  Returns:
    the previous default prefix mapping

### getDefaultModelPrefixes

    public static PrefixMapping getDefaultModelPrefixes()

  Answer the current default model prefixes PrefixMapping object.

### assembleModelFrom

    public static Model assembleModelFrom(Model singleRoot)

  Answer a Model constructed from the single resource in `singleRoot` of type `ja:Model`. See the Assembler howto (doc/assembler/assembler-howto.html) for documentation of Assembler descriptions. See also `findAssemblerRoots` to find the set of possible roots in a description, and `assemblerModelFrom(Resource)` for assembling a model from its single description.

### findAssemblerRoots

    public static java.util.Set findAssemblerRoots(Model m)

  Answer a Set of resources present in `m` that are explicitly or implicitly of type ja:Object, ie, suitable as roots for `assemblerModelFrom`. Note that the resource objects returned need not have `m` as their `getModel()` - they may be members of an extended constructed model.

### assembleModelFrom

    public static Model assembleModelFrom(Resource root)

  Answer a Model as described the the Assembler specification rooted at the Resource `root` in its Model. `Resource` must be of rdf:type `ja:Object`, where `ja` is the prefix of Jena Assembler objects.

### createDefaultModel

    public static Model createDefaultModel()

  Answer a fresh Model with the default specification and Standard reification style [reification triples contribute to ReifiedStatements, and are visible to listStatements, etc].

### createDefaultModel

    public static Model createDefaultModel(ReificationStyle style)

  Answer a new memory-based model with the given reification style

### withHiddenStatements

    public static Model withHiddenStatements(Model m)

  Answer a read-only Model with all the statements of this Model and any statements "hidden" by reification. That model is dynamic, ie any changes this model will be reflected that one.

### createNonreifyingModel

    public static Model createNonreifyingModel()

  construct a new memory-based model that does not capture reification triples (but still handles reifyAs() and .as(ReifiedStatement).

### createModelForGraph

    public static Model createModelForGraph(Graph g)

  Answer a model that encapsulates the given graph. Existing prefixes are undisturbed.

  Parameters:
    `g` - A graph structure
  Returns:
    A model presenting an API view of graph g

### createFileModelMaker

    public static ModelMaker createFileModelMaker(java.lang.String root)

  Answer a ModelMaker that constructs memory-based Models that are backed by files in the root directory. The Model is loaded from the file when it is opened, and when the Model is closed it is written back. The model is given the Standard reification style.

  Parameters:
    `root` - the name of the directory in which the backing files are held
  Returns:
    a ModelMaker linked to the files in the root

### createFileModelMaker

    public static ModelMaker createFileModelMaker(java.lang.String root,
                                                  ReificationStyle style)

  Answer a ModelMaker that constructs memory-based Models that are backed by files in the root directory. The Model is loaded from the file when it is opened, and when the Model is closed it is written back.

  Parameters:
    `root` - the name of the directory in which the backing files are held
    `style` - the desired reification style
  Returns:
    a ModelMaker linked to the files in the root

### createMemModelMaker

    public static ModelMaker createMemModelMaker()

  Answer a ModelMaker that constructs memory-based Models that do not persist past JVM termination. The model has the Standard reification style.

  Returns:
    a ModelMaker that constructs memory-based models

### createMemModelMaker

    public static ModelMaker createMemModelMaker(ReificationStyle style)

  Answer a ModelMaker that constructs memory-based Models that do not persist past JVM termination, with the given reification style.

  Parameters:
    `style` - the reification style for the model
  Returns:
    a ModelMaker that constructs memory-based models

### createModelRDBMaker

    public static ModelMaker createModelRDBMaker(IDBConnection c)

  Answer a ModelMaker that accesses database-backed Models on the database at the other end of the connection c with the usual Standard reification style.

  Parameters:
    `c` - a connection to the database holding the models
  Returns:
    a ModelMaker whose Models are held in the database at c

### createModelRDBMaker

    public static ModelMaker createModelRDBMaker(IDBConnection c,
                                                 ReificationStyle style)

  Answer a ModelMaker that accesses database-backed Models on the database at the other end of the connection c with the given reification style.

  Parameters:
    `c` - a connection to the database holding the models
    `style` - the desired reification style
  Returns:
    a ModelMaker whose Models are held in the database at c

### createSimpleRDBConnection

    public static IDBConnection createSimpleRDBConnection(java.lang.String url,
                                                          java.lang.String user,
                                                          java.lang.String password,
                                                          java.lang.String dbType)

  Answer a plain IDBConnection to a database with the given URL, with the given user having the given password. For more complex ways of forming a connection, see the DBConnection documentation.

  Parameters:
    `url` - the URL of the database
    `user` - the user name to use to access the database
    `password` - the password to use. WARNING: open text.
    `dbType` - the databate type: currently, "Oracle" or "MySQL".
  Returns:
    the connection
  Throws:
    `quite` - possibly

### createSimpleRDBConnection

    public static IDBConnection createSimpleRDBConnection()

  Answer a plain IDBConnection to a database, with the arguments implicitly supplied by system properties:

  The database URL - jena.db.url
  The user - jena.db.user, or fails back to "test"
  The password - jena.db.password, or fails back to ""
  The db type - jena.db.type, or guessed from the URL

### createRDFSModel

    public static InfModel createRDFSModel(Model model)

  Return a Model through which all the RDFS entailments derivable from the given model are accessible. Some work is done when the inferenced model is created but each query will also trigger some additional inference work.

  Parameters:
    `model` - the Model containing both instance data and schema assertions to be inferenced over

### createRDFSModel

    public static InfModel createRDFSModel(Model schema,
                                           Model model)

  Return a Model through which all the RDFS entailments derivable from the given data and schema models are accessible. There is no strict requirement to separate schema and instance data between the two arguments.

  Parameters:
    `model` - a Model containing instance data assertions
    `schema` - a Model containing RDFS schema data

### createInfModel

    public static InfModel createInfModel(Reasoner reasoner,
                                          Model model)

  Build an inferred model by attaching the given RDF model to the given reasoner.

  Parameters:
    `reasoner` - the reasoner to use to process the data
    `model` - the Model containing both instance data and schema assertions to be inferenced over

### createInfModel

    public static InfModel createInfModel(Reasoner reasoner,
                                          Model schema,
                                          Model model)

  Build an inferred model by attaching the given RDF model to the given reasoner. This form of the call allows two data sets to be merged and reasoned over - conventionally one contains schema data and one instance data but this is not a formal requirement.

  Parameters:
    `reasoner` - the reasoner to use to process the data
    `schema` - a Model containing RDFS schema data
    `model` - a Model containing instance data assertions

### createInfModel

    public static InfModel createInfModel(InfGraph g)

  Build an inference model from an InfGraph. Graphs and InfGraphs are internal implementation level objects rather than normal user objects so this method should only be used if you are sure this is what you need.

  Parameters:
    `g` - and inference graph
  Returns:
    the same graph wrapped up as an InfModel

### createOntologyModel

    public static OntModel createOntologyModel()

  Answer a new ontology model which will process in-memory models of ontologies expressed the default ontology language (OWL). The default document manager will be used to load the ontology's included documents.

  Note:The default model chosen for OWL, RDFS and DAML+OIL includes a weak reasoner that includes some entailments (such as transitive closure on the sub-class and sub-property hierarchies). Users who want either no inference at all, or alternatively more complete reasoning, should use one of the other `createOntologyModel` methods that allow the preferred OntModel specification to be stated.

  Returns:
    A new ontology model
  See Also:
    `OntModelSpec.getDefaultSpec(java.lang.String)`, `createOntologyModel(OntModelSpec, Model)`

### createOntologyModel

    public static OntModel createOntologyModel(java.lang.String languageURI)

  Answer a new ontology model which will process in-memory models of ontologies in the given language. The default document manager will be used to load the ontology's included documents.

  Parameters:
    `languageURI` - The URI specifying the ontology language we want to process
  Returns:
    A new ontology model
  See Also:
    `OntModelSpec.getDefaultSpec(java.lang.String)`

### createOntologyModel

    public static OntModel createOntologyModel(OntModelSpec spec,
                                               ModelMaker maker,
                                               Model base)

  Answer a new ontology model which will process in-memory models of ontologies expressed the default ontology language (OWL). The default document manager will be used to load the ontology's included documents.

  Parameters:
    `spec` - An ontology model specification that defines the language and reasoner to use
    `maker` - A model maker that is used to get the initial store for the ontology (unless the base model is given), and create addtional stores for the models in the imports closure
    `base` - The base model, which contains the contents of the ontology to be processed
  Returns:
    A new ontology model
  See Also:
    `OntModelSpec`

### createOntologyModel

    public static OntModel createOntologyModel(OntModelSpec spec,
                                               Model base)

  Answer a new ontology model, constructed according to the given ontology model specification, and starting with the ontology data in the given model.

  Parameters:
    `spec` - An ontology model specification object, that will be used to construct the ontology model with different options of ontology language, reasoner, document manager and storage model
    `base` - An existing model to treat as an ontology model, or null.
  Returns:
    A new ontology model
  See Also:
    `OntModelSpec`

### createOntologyModel

    public static OntModel createOntologyModel(OntModelSpec spec)

  Answer a new ontology model constructed according to the specification, which includes a ModelMaker which will create the necessary base model.

### createUnion

    public static Model createUnion(Model m1,
                                    Model m2)

  Answer a new model that is the dynamic union of two other models. By dynamic union, we mean that changes to either `m1` or `m2` will be reflected in the result model, and vice versa: specifically, additions to and removals from the union will be implemented as operations on `m1` only. See also the behaviour of OntModel and the MultiUnion class.

  `createUnion` only creates two-element unions.

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