Package org.projog.core.predicate.builtin.compound

Class AbstractCollectionOf

java.lang.Object

org.projog.core.predicate.builtin.compound.AbstractCollectionOf

All Implemented Interfaces:

Predicate

Direct Known Subclasses:

BagOf.BagOfPredicate, SetOf.SetOfPredicate

abstract class AbstractCollectionOf
extends java.lang.Object
implements Predicate

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	AbstractCollectionOf.Key	Represents a combination of possible values for the variables contained in the goal.

Field Summary

Fields

Modifier and Type	Field	Description
private Term	bag
private Term	goal
private java.util.Iterator<java.util.Map.Entry<AbstractCollectionOf.Key,java.util.List<Term>>>	itr
private PredicateFactory	pf
private Term	template
private java.util.List<Variable>	variablesNotInTemplate

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	AbstractCollectionOf(PredicateFactory pf, Term template, Term goal, Term bag)

Method Summary

Modifier and Type	Method	Description
protected abstract void	add(java.util.List<Term> l, Term t)
boolean	couldReevaluationSucceed()	Could the next re-evaluation of this instance succeed?
boolean	evaluate()	Attempts to satisfy the goal this instance represents.
private java.util.List<Variable>	getVariablesNotInTemplate(Term template, Term goal)
private boolean	hasFoundAnotherSolution(Predicate predicate)
private void	init(Term template, Term goal)

Methods inherited from class java.lang.Object

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

Field Detail

pf

private final PredicateFactory pf

template

private final Term template

goal

private final Term goal

bag

private final Term bag

variablesNotInTemplate

private java.util.List<Variable> variablesNotInTemplate

itr

private java.util.Iterator<java.util.Map.Entry<AbstractCollectionOf.Key,java.util.List<Term>>> itr

Constructor Detail

AbstractCollectionOf

protected AbstractCollectionOf(PredicateFactory pf,
                               Term template,
                               Term goal,
                               Term bag)

Method Detail

evaluate

public final boolean evaluate()

Description copied from interface: Predicate

Attempts to satisfy the goal this instance represents.

Calling this method multiple times on a single instance allows all possible answers to be identified. An attempt to find a solution carries on from where the last successful call finished.

If PredicateFactory.isRetryable() returns false then this method should only be called once per individual query (no attempt should be made to find alternative solutions).

If PredicateFactory.isRetryable() returns true then, in order to find all possible solutions for an individual query, this method should be recalled on backtracking until it returns false.

Specified by:

evaluate in interface Predicate

Returns:

true if it was possible to satisfy the clause, false otherwise

See Also:

PredicateFactory.getPredicate(Term[])

init

private void init(Term template,
                  Term goal)

add

protected abstract void add(java.util.List<Term> l,
                            Term t)

getVariablesNotInTemplate

private java.util.List<Variable> getVariablesNotInTemplate(Term template,
                                                           Term goal)

hasFoundAnotherSolution

private boolean hasFoundAnotherSolution(Predicate predicate)

couldReevaluationSucceed

public final boolean couldReevaluationSucceed()

Description copied from interface: Predicate

Could the next re-evaluation of this instance succeed?

Specifies whether a specific instance of a specific implementation of Predicate, that has already had Predicate.evaluate() called on it at least once, could possibly return true the next time Predicate.evaluate() is called on it. i.e. is it worth trying to continue to find solutions for the specific query this particular instance represents and has been evaluating?

(Note: the difference between this method and PredicateFactory.isRetryable() is that PredicateFactory.isRetryable() deals with whether, in general, a specific implementation (rather than instance) of Predicate could ever produce multiple answers for an individual query.)

Specified by:

couldReevaluationSucceed in interface Predicate

Returns:

true if an attempt to re-evaluate this instance could possible succeed, false otherwise