001: /******************************************************************
002: * File: BBRuleContext.java
003: * Created by: Dave Reynolds
004: * Created on: 05-May-2003
005: *
006: * (c) Copyright 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP
007: * [See end of file]
008: * $Id: BBRuleContext.java,v 1.13 2008/01/02 12:06:15 andy_seaborne Exp $
009: *****************************************************************/package com.hp.hpl.jena.reasoner.rulesys.impl;
010:
011: import com.hp.hpl.jena.graph.Node;
012: import com.hp.hpl.jena.graph.Triple;
013: import com.hp.hpl.jena.reasoner.*;
014: import com.hp.hpl.jena.reasoner.rulesys.*;
015: import com.hp.hpl.jena.util.iterator.ClosableIterator;
016:
017: /**
018: * Implementation of RuleContext for use in the backward chaining
019: * interpreter. The RuleContext allows builtin predicates to
020: * interpret variable bindings to access the static triple data.
021: *
022: * @author <a href="mailto:der@hplb.hpl.hp.com">Dave Reynolds</a>
023: * @version $Revision: 1.13 $ on $Date: 2008/01/02 12:06:15 $
024: */
025: public class BBRuleContext implements RuleContext {
026:
027: /** The binding environment which represents the state of the current rule execution. */
028: protected BindingEnvironment env;
029:
030: /** The rule current being executed. */
031: protected Rule rule;
032:
033: /** The enclosing inference graph. */
034: protected BackwardRuleInfGraphI graph;
035:
036: /**
037: * Construct an empty context. It can't be used until
038: * the rule and environment have been set.
039: */
040: public BBRuleContext(BackwardRuleInfGraphI graph) {
041: this .graph = graph;
042: }
043:
044: /**
045: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#contains(com.hp.hpl.jena.graph.Node, com.hp.hpl.jena.graph.Node, com.hp.hpl.jena.graph.Node)
046: */
047: public boolean contains(Node s, Node p, Node o) {
048: ClosableIterator i = find(s, p, o);
049: boolean result = i.hasNext();
050: i.close();
051: return result;
052: }
053:
054: /**
055: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#contains(com.hp.hpl.jena.graph.Triple)
056: */
057: public boolean contains(Triple t) {
058: return contains(t.getSubject(), t.getPredicate(), t.getObject());
059: }
060:
061: /**
062: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#find(com.hp.hpl.jena.graph.Node, com.hp.hpl.jena.graph.Node, com.hp.hpl.jena.graph.Node)
063: */
064: public ClosableIterator find(Node s, Node p, Node o) {
065: return graph.findDataMatches(new TriplePattern(s, p, o));
066: // return searchpath.find(new TriplePattern(s, p, o));
067: }
068:
069: /**
070: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#getEnv()
071: */
072: public BindingEnvironment getEnv() {
073: return env;
074: }
075:
076: /**
077: * Set the binding environment for the this context
078: */
079: public void setEnv(BindingEnvironment env) {
080: this .env = env;
081: }
082:
083: /**
084: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#getGraph()
085: */
086: public InfGraph getGraph() {
087: return graph;
088: }
089:
090: /**
091: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#getRule()
092: */
093: public Rule getRule() {
094: return rule;
095: }
096:
097: /**
098: * @see com.hp.hpl.jena.reasoner.rulesys.RuleContext#setRule(com.hp.hpl.jena.reasoner.rulesys.Rule)
099: */
100: public void setRule(Rule rule) {
101: this .rule = rule;
102: }
103:
104: /**
105: * Assert a new triple in the deduction graph, bypassing any processing machinery.
106: */
107: public void silentAdd(Triple t) {
108: ((SilentAddI) graph).silentAdd(t);
109: }
110:
111: /**
112: * Assert a new triple in the deduction graph, triggering any consequent processing as appropriate.
113: * In the backward case there no immediate consequences so this is equivalent to a silentAdd.
114: */
115: public void add(Triple t) {
116: ((SilentAddI) graph).silentAdd(t);
117: }
118:
119: /**
120: * Remove a triple from the deduction graph (and the original graph if relevant).
121: */
122: public void remove(Triple t) {
123: graph.delete(t);
124: }
125:
126: /**
127: * Retrieve or create a bNode representing an inferred property value.
128: * This is currently only available on backward contexts and not part of the
129: * normal RuleContext interface.
130: * @param instance the base instance node to which the property applies
131: * @param prop the property node whose value is being inferred
132: * @param pclass the (optional, can be null) class for the inferred value.
133: * @return the bNode representing the property value
134: */
135: public Node getTemp(Node instance, Node prop, Node pclass) {
136: return graph.getTemp(instance, prop, pclass);
137: }
138:
139: }
140:
141: /*
142: (c) Copyright 2003, 2004, 2005, 2006, 2007, 2008 Hewlett-Packard Development Company, LP
143: All rights reserved.
144:
145: Redistribution and use in source and binary forms, with or without
146: modification, are permitted provided that the following conditions
147: are met:
148:
149: 1. Redistributions of source code must retain the above copyright
150: notice, this list of conditions and the following disclaimer.
151:
152: 2. Redistributions in binary form must reproduce the above copyright
153: notice, this list of conditions and the following disclaimer in the
154: documentation and/or other materials provided with the distribution.
155:
156: 3. The name of the author may not be used to endorse or promote products
157: derived from this software without specific prior written permission.
158:
159: THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
160: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
161: OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
162: IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
163: INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
164: NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
165: DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
166: THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
167: (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
168: THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
169: */
|