jtp.frame.listen.dl
Class IntersectionTypeReasoner

java.lang.Object
  |
  +--java.beans.beancontext.BeanContextChildSupport
        |
        +--jtp.util.PropertyImporter
              |
              +--jtp.frame.listen.dl.IntersectionTypeReasoner

All Implemented Interfaces:

BeanContextChild, BeanContextServiceRevokedListener, BeanContextServicesListener, EventListener, Reasoner, RelationBasedFCReasoner, RelationBasedReasoner, Serializable

public class IntersectionTypeReasoner

extends PropertyImporter

implements RelationBasedFCReasoner, Serializable

A telling reasoner that is activated when literals with the relation daml:intersectionOf are told. Given a sentence (daml:intersectionOf CLASS LIST), this reasoner and its helper classes will figure out if any objects are instances of all items of LIST. If there is any such object (or such an object comes about later in the telling of assertions), this listener or one of its helpers will infer that the object is an instance of CLASS.

This reasoner operates largely by returning reasoning steps that cause ValueCollectionListeners to be installed.

See Also:

Serialized Form

Field Summary

protected Symbol	intersectionRelation
protected Symbol	itemRelation
protected Symbol	typeRelation

Fields inherited from class java.beans.beancontext.BeanContextChildSupport

beanContext, beanContextChildPeer, pcSupport, rejectedSetBCOnce, vcSupport

Fields inherited from interface jtp.disp.RelationBasedReasoner

ANY_ARITY, BOTH, NEGATIVE, POSITIVE

Constructor Summary

IntersectionTypeReasoner(Symbol intersection, Symbol type, Symbol item)

Method Summary

boolean	acceptable(Object rs) decides if the goal is suitable for being processed by this reasoner.
protected ReasoningStep[]	addIntersection(Object list, Object className, ReasoningStep intersectionProof) Set up watching for instances of a new conjunctively defined class.
int	getArity() returns the "arity" of literals that are appropriate for this reasoner.
FrameKB	getFrameKB()
protected Map	getListItems(Object list) Assumes that all of the items that are in the list have been asserted.
int	getPolarity() returns the polarity of literals that are appropriate for this reasoner.
Symbol	getRelation() returns the relation symbol of literals that are appropriate for this reasoner.
protected ReasoningStep[]	newInstanceOfClass(Object instance, Object cl, ReasoningStep proof) Called when instance has been discovered to be an instance of cl.
ReasoningStepIterator	process(Object o) This method attempts to find proof for the goal.
void	setFrameKB(FrameKB fkb)
void	setUndoManager(UndoManager undo)

Methods inherited from class jtp.util.PropertyImporter

getImportedProperties, initializeBeanContextResources, setImportedProperties

Methods inherited from class java.beans.beancontext.BeanContextChildSupport

addPropertyChangeListener, addVetoableChangeListener, firePropertyChange, fireVetoableChange, getBeanContext, getBeanContextChildPeer, isDelegated, releaseBeanContextResources, removePropertyChangeListener, removeVetoableChangeListener, serviceAvailable, serviceRevoked, setBeanContext, validatePendingSetBeanContext

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

intersectionRelation

protected Symbol intersectionRelation

typeRelation

protected Symbol typeRelation

itemRelation

protected Symbol itemRelation

Constructor Detail

IntersectionTypeReasoner

public IntersectionTypeReasoner(Symbol intersection,
                                Symbol type,
                                Symbol item)

Method Detail

getFrameKB

public FrameKB getFrameKB()

setFrameKB

public void setFrameKB(FrameKB fkb)

setUndoManager

public void setUndoManager(UndoManager undo)

getRelation

public Symbol getRelation()

Description copied from interface: RelationBasedReasoner

returns the relation symbol of literals that are appropriate for this reasoner.

Specified by:

getRelation in interface RelationBasedReasoner

Returns:

the relation symbol of literals that are appropriate for this reasoner.

getArity

public int getArity()

Description copied from interface: RelationBasedReasoner

returns the "arity" of literals that are appropriate for this reasoner. Arity is the number of parameters of the literal. Return RelationBasedReasoner.ANY_ARITY for reasoners that are not limited to a certain arity.

Specified by:

getArity in interface RelationBasedReasoner

Returns:

the "arity" of literals that are appropriate for this reasoner.

getPolarity

public int getPolarity()

Description copied from interface: RelationBasedReasoner

returns the polarity of literals that are appropriate for this reasoner. Polarity can be one of the following:

1. RelationBasedReasoner.POSITIVE - for literals that are not negated,
2. RelationBasedReasoner.NEGATIVE - for literals that are negated,
3. RelationBasedReasoner.BOTH - if the reasoner can handle literals of any polarity.

Specified by:

getPolarity in interface RelationBasedReasoner

acceptable

public boolean acceptable(Object rs)

Description copied from interface: Reasoner

decides if the goal is suitable for being processed by this reasoner. This method should be fast; if there are doubts as to whether a goal is acceptable, and it looks like determining it might take some time, the method should return true and let the process method figure it out.

Example. Many reasoners only process literals with certain predicates and arity. These reasoners will use those criteria to determine acceptability, for example a reasoner dealing with equality could accept goals that are:

1. Literals,
2. have = as their relation predicate,
3. have exactly two arguments.

Specified by:

acceptable in interface Reasoner

Returns:

true if the goal is suitable for this reasoner, false otherwise.

process

public ReasoningStepIterator process(Object o)

Description copied from interface: Reasoner

This method attempts to find proof for the goal. It returns an enumeration of reasoning steps that correspond to alternative proofs for the goal. Consequently, the items of the enumeration can actually belong to different models of the goal sentence, and have incompatible variable assignments.

Example. A reasoner that performs unification of the goal with facts in a knowledge base can return the following enumeration for the goal (parent joe ?x):

1. A reasoning step proving (parent joe fred) with variable assignment ?x=fred,
2. A reasoning step proving (parent joe mary) with variable assignment ?x=mary.

Specified by:

process in interface Reasoner

Parameters:

o - the goal: either a query or an assertion

Returns:

the iterator of reasoning steps - proofs for the query, or consequences of the assertion.

addIntersection

protected ReasoningStep[] addIntersection(Object list,
                                          Object className,
                                          ReasoningStep intersectionProof)

Set up watching for instances of a new conjunctively defined class.

newInstanceOfClass

protected ReasoningStep[] newInstanceOfClass(Object instance,
                                             Object cl,
                                             ReasoningStep proof)

Called when instance has been discovered to be an instance of cl.

getListItems

protected Map getListItems(Object list)

Assumes that all of the items that are in the list have been asserted. The DAMLParser attempts to enforce this. If users are not exclusively using the DAMLParser, they have to be careful.