|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |