| java.lang.Object com.hp.hpl.jena.ontology.OntModelSpec
OntModelSpec | public class OntModelSpec (Code) | |
Encapsulates a description of the components of an ontology model, including the
storage scheme, reasoner and language profile.
author: Ian Dickinson, HP Labs author: (email) version: CVS $Id: OntModelSpec.java,v 1.54 2008/01/15 08:19:17 chris-dollin Exp $ |
Constructor Summary | |
public | OntModelSpec(ModelMaker importsMaker, OntDocumentManager docMgr, ReasonerFactory rFactory, String languageURI) Construct a new ontology model specification with the given specification parameters
Parameters: importsMaker - The model maker, which will be used to construct stores for statements in theimported ontologies and the base ontology. | public | OntModelSpec(ModelMaker baseMaker, ModelMaker importsMaker, OntDocumentManager docMgr, ReasonerFactory rFactory, String languageURI) Construct a new ontology model specification from the supplied components. | public | OntModelSpec(String baseModelName, ModelMaker baseMaker, ModelMaker importsMaker, OntDocumentManager docMgr, ReasonerFactory rFactory, String languageURI) Construct a new ontology model specification from the supplied components. | public | OntModelSpec(OntModelSpec spec) Create one model spec as a copy of another. |
DAML_MEM | final public static OntModelSpec DAML_MEM(Code) | | A specification for DAML models that are stored in memory and do no additional entailment reasoning
|
DAML_MEM_RDFS_INF | final public static OntModelSpec DAML_MEM_RDFS_INF(Code) | | A specification for DAML models that are stored in memory and use the RDFS inferencer for additional entailments
|
DAML_MEM_RULE_INF | final public static OntModelSpec DAML_MEM_RULE_INF(Code) | | A specification for DAML models that are stored in memory and use a subset of the DAML semantic model additional entailments
|
DAML_MEM_TRANS_INF | final public static OntModelSpec DAML_MEM_TRANS_INF(Code) | | A specification for DAML models that are stored in memory and use the transitive reasoner for entailments
|
OWL_DL_MEM | final public static OntModelSpec OWL_DL_MEM(Code) | | A specification for OWL DL models that are stored in memory and do no additional entailment reasoning
|
OWL_DL_MEM_RDFS_INF | final public static OntModelSpec OWL_DL_MEM_RDFS_INF(Code) | | A specification for OWL DL models that are stored in memory and use the RDFS inferencer for additional entailments
|
OWL_DL_MEM_RULE_INF | final public static OntModelSpec OWL_DL_MEM_RULE_INF(Code) | | A specification for OWL DL models that are stored in memory and use the OWL rules inference engine for additional entailments
|
OWL_DL_MEM_TRANS_INF | final public static OntModelSpec OWL_DL_MEM_TRANS_INF(Code) | | A specification for OWL DL models that are stored in memory and use the transitive inferencer for additional entailments
|
OWL_LITE_MEM | final public static OntModelSpec OWL_LITE_MEM(Code) | | A specification for OWL Lite models that are stored in memory and do no entailment additional reasoning
|
OWL_LITE_MEM_RDFS_INF | final public static OntModelSpec OWL_LITE_MEM_RDFS_INF(Code) | | A specification for OWL Lite models that are stored in memory and use the RDFS inferencer for additional entailments
|
OWL_LITE_MEM_RULES_INF | final public static OntModelSpec OWL_LITE_MEM_RULES_INF(Code) | | A specification for OWL Lite models that are stored in memory and use the OWL rules inference engine for additional entailments
|
OWL_LITE_MEM_TRANS_INF | final public static OntModelSpec OWL_LITE_MEM_TRANS_INF(Code) | | A specification for OWL Lite models that are stored in memory and use the transitive inferencer for additional entailments
|
OWL_MEM | final public static OntModelSpec OWL_MEM(Code) | | A specification for OWL models that are stored in memory and do no additional entailment reasoning
|
OWL_MEM_MICRO_RULE_INF | final public static OntModelSpec OWL_MEM_MICRO_RULE_INF(Code) | | A specification for OWL models that are stored in memory and use the micro OWL rules inference engine for additional entailments
|
OWL_MEM_MINI_RULE_INF | final public static OntModelSpec OWL_MEM_MINI_RULE_INF(Code) | | A specification for OWL models that are stored in memory and use the mini OWL rules inference engine for additional entailments
|
OWL_MEM_RDFS_INF | final public static OntModelSpec OWL_MEM_RDFS_INF(Code) | | A specification for OWL models that are stored in memory and use the RDFS inferencer for additional entailments
|
OWL_MEM_RULE_INF | final public static OntModelSpec OWL_MEM_RULE_INF(Code) | | A specification for OWL models that are stored in memory and use the OWL rules inference engine for additional entailments
|
OWL_MEM_TRANS_INF | final public static OntModelSpec OWL_MEM_TRANS_INF(Code) | | A specification for OWL models that are stored in memory and use the transitive inferencer for additional entailments
|
RDFS_MEM | final public static OntModelSpec RDFS_MEM(Code) | | A specification for RDFS ontology models that are stored in memory and do no additional entailment reasoning
|
RDFS_MEM_RDFS_INF | final public static OntModelSpec RDFS_MEM_RDFS_INF(Code) | | A specification for RDFS ontology models that are stored in memory and use the RDFS inferencer for additional entailments
|
RDFS_MEM_TRANS_INF | final public static OntModelSpec RDFS_MEM_TRANS_INF(Code) | | A specification for RDFS ontology models that are stored in memory and use the transitive reasoner for entailments
|
importModelGetter | protected ModelGetter importModelGetter(Code) | | the ModelGetter which will be used - eventually - for imports
|
m_baseModelName | protected String m_baseModelName(Code) | | the name of the base model in the baseModelMaker, if specified
|
m_importsMaker | protected ModelMaker m_importsMaker(Code) | | The ModelMaker used for creating imported models
|
m_languageURI | protected String m_languageURI(Code) | | The language URI for the ontology
|
m_profile | protected Profile m_profile(Code) | | The ontology language profile
|
m_rFactory | protected ReasonerFactory m_rFactory(Code) | | The reasoner factory for creating the reasoner on demand
|
m_reasoner | protected Reasoner m_reasoner(Code) | | The specification reasoner
|
OntModelSpec | public OntModelSpec(ModelMaker importsMaker, OntDocumentManager docMgr, ReasonerFactory rFactory, String languageURI)(Code) | | Construct a new ontology model specification with the given specification parameters
Parameters: importsMaker - The model maker, which will be used to construct stores for statements in theimported ontologies and the base ontology. Use null to get a default (memory) model maker. Parameters: docMgr - The document manager, or null for the default document manager. Parameters: rFactory - The factory for the reasoner to use to infer additional triples in the model, or null for no reasoner Parameters: languageURI - The URI of the ontology language. Required. |
OntModelSpec | public OntModelSpec(ModelMaker baseMaker, ModelMaker importsMaker, OntDocumentManager docMgr, ReasonerFactory rFactory, String languageURI)(Code) | | Construct a new ontology model specification from the supplied components.
Parameters: baseMaker - the model-maker to use for the base model Parameters: importsMaker - the model-maker to use for imported models Parameters: docMgr - the document manager (null for the default manager) Parameters: rFactory - the reasoner (null for no reasoner) Parameters: languageURI - the ontology language URI (must not be null) |
OntModelSpec | public OntModelSpec(String baseModelName, ModelMaker baseMaker, ModelMaker importsMaker, OntDocumentManager docMgr, ReasonerFactory rFactory, String languageURI)(Code) | | Construct a new ontology model specification from the supplied components.
Parameters: baseModelName - the name of the model in the baseModelMaker Parameters: baseMaker - the model-maker to use for the base model Parameters: importsMaker - the model-maker to use for imported models Parameters: docMgr - the document manager (null for the default manager) Parameters: rFactory - the reasoner (null for no reasoner) Parameters: languageURI - the ontology language URI (must not be null) |
OntModelSpec | public OntModelSpec(OntModelSpec spec)(Code) | | Create one model spec as a copy of another. This is useful when what is required is similar to
an existing spec, but with some changes. Note: this is only a shallow copy, so the
structured objects (reasoners, document managers, etc) are not themselves copied. Thus, even after
calling this copy constructor, making a change to the document manager in the copy specification
will also affect the one that the copy was made from. The correct idiom is to replace the object
before side-effecting it, e.g:
OntModelSpec newSpec = new OntModelSpec( existingSpec );
newSpec.setDocumentManager( new OntDocumentManager() );
newSpec.getDocumentManager().setMetaDataSearchPath( "..." );
Parameters: spec - |
assemble | public static OntModelSpec assemble(Resource root)(Code) | | Answer the OntModelSpec described using the Jena Assembler vocabulary
properties of root . If the assembled resource is not
an OntModelSpec, throw an exception reporting the constructed class.
|
assemble | public static OntModelSpec assemble(Model model)(Code) | | Answer the OntModelSpec described using the Jena Assembler vocabulary
properties of the single resource in model of type
JA:OntModelSpec.
|
createBaseModel | public Model createBaseModel()(Code) | | Answer a base model constructed according to this specification. This is used for the
"base" (i.e. non-imported) model for an OntModel.
|
doCreateModel | public Model doCreateModel()(Code) | | Create an OntModel according to this model specification.
The base model comes from the attached base ModelMaker.
an OntModel satisfying this specification |
getBaseModelMaker | public ModelMaker getBaseModelMaker()(Code) | | Answer the model maker used for creating base models.
|
getDefaultSpec | public static OntModelSpec getDefaultSpec(String languageURI)(Code) | | Answer a default specification for the given language URI. This default
will typically use a memory model and have minimal inferencing capabilities.
Specifically, OWL and RDFS languages will have RDFS level inferencing
capability (chosen to give a reasonable balance between power and efficiency
of computation), and DAML language will have the minimal DAML rule reasoner.
To get other (more powerful or less powerful) reasoning capabilities, users
should create ontology models by passing an explicit OntModelSpec
parameter to the
ModelFactory.createOntologyModel(OntModelSpecModel) model factory .
Parameters: languageURI - The ontology language we want a default model spec for The default model spec for that language exception: OntologyException - if the URI is not a recognised name of an ontology language |
getDocumentManager | public OntDocumentManager getDocumentManager()(Code) | | Answer the document manager for this model specification. Defaults to
a standard instance of
OntDocumentManager
The document manager to be used by models matching this specification |
getImportModelMaker | public ModelMaker getImportModelMaker()(Code) | | Answer the model maker used for creating imported models.
The ModelMaker that is used to get or create a model usedto hold imports to an OntModel. |
getLanguage | public String getLanguage()(Code) | | Answer the URI of the ontology language to use when constructing
models from this specification. Well known language URI's are
available from the
ProfileRegistry
The ontology language URI |
getProfile | public Profile getProfile()(Code) | | Answer the language profile for this ontology specification
An ontology language profile object |
getReasoner | public Reasoner getReasoner()(Code) | | Answer the reasoner that will be used to infer additional entailed
triples in the ontology model.
The reasoner for this specification |
getReasonerFactory | public ReasonerFactory getReasonerFactory()(Code) | | Answer the current reasoner factory
The reasoner factory, or null. |
implementCreateModelOver | public Model implementCreateModelOver(String name)(Code) | | Create an OntModel according to this model specification.
The base model comes from the underlying ModelMaker and is named by the
given name.
|
setBaseModelMaker | public void setBaseModelMaker(ModelMaker m)(Code) | | Set the model maker used for base models.
Parameters: m - The model maker that is used to create the base modelif one is not supplied when a model is created. |
setDocumentManager | public void setDocumentManager(OntDocumentManager docMgr)(Code) | | Set the document manager in this specification
Parameters: docMgr - The new document manager |
setImportModelMaker | public void setImportModelMaker(ModelMaker maker)(Code) | | Set the model maker that will be used when the ontology model needs to create
an additional container for an imported ontology
Parameters: maker - The new model maker to use |
setLanguage | public void setLanguage(String languageURI)(Code) | | Set the URI of the ontology to use for models that conform to
this specification.
Parameters: languageURI - The new language URI exception: OntologyException - if the URI does not map to a known language profile |
setReasoner | public void setReasoner(Reasoner reasoner)(Code) | | Set the reasoner that will be used by ontology models that conform
to this specification to compute entailments.
Note: The reasoner is generated on demand by the reasoner
factory. To prevent this spec from having a reasoner, set the reasoner factory
to null, see
OntModelSpec.setReasonerFactory .
Parameters: reasoner - The new reasoner |
setReasonerFactory | public void setReasonerFactory(ReasonerFactory rFactory)(Code) | | Set the factory object that will be used to generate the reasoner object
for this model specification. Note that the reasoner itself is cached, so setting
the factory after a call to
OntModelSpec.getReasoner() will have no effect.
Parameters: rFactory - The new reasoner factory, or null to prevent any reasoner being used |
|
|