| java.lang.Object
 com.hp.hpl.jena.reasoner.rulesys.Rule
| Rule | | public class Rule implements ClauseEntry(Code) | | Representation of a generic inference rule.
This represents the rule specification but most engines will
compile this specification into an abstract machine or processing
graph.
The rule specification comprises a list of antecendents (body) and a list
of consequents (head). If there is more than one consequent then a backchainer
should regard this as a shorthand for several rules, all with the
same body but with a singleton head.
Each element in the head or body can be a TriplePattern, a Functor or a Rule.
A TriplePattern is just a triple of Nodes but the Nodes can represent
variables, wildcards and embedded functors - as well as constant uri or
literal graph nodes. A functor comprises a functor name and a list of
arguments. The arguments are Nodes of any type except functor nodes
(there is no functor nesting). The functor name can be mapped into a registered
java class that implements its semantics. Functors play three roles -
in heads they represent actions (procedural attachement); in bodies they
represent builtin predicates; in TriplePatterns they represent embedded
structured literals that are used to cache matched subgraphs such as
restriction specifications.
The equality contract for rules is that two rules are equal if each of terms
(ClauseEntry objects) are equals and they have the same name, if any.
We include a trivial, recursive descent parser but this is just there
to allow rules to be embedded in code. External rule syntax based on N3
and RDF could be developed. The embedded syntax supports rules such as:
[ (?C rdf:type *), guard(?C, ?P) -> (?c rb:restriction some(?P, ?D)) ].
[ (?s owl:foo ?p) -> [ (?s owl:bar ?a) -> (?s ?p ?a) ] ].
[name: (?s owl:foo ?p) -> (?s ?p ?a)].
only built in namespaces are recognized as such, * is a wildcard node, ?c is a variable,
name(node ... node) is a functor, (node node node) is a triple pattern, [..] is an
embedded rule, commas are ignore and can be freely used as separators. Functor names
may not end in ':'.
author:
Dave Reynolds * @version $Revision: 1.48 $ on $Date: 2008/01/02 12:07:47 $ |
| Inner Class :public static class Parser | |
| Inner Class :public static class ParserException extends JenaException | |
| isBackward | | protected boolean isBackward(Code) | | Flags whether the rule was written as a forward or backward rule
|
| isMonotonic | | protected boolean isMonotonic(Code) | | Flags whether the rule is monotonic
|
| numVars | | protected int numVars(Code) | | The number of distinct variables used in the rule
|
| Rule | | public Rule(List head, List body)(Code) | | Constructor
Parameters:
body - a list of TriplePatterns or Functors.
Parameters:
head - a list of TriplePatterns, Functors or rules |
| Rule | | public Rule(String name, List head, List body)(Code) | | Constructor
Parameters:
name - a label for rule
Parameters:
body - a list of TriplePatterns or Functors.
Parameters:
head - a list of TriplePatterns, Functors or rules |
| Rule | | public Rule(String name, ClauseEntry[] head, ClauseEntry[] body)(Code) | | Constructor
Parameters:
name - a label for rule
Parameters:
body - an array of TriplePatterns or Functors.
Parameters:
head - an array of TriplePatterns, Functors or rules |
| bodyLength | | public int bodyLength()(Code) | | Return the number of body elements
|
| cloneRule | | public Rule cloneRule()(Code) | | Clone a rule, cloning any embedded variables.
|
| equals | | public boolean equals(Object o)(Code) | | Equality override
|
| getBody | | public ClauseEntry[] getBody()(Code) | | return the entire rule body as an array of objects
|
| getBodyElement | | public ClauseEntry getBodyElement(int n)(Code) | | Return the n'th body element
|
| getHead | | public ClauseEntry[] getHead()(Code) | | return the entire rule head as an array of objects
|
| getHeadElement | | public ClauseEntry getHeadElement(int n)(Code) | | Return the n'th head element
|
| getName | | public String getName()(Code) | | Get the name for the rule - can be null.
|
| getNumVars | | public int getNumVars()(Code) | | Return the number of distinct variables in the rule. Or more precisely, the
size of a binding environment needed to represent the rule.
|
| hashCode | | public int hashCode()(Code) | | hash function override
|
| headLength | | public int headLength()(Code) | | Return the number of head elements
|
| instantiate | | public Rule instantiate(BindingEnvironment env)(Code) | | Instantiate a rule given a variable binding environment.
This will clone any non-bound variables though that is only needed
for trail implementations.
|
| isAxiom | | public boolean isAxiom()(Code) | | Returns true if the rule does not depend on any data, and so should
be treated as an axiom.
|
| isBackward | | public boolean isBackward()(Code) | | Return true if the rule was written as a backward (as opposed to forward) rule.
|
| isMonotonic | | public boolean isMonotonic()(Code) | | Returns false for rules which can affect other rules non-monotonically (remove builtin
or similar) or are affected non-monotonically (involve negation-as-failure).
|
| parseRule | | public static Rule parseRule(String source) throws ParserException(Code) | | Parse a string as a rule.
throws:
ParserException - if there is a problem |
| parseRules | | public static List parseRules(Parser parser) throws ParserException(Code) | | Run a pre-bound rule parser to extract it's rules
a list of rules
throws:
ParserException - if there is a problem |
| parseRules | | public static List parseRules(String source) throws ParserException(Code) | | Parse a string as a list a rules.
a list of rules
throws:
ParserException - if there is a problem |
| rulesParserFromReader | | public static Parser rulesParserFromReader(BufferedReader src)(Code) | | Processes the source reader stripping off comment lines and noting prefix
definitions (@prefix) and rule inclusion commands (@include).
Returns a parser which is bound to the stripped source text with
associated prefix and rule inclusion definitions.
|
| rulesStringFromReader | | public static String rulesStringFromReader(BufferedReader src)(Code) | | Answer a String which is the concatenation (with newline glue) of all the
non-comment lines readable from src. A comment line is
one starting "#" or "//".
|
| sameAs | | public boolean sameAs(Object o)(Code) | | Compare clause entries, taking into account variable indices.
The equality function ignores differences between variables.
|
| setBackward | | public void setBackward(boolean flag)(Code) | | Set the rule to be run backwards.
Parameters:
flag - if true the rule should run backwards. |
| setNumVars | | public void setNumVars(int n)(Code) | | Set the number of distinct variables for this rule.
Used internally when cloing rules, not normally required.
|
| toShortString | | public String toShortString()(Code) | | Print a short description of the rule, just its name if it
has one, otherwise the whole rule description.
|
| toString | | public String toString()(Code) | | Printable string describing the rule
|
|
|