Class RepeatInfinitely

java.lang.Object
org.projog.core.predicate.builtin.flow.RepeatInfinitely
All Implemented Interfaces:
Predicate, PredicateFactory
public final class RepeatInfinitely extends Object implements PredicateFactory, Predicate
repeat - always succeeds.

repeat always succeeds even when an attempt is made to re-satisfy it.

  • Constructor Details

    • RepeatInfinitely

      public RepeatInfinitely()

  • Method Details

    • getPredicate

      public Predicate getPredicate(Term term)
      Description copied from interface: PredicateFactory
      Returns a Predicate to be used in the evaluation of a goal.
      Specified by:
      getPredicate in interface PredicateFactory
      Parameters:
      term - the term containing the arguments to use in the evaluation of the goal
      Returns:
      Predicate to be used in the evaluation of the goal
      See Also:

    • isRetryable

      public boolean isRetryable()
      Description copied from interface: PredicateFactory
      Should instances of this implementation be re-evaluated when backtracking?

      Some goals (e.g. X is 1) are only meant to be evaluated once (the statement is either true or false) while others (e.g. repeat(3)) are meant to be evaluated multiple times. For instances of Predicate that are designed to possibly have Predicate.evaluate() called on them multiple times for the same individual query this method should return true. For instances of Predicate that are designed to only be evaluated once per individual query this method should return false.

      Specified by:
      isRetryable in interface PredicateFactory
      Returns:
      true if an attempt should be made to re-evaluate instances of implementing classes when backtracking, false otherwise

    • evaluate

      public 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:

    • couldReevaluationSucceed

      public 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