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.reasoner
Class ReasonerRegistry

    java.lang.Object
      com.hp.hpl.jena.reasoner.ReasonerRegistry

    public class ReasonerRegistry

extends java.lang.Object

A global registry of known reasoner modules. Modules are identified by a URI and can have associated capability and descriptive information, in RDF. Currently the schema/ontology for such descriptions is mostly open. However, we do ensure that each reasoner URI at least has an associated rdf:type statement to indicate that it is a reasoner.

It is up to each reasoner or some associated configuration system to register it in this registry.

Version:
  $Revision: 1.31 $ on $Date: 2008/01/21 14:54:20 $
Author:
  Dave Reynolds

Method Summary
`Reasoner` | `create(java.lang.String uri, Resource configuration)` Create and return a new instance of the reasoner identified by the given uri.
`Model` | `getAllDescriptions()` Return a composite set of RDF capability descriptions for all registered reasoners.
`Resource` | `getDescription(java.lang.String uri)` Return information on a given Reasoner.
`static DIGReasoner` | `getDIGReasoner()` Create a DIG reasoner for the specified language for the OWL language, with default settings (including the default URL for the DIG reasoner), and no axioms specified.
`static DIGReasoner` | `getDIGReasoner(Resource lang, boolean withAxioms, Resource config)` Create a DIG reasoner for the specified language (DAML or OWL), optionally with axioms that specify e.g. the types of OWL objects etc.
`static DIGReasoner` | `getDIGReasoner(Resource lang, Resource config)` Create a DIG reasoner for the specified language (DAML or OWL), without type axioms.
`ReasonerFactory` | `getFactory(java.lang.String uri)` Return the factory for the given reasoner.
`static Reasoner` | `getOWLMicroReasoner()` Prebuilt standard configuration a micro-OWL reasoner.
`static Reasoner` | `getOWLMiniReasoner()` Prebuilt mini configuration for the default OWL reasoner.
`static Reasoner` | `getOWLReasoner()` Prebuilt standard configuration for the default OWL reasoner.
`static Reasoner` | `getRDFSReasoner()` Return a prebuilt standard configuration for the default RDFS reasoner
`static Reasoner` | `getRDFSSimpleReasoner()` Return a prebuilt simplified configuration for the default RDFS reasoner
`static Reasoner` | `getTransitiveReasoner()` Return a prebuilt standard configuration for the default subclass/subproperty transitive closure reasoner.
`static Node` | `makeDirect(Node node)` Return a property Node which represents the direct version of a transitively closed property.
`static java.lang.String` | `makeDirect(java.lang.String uri)` Return a URI string which represents the direct version of a transitively closed property URI Not clear what the right thing to do here is.
`void` | `register(ReasonerFactory factory)` Register a Reasoner.
`void` | `register(java.lang.String reasonerUri, ReasonerFactory factory)` Register a Reasoner - simple case with no RDF description.
`static ReasonerRegistry` | `theRegistry()` Return the single global instance of the registry

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

Method Detail

### theRegistry

    public static ReasonerRegistry theRegistry()

  Return the single global instance of the registry

### register

    public void register(ReasonerFactory factory)

  Register a Reasoner.

  Parameters:
    `factory` - an factory that can be used to create instances of the reasoner

### register

    public void register(java.lang.String reasonerUri,
                         ReasonerFactory factory)

  Register a Reasoner - simple case with no RDF description.

  Parameters:
    `factory` - an factory that can be used to create instances of the reasoner
    `reasonerUri` - the URI used to label the reasoner, expressed as a simple string

### getAllDescriptions

    public Model getAllDescriptions()

  Return a composite set of RDF capability descriptions for all registered reasoners. Listing all Resources of type ReasonerClass in the returned model would enumerate all registered reasoners.

### getDescription

    public Resource getDescription(java.lang.String uri)

  Return information on a given Reasoner.

  Parameters:
    `uri` - the URI of the reasoner
  Returns:
    a Resource representing the reasoner whose properties (as obtainable through listProperties etc) give a capability description of the reasoner; returns null if no such reasoner is registered.

### getFactory

    public ReasonerFactory getFactory(java.lang.String uri)

  Return the factory for the given reasoner.

  Parameters:
    `uri` - the URI of the reasoner
  Returns:
    the ReasonerFactory instance for this reasoner

### create

    public Reasoner create(java.lang.String uri,
                           Resource configuration)
                    throws ReasonerException

  Create and return a new instance of the reasoner identified by the given uri.

  Parameters:
    `uri` - the uri of the reasoner to be created, expressed as a simple string
    `configuration` - an optional set of configuration information encoded in RDF this parameter can be null if no configuration information is required.
  Returns:
    a reaoner instance
  Throws:
    `ReasonerException` - if there is not such reasoner or if there is some problem during instantiation

### makeDirect

    public static Node makeDirect(Node node)

  Return a property Node which represents the direct version of a transitively closed property. See `makeDirect(String)`; this method makes a new Node with the direct respelling of `node`s URI.

### makeDirect

    public static java.lang.String makeDirect(java.lang.String uri)

  Return a URI string which represents the direct version of a transitively closed property URI

  Not clear what the right thing to do here is. Should not just invent a new local name in the same namespace because that might be a controlled namespace like RDF or RDFS. Can't even just extend the namespace slightly because that would be violating the web principles of namespace ownership. On the other hand, this solution results in staggeringly clumsy names.

  Parameters:
    `uri` - the URI representing the transitive property

### getRDFSReasoner

    public static Reasoner getRDFSReasoner()

  Return a prebuilt standard configuration for the default RDFS reasoner

### getRDFSSimpleReasoner

    public static Reasoner getRDFSSimpleReasoner()

  Return a prebuilt simplified configuration for the default RDFS reasoner

### getTransitiveReasoner

    public static Reasoner getTransitiveReasoner()

  Return a prebuilt standard configuration for the default subclass/subproperty transitive closure reasoner.

### getOWLReasoner

    public static Reasoner getOWLReasoner()

  Prebuilt standard configuration for the default OWL reasoner. This configuration is hybrid forward/backward reasoner.

### getOWLMicroReasoner

    public static Reasoner getOWLMicroReasoner()

  Prebuilt standard configuration a micro-OWL reasoner. This just supports property axioms, and class inheritance sufficient to power the OntAPI.

### getOWLMiniReasoner

    public static Reasoner getOWLMiniReasoner()

  Prebuilt mini configuration for the default OWL reasoner. This omits bNode introduction rules which has significant performance gain in some cases and avoids breaking the find contract.

### getDIGReasoner

    public static DIGReasoner getDIGReasoner()

  Create a DIG reasoner for the specified language for the OWL language, with default settings (including the default URL for the DIG reasoner), and no axioms specified.

  Returns:
    A new DIG reasoner

### getDIGReasoner

    public static DIGReasoner getDIGReasoner(Resource lang,
                                             Resource config)

  Create a DIG reasoner for the specified language (DAML or OWL), without type axioms.

  Parameters:
    `lang` - The ontology language, OWL or DAML, as a resource
    `config` - Optional configuration root resource, or null
  Returns:
    A new DIG reasoner

### getDIGReasoner

    public static DIGReasoner getDIGReasoner(Resource lang,
                                             boolean withAxioms,
                                             Resource config)

  Create a DIG reasoner for the specified language (DAML or OWL), optionally with axioms that specify e.g. the types of OWL objects etc.

  Parameters:
    `lang` - The ontology language, OWL or DAML, as a resource
    `withAxioms` - If true, include the type axioms for the language
    `config` - Optional configuration root resource, or null
  Returns:
    A new DIG reasoner

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