| com.hp.hpl.jena.reasoner.BaseInfGraph
 com.hp.hpl.jena.reasoner.rulesys.BasicForwardRuleInfGraph
com.hp.hpl.jena.reasoner.rulesys.impl.oldCode.OrigFBRuleInfGraph
| OrigFBRuleInfGraph | | public class OrigFBRuleInfGraph extends BasicForwardRuleInfGraph implements BackwardRuleInfGraphI(Code) | | An inference graph that uses a mixture of forward and backward
chaining rules. The forward rules can create direct deductions from
the source data and schema and can also create backward rules. A
query is answered by consulting the union of the raw data, the forward
derived results and any relevant backward rules (whose answers are tabled
for future reference).
author:
Dave Reynolds
version:
$Revision: 1.10 $ on $Date: 2008/01/02 12:09:44 $ |
| Inner Class :public static class RuleStore | |
| Method Summary | |
| public void | addBRule(Rule brule)
Adds a new Backward rule as a rusult of a forward rule process. | | public void | addBRules(List rules)
| | public void | addDeduction(Triple t)
Add a new deduction to the deductions graph. | | public void | addPreprocessingHook(RulePreprocessHook hook)
Add a new preprocessing hook defining an operation that
should be run when the preparation phase is underway. | | public void | addRuleDuringPrepare(Rule rule)
Add a new rule to the rule set. | | public InfGraph | cloneWithPremises(Graph premises)
Return a new inference graph which is a clone of the current graph
together with an additional set of data premises. | | public void | deleteBRule(Rule brule)
Deletes a new Backward rule as a rules of a forward rule process. | | public ExtendedIterator | find(TriplePattern pattern)
Basic pattern lookup interface. | | public ExtendedIterator | findDataMatches(Node subject, Node predicate, Node object)
Search the combination of data and deductions graphs for the given triple pattern. | | public ExtendedIterator | findDataMatches(TriplePattern pattern)
Search the combination of data and deductions graphs for the given triple pattern. | | public ExtendedIterator | findWithContinuation(TriplePattern pattern, Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query. | | public List | getBRules()
Return an ordered list of all registered backward rules. | | public long | getNRulesFired()
| | public List | getRules()
Return the originally supplied set of rules, may be a mix of forward
and backward rules. | | public Node | getTemp(Node instance, Node prop, Node pclass)
Retrieve or create a bNode representing an inferred property value.
Parameters:
instance - the base instance node to which the property applies
Parameters:
prop - the property node whose value is being inferred
Parameters:
pclass - the (optional, can be null) class for the inferred value. | | public ExtendedIterator | graphBaseFind(Node subject, Node property, Node object)
Returns an iterator over Triples. | | protected void | instantiateRuleEngine(List rules)
Instantiate the forward rule engine to use. | | public synchronized void | performAdd(Triple t)
Add one triple to the data graph, run any rules triggered by
the new data item, recursively adding any generated triples. | | public void | performDelete(Triple t)
Removes the triple t (if possible) from the set belonging to this graph. | | protected boolean | preloadDeductions(Graph preloadIn)
Adds a set of precomputed triples to the deductions store. | | public void | prepare()
Perform any initial processing and caching. | | public boolean | processBuiltin(ClauseEntry clause, Rule rule, BindingEnvironment env)
| | public void | rebind()
Cause the inference graph to reconsult the underlying graph to take
into account changes. | | public void | reset()
Flush out all cached results. | | public void | setDerivationLogging(boolean recordDerivations)
| | public void | setTraceOn(boolean state)
Set the state of the trace flag. | | public void | setUseTGCCache()
Instantiate the optional caches for the subclass/suproperty lattices. |
| bEngine | | protected BRuleEngine bEngine(Code) | | The core backward rule engine which includes all the memoized results
|
| context | | protected BBRuleContext context(Code) | | Single context for the reasoner, used when passing information to builtins
|
| dataFind | | protected Finder dataFind(Code) | | A finder that searches across the data, schema, axioms and forward deductions
|
| preprocessorHooks | | protected List preprocessorHooks(Code) | | Optional list of preprocessing hooks to be run in sequence during preparation time
|
| rawRules | | protected List rawRules(Code) | | The original rule set as supplied
|
| rules | | protected List rules(Code) | | The rule list after possible extension by preprocessing hooks
|
| tempNodecache | | protected TempNodeCache tempNodecache(Code) | | Cache of temporary property values inferred through getTemp calls
|
| transitiveEngine | | protected TransitiveEngine transitiveEngine(Code) | | Optional precomputed cache of the subClass/subproperty lattices
|
| useRETE | | public static boolean useRETE(Code) | | Static switch from Basic to RETE implementation of the forward component
|
| useTGCCaching | | protected boolean useTGCCaching(Code) | | Flag, if true then subClass and subProperty lattices will be optimized using TGCs
|
| OrigFBRuleInfGraph | | public OrigFBRuleInfGraph(Reasoner reasoner, Graph schema)(Code) | | Constructor.
Parameters:
reasoner - the reasoner which created this inf graph instance
Parameters:
schema - the (optional) schema graph to be included |
| OrigFBRuleInfGraph | | public OrigFBRuleInfGraph(Reasoner reasoner, List rules, Graph schema)(Code) | | Constructor.
Parameters:
reasoner - the reasoner which created this inf graph instance
Parameters:
rules - the rules to process
Parameters:
schema - the (optional) schema graph to be included |
| OrigFBRuleInfGraph | | public OrigFBRuleInfGraph(Reasoner reasoner, List rules, Graph schema, Graph data)(Code) | | Constructor.
Parameters:
reasoner - the reasoner which created this inf graph instance
Parameters:
rules - the rules to process
Parameters:
schema - the (optional) schema graph to be included
Parameters:
data - the data graph to be processed |
| addBRule | | public void addBRule(Rule brule)(Code) | | Adds a new Backward rule as a rusult of a forward rule process. Only some
infgraphs support this.
|
| addBRules | | public void addBRules(List rules)(Code) | | Adds a set of new Backward rules
|
| addDeduction | | public void addDeduction(Triple t)(Code) | | Add a new deduction to the deductions graph.
|
| addPreprocessingHook | | public void addPreprocessingHook(RulePreprocessHook hook)(Code) | | Add a new preprocessing hook defining an operation that
should be run when the preparation phase is underway.
|
| addRuleDuringPrepare | | public void addRuleDuringPrepare(Rule rule)(Code) | | Add a new rule to the rule set. This should only be used by implementations
of RuleProprocessHook (which are called during rule system preparation phase).
If called at other times the rule won't be correctly transferred into the
underlying engines.
|
| cloneWithPremises | | public InfGraph cloneWithPremises(Graph premises)(Code) | | Return a new inference graph which is a clone of the current graph
together with an additional set of data premises. Attempts to the replace
the default brute force implementation by one that can reuse some of the
existing deductions.
|
| deleteBRule | | public void deleteBRule(Rule brule)(Code) | | Deletes a new Backward rule as a rules of a forward rule process. Only some
infgraphs support this.
|
| find | | public ExtendedIterator find(TriplePattern pattern)(Code) | | Basic pattern lookup interface.
This implementation assumes that the underlying findWithContinuation
will have also consulted the raw data.
Parameters:
pattern - a TriplePattern to be matched against the data a ExtendedIterator over all Triples in the data setthat match the pattern |
| findDataMatches | | public ExtendedIterator findDataMatches(Node subject, Node predicate, Node object)(Code) | | Search the combination of data and deductions graphs for the given triple pattern.
This may different from the normal find operation in the base of hybrid reasoners
where we are side-stepping the backward deduction step.
|
| findDataMatches | | public ExtendedIterator findDataMatches(TriplePattern pattern)(Code) | | Search the combination of data and deductions graphs for the given triple pattern.
This may different from the normal find operation in the base of hybrid reasoners
where we are side-stepping the backward deduction step.
|
| findWithContinuation | | public ExtendedIterator findWithContinuation(TriplePattern pattern, Finder continuation)(Code) | | Extended find interface used in situations where the implementator
may or may not be able to answer the complete query. It will
attempt to answer the pattern but if its answers are not known
to be complete then it will also pass the request on to the nested
Finder to append more results.
Parameters:
pattern - a TriplePattern to be matched against the data
Parameters:
continuation - either a Finder or a normal Graph whichwill be asked for additional match results if the implementormay not have completely satisfied the query. |
| getBRules | | public List getBRules()(Code) | | Return an ordered list of all registered backward rules. Includes those
generated by forward productions.
|
| getNRulesFired | | public long getNRulesFired()(Code) | | Return the number of rules fired since this rule engine instance
was created and initialized
|
| getRules | | public List getRules()(Code) | | Return the originally supplied set of rules, may be a mix of forward
and backward rules.
|
| getTemp | | public Node getTemp(Node instance, Node prop, Node pclass)(Code) | | Retrieve or create a bNode representing an inferred property value.
Parameters:
instance - the base instance node to which the property applies
Parameters:
prop - the property node whose value is being inferred
Parameters:
pclass - the (optional, can be null) class for the inferred value. the bNode representing the property value |
| graphBaseFind | | public ExtendedIterator graphBaseFind(Node subject, Node property, Node object)(Code) | | Returns an iterator over Triples.
This implementation assumes that the underlying findWithContinuation
will have also consulted the raw data.
|
| instantiateRuleEngine | | protected void instantiateRuleEngine(List rules)(Code) | | Instantiate the forward rule engine to use.
Subclasses can override this to switch to, say, a RETE imlementation.
Parameters:
rules - the rule set or null if there are not rules bound in yet. |
| performAdd | | public synchronized void performAdd(Triple t)(Code) | | Add one triple to the data graph, run any rules triggered by
the new data item, recursively adding any generated triples.
|
| performDelete | | public void performDelete(Triple t)(Code) | | Removes the triple t (if possible) from the set belonging to this graph.
|
| preloadDeductions | | protected boolean preloadDeductions(Graph preloadIn)(Code) | | Adds a set of precomputed triples to the deductions store. These do not, themselves,
fire any rules but provide additional axioms that might enable future rule
firing when real data is added. Used to implement bindSchema processing
in the parent Reasoner.
true if the preload was able to load rules as well |
| prepare | | public void prepare()(Code) | | Perform any initial processing and caching. This call is optional. Most
engines either have negligable set up work or will perform an implicit
"prepare" if necessary. The call is provided for those occasions where
substantial preparation work is possible (e.g. running a forward chaining
rule system) and where an application might wish greater control over when
this prepration is done.
|
| processBuiltin | | public boolean processBuiltin(ClauseEntry clause, Rule rule, BindingEnvironment env)(Code) | | Process a call to a builtin predicate
Parameters:
clause - the Functor representing the call
Parameters:
env - the BindingEnvironment for this call
Parameters:
rule - the rule which is invoking this call true if the predicate succeeds |
| rebind | | public void rebind()(Code) | | Cause the inference graph to reconsult the underlying graph to take
into account changes. Normally changes are made through the InfGraph's add and
remove calls are will be handled appropriately. However, in some cases changes
are made "behind the InfGraph's back" and this forces a full reconsult of
the changed data.
|
| reset | | public void reset()(Code) | | Flush out all cached results. Future queries have to start from scratch.
|
| setDerivationLogging | | public void setDerivationLogging(boolean recordDerivations)(Code) | | Set to true to enable derivation caching
|
| setTraceOn | | public void setTraceOn(boolean state)(Code) | | Set the state of the trace flag. If set to true then rule firings
are logged out to the Log at "INFO" level.
|
| setUseTGCCache | | public void setUseTGCCache()(Code) | | Instantiate the optional caches for the subclass/suproperty lattices.
Unless this call is made the TGC caching will not be used.
|
|
|