Package org.projog.core.predicate.udp

Class StaticUserDefinedPredicateFactory

    • Field Detail

      • lock

        private final java.lang.Object lock

      • implications

        private final java.util.List<ClauseModel> implications

      • setCompiledPredicateFactoryInvocationCtr

        private int setCompiledPredicateFactoryInvocationCtr

    • Constructor Detail

      • StaticUserDefinedPredicateFactory

        public StaticUserDefinedPredicateFactory​(KnowledgeBase kb,
                                         PredicateKey predicateKey)

    • Method Detail

      • 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:
        java.lang.IllegalStateException - if the predicate has already been compiled.

      • compile

        public void compile()

      • setCompiledPredicateFactory

        private void setCompiledPredicateFactory()

      • getCopyOfImplications

        private java.util.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,
                                                                            java.util.List<ClauseModel> clauseModels)

      • createInterpretedPredicateFactoryFromClauses

        private PredicateFactory createInterpretedPredicateFactoryFromClauses​(Clauses 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.

      • getActualPredicateFactory

        public PredicateFactory getActualPredicateFactory()

      • getImplications

        public java.util.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:

        • Calls to Iterator.next() return a new copy of the ClauseModel.
        • Calls to Iterator.remove() cause a UnsupportedOperationException
        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