Class StaticUserDefinedPredicateFactory

java.lang.Object
org.projog.core.predicate.udp.StaticUserDefinedPredicateFactory
All Implemented Interfaces:
PredicateFactory, PreprocessablePredicateFactory, UserDefinedPredicateFactory
public class StaticUserDefinedPredicateFactory extends Object implements UserDefinedPredicateFactory, PreprocessablePredicateFactory
Maintains a record of the clauses that represents a "static" user defined predicate.

A "static" user defined predicate is one that can not have clauses added or removed after it is first defined.

  • Field Details

    • lock

      private final Object lock

    • predicateKey

      private final PredicateKey predicateKey

    • kb

      private final KnowledgeBase kb

    • spyPoint

      private final SpyPoints.SpyPoint spyPoint

    • implications

      private final List<ClauseModel> implications

    • compiledPredicateFactory

      private PredicateFactory compiledPredicateFactory

    • setCompiledPredicateFactoryInvocationCtr

      private int setCompiledPredicateFactoryInvocationCtr

  • Constructor Details

  • Method Details

    • addFirst

      public void addFirst(ClauseModel clauseModel)
      Not supported.

      It is not possible to add a clause to the beginning of a static user defined predicate.

      Specified by:
      addFirst in interface UserDefinedPredicateFactory
      Parameters:
      clauseModel - the clause to add to the beginning of the predicate
      Throws:
      ProjogException

    • addLast

      public void addLast(ClauseModel clauseModel)
      Adds new clause to list of clauses for this predicate.

      Note: it is not possible to add clauses to a static user defined predicate once it has been compiled.

      Specified by:
      addLast in interface UserDefinedPredicateFactory
      Parameters:
      clauseModel - the clause to add to the end of the predicate
      Throws:
      IllegalStateException - if the predicate has already been compiled.

    • compile

      public void compile()

    • setCompiledPredicateFactory

      private void setCompiledPredicateFactory()

    • getCopyOfImplications

      private List<ClauseModel> getCopyOfImplications()

    • isCyclic

      private boolean isCyclic()
      Return true if this predicate calls a predicate that in turns calls this predicate.

      For example, in the following script both a and b are cyclic, but c is not. 

      a(Z) :- b(Z).

b(Z) :- a(Z).

c(Z) :- b(Z).

    • createInterpretedPredicateFactoryFromClauseActions

      private PredicateFactory createInterpretedPredicateFactoryFromClauseActions(Clauses clauses, List<ClauseModel> clauseModels)

    • createInterpretedPredicateFactoryFromClauses

      private PredicateFactory createInterpretedPredicateFactoryFromClauses(Clauses clauses)

    • createSingleClausePredicateFactory

      private PredicateFactory createSingleClausePredicateFactory(ClauseAction clause)

    • createPredicate

      private Predicate createPredicate(Term[] args, ClauseAction[] clauses)

    • isClausesRetryable

      private static boolean isClausesRetryable(ClauseAction[] clauses)
      Returns true if clauses could return more than one result.

      Returns false if use of cut means once a result has been found a subsequent attempt at backtracking will immediately fail. e.g.: 

      p(X) :- var(X), !.
p(1) :- !.
p(7). % OK for last rule not to contain a cut, as long as it is not retryable.

    • getPredicate

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

    • getPredicateKey

      public PredicateKey getPredicateKey()
      Description copied from interface: UserDefinedPredicateFactory
      Returns the key for the predicate this object represents
      Specified by:
      getPredicateKey in interface UserDefinedPredicateFactory
      Returns:
      the key for the predicate this object represents

    • getActualPredicateFactory

      public PredicateFactory getActualPredicateFactory()

    • getImplications

      public Iterator<ClauseModel> getImplications()
      Returns an iterator over the clauses of this user defined predicate.

      The iterator returned will have the following characteristics which prevent the underlying structure of the user defined predicate being altered:

      Specified by:
      getImplications in interface UserDefinedPredicateFactory
      Returns:
      an iterator over the clauses in the predicate in proper sequence.

    • isDynamic

      public boolean isDynamic()
      Description copied from interface: UserDefinedPredicateFactory
      Returns true is this predicate is dynamic.

      A "dynamic" predicate is a user defined predicate that can have clauses added or removed after is first defined.

      Specified by:
      isDynamic in interface UserDefinedPredicateFactory
      Returns:
      true is this predicate is dynamic

    • getClauseModel

      public ClauseModel getClauseModel(int index)
      Description copied from interface: UserDefinedPredicateFactory
      Returns the clause at the specified position in this predicate's list of clauses.
      Specified by:
      getClauseModel in interface UserDefinedPredicateFactory
      Parameters:
      index - index of the clause to return
      Returns:
      the clause at the specified position in this predicate's list of clauses or null if out of bounds

    • 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

    • preprocess

      public PredicateFactory preprocess(Term arg)
      Specified by:
      preprocess in interface PreprocessablePredicateFactory

    • optimisePredicateFactory

      private static List<ClauseAction> optimisePredicateFactory(KnowledgeBase kb, ClauseAction[] data, Term arg)