Package org.projog.core.predicate.builtin.clp

Class Resolve.ClpResolvePredicate

  • All Implemented Interfaces:
    Predicate
    Enclosing class:
    Resolve
    private static final class Resolve.ClpResolvePredicate
extends java.lang.Object
implements Predicate

    • Field Summary

      Fields 
      Modifier and Type Field Description
      private org.projog.clp.BruteForceSearch bruteForceSearch  
      private java.util.Map<ClpVariable,​org.projog.clp.Variable> variables  

    • Constructor Summary

      Constructors 
      Modifier Constructor Description
      private ClpResolvePredicate​(org.projog.clp.BruteForceSearch bruteForceSearch, java.util.Map<ClpVariable,​org.projog.clp.Variable> variables)  

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      boolean couldReevaluationSucceed()
      Could the next re-evaluation of this instance succeed?
      boolean evaluate()
      Attempts to satisfy the goal this instance represents.
      private org.projog.clp.ClpConstraintStore next()  

      • Methods inherited from class java.lang.Object

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

    • Field Detail

      • bruteForceSearch

        private final org.projog.clp.BruteForceSearch bruteForceSearch

      • variables

        private final java.util.Map<ClpVariable,​org.projog.clp.Variable> variables

    • Constructor Detail

      • ClpResolvePredicate

        private ClpResolvePredicate​(org.projog.clp.BruteForceSearch bruteForceSearch,
                            java.util.Map<ClpVariable,​org.projog.clp.Variable> variables)

    • Method Detail

      • 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:
        PredicateFactory.getPredicate(Term[])

      • next

        private org.projog.clp.ClpConstraintStore next()

      • 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