Uses of Interface
com.hp.hpl.jena.rdf.model.Model

Packages that use Model
com.hp.hpl.jena.db A general database backend for persistent storage of Jena models.  
com.hp.hpl.jena.ontology Provides a set of abstractions and convenience classes for accessing and manipluating ontologies represented in RDF.  
com.hp.hpl.jena.ontology.daml A re-implementation of the Jena 1.X DAML+OIL API, to assist Jena 1 users to move to Jena2.  
com.hp.hpl.jena.ontology.tidy Implements an OWL Syntax Checker.  
com.hp.hpl.jena.rdf.arp Reading RDF/XML.  
com.hp.hpl.jena.rdf.listeners A package defining some useful implementations of ModelChangedListener, for listening to (a) all triples added or removed, exploding composite objects, (b) all objects added or removed, as themselves, (c) notification of additions/removals, but no details, and (d) accepting but ignoring all changes, as a base-class to be extended.  
com.hp.hpl.jena.rdf.model A package for creating and manipulating RDF graphs.  
com.hp.hpl.jena.rdf.model.impl This package contains implementations of the interfaces defined in the .model package, eg ModelCom for Model, ResourceImpl for Resource, and so on.  
com.hp.hpl.jena.rdql RDQL - A query language for Jena.  
com.hp.hpl.jena.reasoner The Jena2 reasoner subsystem is designed to allow a range of inference engines to be plugged into Jena.  
com.hp.hpl.jena.reasoner.rulesys Provides a selection of simple rule engines for Jena inference models.  
com.hp.hpl.jena.reasoner.transitiveReasoner This package contains a reasoner which supports transitive-reflexive closure of subPropertyOf and subClassOf relations.  
com.hp.hpl.jena.shared This package defines some classes common to the Jena API and SPI levels, in particular the JenaException class from which all Jena-specific exceptions hang, and the interface PrefixMapping for translation to and from QNames. 
com.hp.hpl.jena.util Miscellaneous collection of utility classes.  
com.hp.hpl.jena.vocabulary A package containing constant classes with predefined constant objects for classes and properties defined in well known vocabularies.  
 

Uses of Model in com.hp.hpl.jena.db
 

Classes in com.hp.hpl.jena.db that implement Model
 class ModelRDB
          A persistent relational database implemention of the RDF API.
 

Methods in com.hp.hpl.jena.db that return Model
 Model ModelRDB.getModelProperties()
          Returns a Jena Model containing model-specific properties.
static Model ModelRDB.getDefaultModelProperties(IDBConnection dbcon)
          Retrieve a default set of model customization properties The returned default set of properties is suitable for use in a call to ModelRDB.create(..., modelProperties);
 Model ModelRDB.loadAll()
          Deprecated. Since Jena 2.0, this call is not recommended. Instead use the soon-to-be-released bulk-load functions.
 Model IDBConnection.getDatabaseProperties()
          Returns a Jena Model containing database properties.
 Model IDBConnection.getDefaultModelProperties()
          Retrieve a default set of model customization properties.
 Model DBConnection.getDatabaseProperties()
           
 Model DBConnection.getDefaultModelProperties()
           
 

Methods in com.hp.hpl.jena.db with parameters of type Model
static ModelRDB ModelRDB.createModel(IDBConnection dbcon, Model modelProperties)
          Create a new model on an existing database.
static ModelRDB ModelRDB.createModel(IDBConnection dbcon, java.lang.String name, Model modelProperties)
          Create a new model on an existing database.
 void IDBConnection.setDatabaseProperties(Model propertyModel)
          Sets database-specific properties.
 void DBConnection.setDatabaseProperties(Model dbProperties)
           
 

Uses of Model in com.hp.hpl.jena.ontology
 

Subinterfaces of Model in com.hp.hpl.jena.ontology
 interface OntModel
           An enhanced view of a Jena model that is known to contain ontology data, under a given ontology vocabulary (such as OWL).
 

Methods in com.hp.hpl.jena.ontology that return Model
 Model OntModelSpec.createModel()
          Satisfy the ModelSpec interface: create an [Ont]Model according to the specification.
 Model OntModelSpec.createModelOver(java.lang.String name)
          Satisfy the ModelSpec interface: create an [Ont]Model according to the specification.
 Model OntModelSpec.addDescription(Model d, Resource self)
          Add the description of this OntModelSpec to the given model under the given resource.
 Model OntModel.getBaseModel()
           Answer the base model of this model.
 Model OntModel.write(java.io.Writer writer)
          Write the model as an XML document.
 Model OntModel.write(java.io.Writer writer, java.lang.String lang)
          Write a serialized represention of a model in a specified language.
 Model OntModel.write(java.io.Writer writer, java.lang.String lang, java.lang.String base)
          Write a serialized represention of a model in a specified language.
 Model OntModel.write(java.io.OutputStream out)
          Write a serialization of this model as an XML document.
 Model OntModel.write(java.io.OutputStream out, java.lang.String lang)
          Write a serialized represention of this model in a specified language.
 Model OntModel.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 OntModel.writeAll(java.io.Writer writer, java.lang.String lang, java.lang.String base)
          Write a serialized represention of all of the contents of the model, including inferred statements and statements imported from other documents.
 Model OntModel.writeAll(java.io.OutputStream out, java.lang.String lang, java.lang.String base)
          Write a serialized represention of all of the contents of the model, including inferred statements and statements imported from other documents.
 Model OntDocumentManager.getModel(java.lang.String uri)
           Answer the cached model corresponding to the given document, if known.
 Model OntDocumentManager.getOntology(java.lang.String uri, OntModelSpec spec)
           Answer the ontology model that results from loading the document with the given URI.
 

Methods in com.hp.hpl.jena.ontology with parameters of type Model
static ModelMaker OntModelSpec.getImportMaker(Model description, Resource root)
          Answer the ModelMaker to be used to construct models that are used for the imports of an OntModel.
static java.lang.String OntModelSpec.getLanguage(Model description, Resource root)
          Answer the URI string of the ontology language in this description.
static OntDocumentManager OntModelSpec.getDocumentManager(Model description, Resource root)
          Answer an OntDocumentManager satisfying the docManager part of this description.
static ReasonerFactory OntModelSpec.getReasonerFactory(Model description, Resource root)
          Answer a ReasonerFactory as described by the reasonsWith part of this discription.
 Model OntModelSpec.addDescription(Model d, Resource self)
          Add the description of this OntModelSpec to the given model under the given resource.
 void OntModel.addSubModel(Model model)
           Add the given model as one of the sub-models of the enclosed ontology union model.
 void OntModel.addSubModel(Model model, boolean rebind)
           Add the given model as one of the sub-models of the enclosed ontology union model.
 void OntModel.removeSubModel(Model model)
           Remove the given model as one of the sub-models of the enclosed ontology union model.
 void OntModel.removeSubModel(Model model, boolean rebind)
           Remove the given model as one of the sub-models of the enclosed ontology union model.
 void OntDocumentManager.configure(Model config)
          Configure this document manager using the given configuration information, after first resetting the model back to all default values.
 void OntDocumentManager.configure(Model config, boolean reset)
          Configure this document manager according to the configuration options supplied by the given configuration model.
 void OntDocumentManager.addModel(java.lang.String docURI, Model model)
           Add an entry that model is the appropriate model to use for the given ontology document
 

Constructors in com.hp.hpl.jena.ontology with parameters of type Model
OntModelSpec(Model description)
          Initialise an OntModelSpec from an RDF description using the JMS vocabulary.
OntModelSpec(Resource root, Model description)
          Initialise an OntModelSpec from an RDF description using the JMS vocabulary.
OntDocumentManager(Model config)
          Initialise a document manager with the given configuration model.
 

Uses of Model in com.hp.hpl.jena.ontology.daml
 

Subinterfaces of Model in com.hp.hpl.jena.ontology.daml
 interface DAMLModel
          Interface that encapsulates the capability of storing and retrieving DAML ontology information from the underlying storage or persistence service.
 

Methods in com.hp.hpl.jena.ontology.daml that return Model
 Model DAMLModel.read(java.lang.String uri, java.lang.String base, java.lang.String lang)
          Read the ontology indicated by the given uri.
 

Uses of Model in com.hp.hpl.jena.ontology.tidy
 

Methods in com.hp.hpl.jena.ontology.tidy with parameters of type Model
 void Checker.add(Model m)
          Adds the model to the syntax check.
 

Uses of Model in com.hp.hpl.jena.rdf.arp
 

Methods in com.hp.hpl.jena.rdf.arp that return Model
static Model JenaReader.memModel()
          Deprecated. This Reader is now the default.
 

Methods in com.hp.hpl.jena.rdf.arp with parameters of type Model
static void JenaReader.useMe(Model m)
          Sets the reader for the languages RDF/XML and RDF/XML-ABBREV to be JenaReader.
 void JenaReader.read(Model model, java.lang.String url)
           
 void JenaReader.read(Model model, java.io.Reader reader, java.lang.String xmlBase)
          Reads from reader, using base URI xmlbase, adding triples to model.
 void JenaReader.read(Model model, java.io.InputStream in, java.lang.String xmlBase)
          Reads from inputStream, using base URI xmlbase, adding triples to model.
 

Uses of Model in com.hp.hpl.jena.rdf.listeners
 

Methods in com.hp.hpl.jena.rdf.listeners with parameters of type Model
 void StatementListener.addedStatements(Model m)
           
 void StatementListener.removedStatements(Model m)
           
 void ObjectListener.addedStatements(Model m)
           
 void ObjectListener.removedStatements(Model m)
           
 void NullListener.addedStatements(Model m)
           
 void NullListener.removedStatements(Model m)
           
 void ChangedListener.addedStatements(Model m)
           
 void ChangedListener.removedStatements(Model m)
           
 

Uses of Model in com.hp.hpl.jena.rdf.model
 

Subinterfaces of Model in com.hp.hpl.jena.rdf.model
 interface InfModel
          An extension to the normal Model interface that supports access to any underlying inference capability.
 

Methods in com.hp.hpl.jena.rdf.model that return Model
 Model Statement.getModel()
          get the Model this Statement was created in.
 Model Resource.getModel()
          Return the model associated with this resource.
 Model ModelSpec.createModel()
          Answer a new Model which fits the specification of this ModelSpec.
 Model ModelSpec.createModelOver(java.lang.String name)
          Answer a Model that fits the specification of this ModelSpec and is built over some underlying model with the given name.
 Model ModelSpec.getDescription()
          Answer an RDF description of this ModelSpec using the JMS vocabulary.
 Model ModelSpec.getDescription(Resource root)
          Answer an RDF description of this ModelSpec using the JMS vocabulary, with the given Resource as root.
 Model ModelSpec.addDescription(Model m, Resource self)
          Add this ModelSpec's description to a given model, under the given resource
 Model ModelMaker.createModel(java.lang.String name, boolean strict)
          Create a new Model associated with the given name.
 Model ModelMaker.createModel(java.lang.String name)
          Create a Model that does not already exist - equivalent to
createModel( name, false ).
 Model ModelMaker.createModel()
          Create a new anonymous Model, as per ModelSpec.
 Model ModelMaker.getModel()
          Answer the default Model for this Maker.
 Model ModelMaker.openModel(java.lang.String name, boolean strict)
          Find an existing Model that this factory knows about under the given name.
 Model ModelMaker.openModel(java.lang.String name)
          Equivalent to openModel( name, false )
static Model ModelFactory.createModel(ModelSpec desc)
          Answer a fresh Model created according to the ModelSpec argument.
static Model ModelFactory.createModelOver(ModelSpec desc, java.lang.String name)
          Answer a fresh Model created according to the given specifictaion and based on any underlying model with the given name.
static Model ModelFactory.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 ModelFactory.createDefaultModel(ReificationStyle style)
          Answer a new memory-based model with the given reification style
static Model ModelFactory.withHiddenStatements(Model m)
          Answer a read-only Model with all the statements of this Model and any statements "hidden" by reification.
static Model ModelFactory.createNonreifyingModel()
          construct a new memory-based model that does not capture reification triples (but still handles reifyAs() and .as(ReifiedStatement).
static Model ModelFactory.createModelForGraph(Graph g)
          Answer a model that encapsulates the given graph.
 Model ModelCon.add(Resource s, Property p, RDFNode o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, boolean o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, long o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, char o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, float o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, double o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, java.lang.String o)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, java.lang.String o, boolean wellFormed)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, java.lang.String o, java.lang.String l)
          add a statement to this model.
 Model ModelCon.add(Resource s, Property p, java.lang.String o, java.lang.String l, boolean wellFormed)
          Deprecated. since Jena2. It is no longer legal to have a language tag on a well-formed XMLLiteral. Use the 4-argument form of add instead. add a statement to this model.
 Model ModelCon.add(Resource s, Property p, java.lang.Object o)
          add a statement to this model.
 Model ModelCon.remove(StmtIterator iter)
          Remove all the Statements returned by an iterator.
 Model ModelCon.remove(Model m)
          Remove all the Statements in a given model, including reified statements
 Model ModelCon.remove(Model m, boolean suppressReifications)
          Remove from this model all the statements found in the given model.
 Model Model.add(Statement s)
          Add a statement to this model.
 Model Model.add(Statement[] statements)
          Add all the statements to the Model, using through the bulk update interface.
 Model Model.remove(Statement[] statements)
          Remove all the statements from the Model, using the bulk update interface.
 Model 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 Model.remove(java.util.List statements)
          Remove all the statements in the list from this model, using the bulk update interface.
 Model Model.add(StmtIterator iter)
          Add all the statements returned by an iterator to this model.
 Model Model.add(Model m)
          Add all the statements in another model to this model, including the reified statements.
 Model Model.add(Model m, boolean suppressReifications)
          Add all the statements of the given model m to this model.
 Model Model.read(java.lang.String url)
          Add the RDF statements from an XML document.
 Model Model.read(java.io.InputStream in, java.lang.String base)
          Add statements from an RDF/XML serialization.
 Model 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 Model.read(java.io.Reader reader, java.lang.String base)
          Using this method is often a mistake.
 Model Model.read(java.lang.String url, java.lang.String lang)
          Add statements from a serializion in language lang to the model.
 Model Model.read(java.io.Reader reader, java.lang.String base, java.lang.String lang)
          Using this method is often a mistake.
 Model Model.write(java.io.Writer writer)
          Write the model as an XML document.
 Model Model.write(java.io.Writer writer, java.lang.String lang)
          Write a serialized represention of a model in a specified language.
 Model 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.
 Model Model.write(java.io.OutputStream out)
          Write a serialization of this model as an XML document.
 Model Model.write(java.io.OutputStream out, java.lang.String lang)
          Write a serialized represention of this model in a specified language.
 Model 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 Model.remove(Statement s)
          Removes a statement.
 Model Model.query(Selector s)
          Create a new model containing the statements matching a query.
 Model Model.union(Model model)
          Create a new model containing all the statements in this model together with all of those in another given model.
 Model Model.intersection(Model model)
          Create a new model containing all the statements which are in both this model and another.
 Model Model.difference(Model model)
          Create a new model containing all the statements in this model which are not in another.
 Model Model.begin()
          Begin a new transation.
 Model Model.abort()
          Abort the current transaction and abandon any changes in progress.
 Model Model.commit()
          Commit the current transaction.
 Model Model.register(ModelChangedListener listener)
          Register a listener for model-changed events on this model.
 Model Model.unregister(ModelChangedListener listener)
          Unregister a listener from model-changed events on this model.
 Model InfModel.getRawModel()
          Return the raw RDF model being processed (i.e. the argument to the Reasonder.bind call that created this InfModel).
 Model InfModel.getDeductionsModel()
          Returns a derivations model.
 

Methods in com.hp.hpl.jena.rdf.model with parameters of type Model
 void RDFWriter.write(Model model, java.io.Writer out, java.lang.String base)
          Caution: Serialize Model model to Writer out.
 void RDFWriter.write(Model model, java.io.OutputStream out, java.lang.String base)
          Serialize Model model to OutputStream out.
 void RDFReader.read(Model model, java.io.Reader r, java.lang.String base)
          It is usually a mistake to use this method.
 void RDFReader.read(Model model, java.io.InputStream r, java.lang.String base)
          Read serialized RDF from an InputStream and add the statements to a Model.
 void RDFReader.read(Model model, java.lang.String url)
          Read serialized RDF from a url and add the statements to a model.
 RDFNode RDFNode.inModel(Model m)
          returns a .equals() version of this node, except that its in the model m.
 ModelSpec ModelSpecCreator.create(Resource root, Model desc)
          create [or find] a ModelSpec that is appropriate for the description rooted at the given root resource, which must have rdf:type JMS:ModelSpec.
 Model ModelSpec.addDescription(Model m, Resource self)
          Add this ModelSpec's description to a given model, under the given resource
 ModelMaker ModelMakerCreator.create(Model desc, Resource root)
          Answer a ModelMaker who's description is found hanging from a given root in a given model.
static ModelSpec ModelFactory.createSpec(Model desc)
          Answer a ModelSpec which can create models to the specifications in the RDF description.
static ModelSpec ModelFactory.createSpec(Resource root, Model desc)
          Answer a ModelSpec which can create models to the specifcations in the RDF description rooted at the given root.
static Model ModelFactory.withHiddenStatements(Model m)
          Answer a read-only Model with all the statements of this Model and any statements "hidden" by reification.
static InfModel ModelFactory.createRDFSModel(Model model)
          Return a Model through which all the RDFS entailments derivable from the given model are accessible.
static InfModel ModelFactory.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 InfModel ModelFactory.createInfModel(Reasoner reasoner, Model model)
          Build an inferred model by attaching the given RDF model to the given reasoner.
static InfModel ModelFactory.createInfModel(Reasoner reasoner, Model schema, Model model)
          Build an inferred model by attaching the given RDF model to the given reasoner.
static OntModel ModelFactory.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 ModelFactory.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.
 Model ModelCon.remove(Model m)
          Remove all the Statements in a given model, including reified statements
 Model ModelCon.remove(Model m, boolean suppressReifications)
          Remove from this model all the statements found in the given model.
 void ModelChangedListener.addedStatements(Model m)
          Method to call when a model has been used to define the statements to be added to our attached model.
 void ModelChangedListener.removedStatements(Model m)
          Method to call when a model has been used to remove statements from our attached model.
 Model Model.add(Model m)
          Add all the statements in another model to this model, including the reified statements.
 Model Model.add(Model m, boolean suppressReifications)
          Add all the statements of the given model m to this model.
 boolean Model.containsAny(Model model)
          Determine if any of the statements in a model are also contained in this model.
 boolean Model.containsAll(Model model)
          Determine if all of the statements in a model are also contained in this model.
 Model Model.union(Model model)
          Create a new model containing all the statements in this model together with all of those in another given model.
 Model Model.intersection(Model model)
          Create a new model containing all the statements which are in both this model and another.
 Model Model.difference(Model model)
          Create a new model containing all the statements in this model which are not in another.
 boolean Model.isIsomorphicWith(Model g)
          Compare this Model with another for equality ignoring the labels on bNodes.
 StmtIterator InfModel.listStatements(Resource subject, Property predicate, RDFNode object, Model posit)
          Find all the statements matching a pattern.
 

Uses of Model in com.hp.hpl.jena.rdf.model.impl
 

Classes in com.hp.hpl.jena.rdf.model.impl that implement Model
 class com.hp.hpl.jena.rdf.model.impl.ModelCom
          Common methods for model implementations.
 

Uses of Model in com.hp.hpl.jena.rdql
 

Methods in com.hp.hpl.jena.rdql that return Model
 Model ResultBinding.mergeTriples(Model model)
          Merge the triples that caused this result binding into a model.
 Model QueryResultsMem.toModel()
          Encode the result set as RDF.
 Model QueryResultsFormatter.toModel()
          Encode the result set as RDF.
 Model Query.getSource()
          Return the model that this query executes against.
 

Methods in com.hp.hpl.jena.rdql with parameters of type Model
 Model ResultBinding.mergeTriples(Model model)
          Merge the triples that caused this result binding into a model.
 Resource QueryResultsMem.asRDF(Model model)
          Encode the result set as RDF in the model provided.
 Resource QueryResultsFormatter.asRDF(Model model)
          Encode the result set as RDF in the model provided.
static QueryResults Query.exec(java.lang.String queryString, Model model)
          Convenience function to parse and execute a query against an existing model.
 void Query.setSource(Model m)
          The data target for the query as a Jena model.
 

Constructors in com.hp.hpl.jena.rdql with parameters of type Model
QueryResultsMem(Model model)
          Prcoess a result set encoded in RDF according to http://jena.hpl.hp.com/2003/03/result-set#
 

Uses of Model in com.hp.hpl.jena.reasoner
 

Methods in com.hp.hpl.jena.reasoner that return Model
 Model ReasonerRegistry.getAllDescriptions()
          Return a composite set of RDF capability descriptions for all registered reasoners.
 Model ReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model Reasoner.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 

Methods in com.hp.hpl.jena.reasoner with parameters of type Model
 Reasoner Reasoner.bindSchema(Model tbox)
          This is most commonly used to attach an ontology (a set of tbox axioms in description logics jargon) to a reasoner.
 void Reasoner.addDescription(Model configSpec, Resource base)
          Add a configuration description for this reasoner into a partial configuration specification model.
 

Uses of Model in com.hp.hpl.jena.reasoner.rulesys
 

Methods in com.hp.hpl.jena.reasoner.rulesys that return Model
 Model RDFSRuleReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model RDFSFBRuleReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model OWLFBRuleReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model LPBackwardRuleReasoner.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model GenericRuleReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model FBRuleReasoner.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model DAMLMicroReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model BasicForwardRuleReasoner.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 

Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type Model
 void LPBackwardRuleReasoner.addDescription(Model configSpec, Resource base)
          Add a configuration description for this reasoner into a partial configuration specification model.
 Reasoner LPBackwardRuleReasoner.bindSchema(Model tbox)
          Precompute the implications of a schema Model.
 void FBRuleReasoner.addDescription(Model configSpec, Resource base)
          Add a configuration description for this reasoner into a partial configuration specification model.
 Reasoner FBRuleReasoner.bindSchema(Model tbox)
          Precompute the implications of a schema Model.
 void BasicForwardRuleReasoner.addDescription(Model configSpec, Resource base)
          Add a configuration description for this reasoner into a partial configuration specification model.
 Reasoner BasicForwardRuleReasoner.bindSchema(Model tbox)
          Precompute the implications of a schema Model.
 

Uses of Model in com.hp.hpl.jena.reasoner.transitiveReasoner
 

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner that return Model
 Model TransitiveReasonerFactory.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 Model TransitiveReasoner.getCapabilities()
          Return a description of the capabilities of this reasoner encoded in RDF.
 

Methods in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Model
 void TransitiveReasoner.addDescription(Model configSpec, Resource base)
          Add a configuration description for this reasoner into a partial configuration specification model.
 Reasoner TransitiveReasoner.bindSchema(Model tbox)
          Extracts all of the subClass and subProperty declarations from the given schema/tbox and caches the resultant graphs.
 

Uses of Model in com.hp.hpl.jena.shared
 

Methods in com.hp.hpl.jena.shared that return Model
static Model RandomOrderGraph.createDefaultModel()
           
 

Constructors in com.hp.hpl.jena.shared with parameters of type Model
BadDescriptionException(java.lang.String message, Model badModel)
           
 

Uses of Model in com.hp.hpl.jena.util
 

Methods in com.hp.hpl.jena.util that return Model
 Model TestManifestList.getModel()
           
static Model ResourceUtils.reachableClosure(Resource root)
          Answer a model that contains all of the resources reachable from a given resource by any property, transitively.
static Model ModelLoader.loadModel(java.lang.String urlStr)
          Load a model
static Model ModelLoader.loadModel(java.lang.String urlStr, java.lang.String lang)
          Load a model or attached a persistent store (but not a database).
static Model ModelLoader.loadModel(java.lang.String urlStr, java.lang.String lang, java.lang.String dbUser, java.lang.String dbPassword, java.lang.String modelName, java.lang.String dbType, java.lang.String driver)
          Load a model or attached a persistent store.
static Model ModelLoader.loadModel(Model model, java.lang.String urlStr, java.lang.String lang)
          Load a model from a file into a model.
static Model ModelLoader.connectToDB(java.lang.String urlStr, java.lang.String dbUser, java.lang.String dbPassword, java.lang.String modelName, java.lang.String dbType, java.lang.String driverName)
          Connect to a database.
 

Methods in com.hp.hpl.jena.util with parameters of type Model
 Graph QueryMapper.toQueryGraph(Model m)
           
static ExtendedIterator ModelQueryUtil.queryBindingsWith(com.hp.hpl.jena.rdf.model.impl.ModelCom model, Model query, Resource[] variables)
           
static Model ModelLoader.loadModel(Model model, java.lang.String urlStr, java.lang.String lang)
          Load a model from a file into a model.
 

Constructors in com.hp.hpl.jena.util with parameters of type Model
TestManifestList(Model m)
           
QueryMapper(Model m, Resource[] variables)
           
 

Uses of Model in com.hp.hpl.jena.vocabulary
 

Fields in com.hp.hpl.jena.vocabulary declared as Model
static Model JMS.schema
          The JMS schema encoded into a model.
 



Copyright © 2000-2003 Hewlett-Packard. All Rights Reserved.