jtp.frame
Class LinkAsserter

java.lang.Object
  |
  +--java.beans.beancontext.BeanContextChildSupport
        |
        +--jtp.util.PropertyImporter
              |
              +--jtp.frame.LinkAsserter

All Implemented Interfaces:

BeanContextChild, BeanContextServiceRevokedListener, BeanContextServicesListener, EventListener, Reasoner, Serializable

public class LinkAsserter

extends PropertyImporter

implements Reasoner

See Also:

Serialized Form

Nested Class Summary

protected static class	LinkAsserter.UndoInsert Class of undoable edits that corresponds to adding a ValueLink to a ValueCollection's input links.
protected static class	LinkAsserter.UndoRemove

Field Summary

protected static boolean

VERBOSE

Fields inherited from class java.beans.beancontext.BeanContextChildSupport

beanContext, beanContextChildPeer, pcSupport, rejectedSetBCOnce, vcSupport

Constructor Summary

LinkAsserter()

Method Summary

boolean	acceptable(Object o) decides if the goal is suitable for being processed by this reasoner.
static boolean	checkLinkRedundancy(ValueCollection source, ValueCollection target, int depth) checks if there is a directed path in the value collection graph from source to target.
FrameKB	getFrameKB()
int	getRedundancyCheckDepth() returns the current value for the number of links that the asserter will follow in the graph to see if the source and target value collections are already connected.
UndoManager	getUndoManager()
static void	insertLink(ValueLink vl) inserts the specified link into the value collections' data structures, if there isn't already a link between these two collections.
protected ValueLink	prepareValueLink(ValueLinkCreationReasoningStep rs)
protected ValueLink	prepareValueLink(ValueLinkCreationReasoningStep rs, ReasoningStepCollector rsc)
ReasoningStepIterator	process(Object o) This method attempts to find proof for the goal.
void	processInsertion(ValueLink vl)
void	processInsertion(ValueLink vl, DefaultReasoningStepCollector rsc)
void	processRemoval(ValueLink vl)
static ReasoningStepIterator	propagateAssertedValue(ValueCollection vc, Object value)
static ReasoningStepIterator	propagateLinkResults(ValueLink vl)
static ReasoningStepIterator	propagateResultsForTarget(ValueLink vl)
static void	removeLink(ValueLink vl)
void	setFrameKB(FrameKB f)
void	setRedundancyCheckDepth(int v) Set the value of redundancyCheckDepth.
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

VERBOSE

protected static boolean VERBOSE

Constructor Detail

LinkAsserter

public LinkAsserter()

Method Detail

getUndoManager

public UndoManager getUndoManager()

setUndoManager

public void setUndoManager(UndoManager undo)

getFrameKB

public FrameKB getFrameKB()

setFrameKB

public void setFrameKB(FrameKB f)

getRedundancyCheckDepth

public int getRedundancyCheckDepth()

returns the current value for the number of links that the asserter will follow in the graph to see if the source and target value collections are already connected.

Returns:

Value of redundancyCheckDepth.

setRedundancyCheckDepth

public void setRedundancyCheckDepth(int v)

Set the value of redundancyCheckDepth.

Parameters:

v - Value to assign to redundancyCheckDepth.

See Also:

getRedundancyCheckDepth()

acceptable

public boolean acceptable(Object o)

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.

prepareValueLink

protected ValueLink prepareValueLink(ValueLinkCreationReasoningStep rs)

prepareValueLink

protected ValueLink prepareValueLink(ValueLinkCreationReasoningStep rs,
                                     ReasoningStepCollector rsc)

propagateAssertedValue

public static ReasoningStepIterator propagateAssertedValue(ValueCollection vc,
                                                           Object value)

propagateLinkResults

public static ReasoningStepIterator propagateLinkResults(ValueLink vl)

propagateResultsForTarget

public static ReasoningStepIterator propagateResultsForTarget(ValueLink vl)

checkLinkRedundancy

public static boolean checkLinkRedundancy(ValueCollection source,
                                          ValueCollection target,
                                          int depth)

checks if there is a directed path in the value collection graph from source to target.

Parameters:

source - the start of the path

target - the end of the path

depth - the maximal depth of the path to look for

insertLink

public static void insertLink(ValueLink vl)

inserts the specified link into the value collections' data structures, if there isn't already a link between these two collections.

Parameters:

vl - the link to insert

Returns:

true if the state of the system has changed (i.e., link was actually inserted.)

processInsertion

public void processInsertion(ValueLink vl)

processInsertion

public void processInsertion(ValueLink vl,
                             DefaultReasoningStepCollector rsc)

processRemoval

public void processRemoval(ValueLink vl)

removeLink

public static void removeLink(ValueLink vl)