Package org.tweetyproject.action.signature

Class ActionSignature

  • All Implemented Interfaces:
    java.lang.Cloneable, Signature
    public class ActionSignature
extends FolSignature
    This class represents an action signature consisting of a set of fluent names (representing environment states) and a set of action names (representing actions). They are represented by first order predicates to allow for the simple implementation of a grounding mechanism.
    Author:
    Sebastian Homann

    • Constructor Detail

      • ActionSignature

        public ActionSignature()
        Creates an empty signature

      • ActionSignature

        public ActionSignature​(java.util.Collection<?> c)
                throws java.lang.IllegalArgumentException
        Creates a signature with the given objects (should be sorts, constants, predicates or formulas).
        Parameters:
        c - a collection of items to be added.
        Throws:
        java.lang.IllegalArgumentException - if at least one of the given objects is neither a constant, a sort, a predicate or a formula.

      • ActionSignature

        public ActionSignature​(FolFormula f)
        Creates a new Action Signature for a single first order formula.
        Parameters:
        f - a FOL formula

    • Method Detail

      • getActionNames

        public java.util.Set<FolActionName> getActionNames()
        Returns:
        the set of action names contained in this action signature.

      • getFluentNames

        public java.util.Set<FolFluentName> getFluentNames()
        Returns:
        the set of fluent names contained in this action signature.

      • isValidFormula

        public boolean isValidFormula​(Formula f)
        Checks if a given formula is valid in the sense of an action description, containing only predicates that are either fluentNames or actionNames and containing neither quantifiers nor functions.
        Parameters:
        f - the formula in question.
        Returns:
        true iff the given formula is a FolFormula, contains only atoms with fluent or action-predicates and contains no quantifiers or functors.

      • toString

        public java.lang.String toString()
        Description copied from class: FolSignature
        Returns a string representation of this first-order logic signature.
        Specified by:
        toString in interface Signature
        Overrides:
        toString in class FolSignature
        Returns:
        a string consisting of the sorts with their constants followed by the predicates and functors of the signature.

      • containsActionName

        public boolean containsActionName​(java.lang.String actionName)
        Returns true iff the given actionName is contained in this action signature.
        Parameters:
        actionName - an action name
        Returns:
        true iff actionName is contained in this signature.

      • containsFluentName

        public boolean containsFluentName​(java.lang.String fluentName)
        Returns true iff the given fluentName is contained in this action signature.
        Parameters:
        fluentName - a fluent name
        Returns:
        true iff fluentName is contained in this action signature.

      • getActionName

        public FolActionName getActionName​(java.lang.String action)
        Returns the action name predicate with the given name if one exists, null otherwise.
        Parameters:
        action - an action
        Returns:
        the actionName predicate with the given name or null

      • getFluentName

        public FolFluentName getFluentName​(java.lang.String fluentName)
        Returns the fluent name predicate with the given name if one exists, null otherwise.
        Parameters:
        fluentName - a string
        Returns:
        the fluent predicate with the given name or null

      • containsActionName

        public boolean containsActionName​(FolActionName actionName)
        Returns true iff the given actionName is contained in this signature.
        Parameters:
        actionName - a FOL action name
        Returns:
        true iff the given actionName is contained in this signature.

      • containsFluentName

        public boolean containsFluentName​(FolFluentName fluentName)
        Returns true iff the given fluentName is contained in this signature.
        Parameters:
        fluentName - a string
        Returns:
        true iff the given fluentName is contained in this signature.

      • containsPredicate

        public boolean containsPredicate​(Predicate predicate)
        Returns true iff the given predicate is contained in this signature.
        Parameters:
        predicate - some predicate
        Returns:
        true iff the given predicate is contained in this signature.

      • getAllGroundedFluentAtoms

        public java.util.Set<FolAtom> getAllGroundedFluentAtoms()
        Returns the set of all possible grounded atoms in this signature on the basis of all fluent predicates contained.
        Returns:
        the set of all possible grounded fluent atoms.

      • getAllGroundedActionNameAtoms

        public java.util.Set<FolAtom> getAllGroundedActionNameAtoms()
        Returns the set of all possible grounded atoms in this signature on the basis of all action name predicates contained.
        Returns:
        the set of all possible grounded action atoms.

      • add

        public void add​(java.lang.Object obj)
         throws java.lang.IllegalArgumentException
        Description copied from class: FolSignature
        Adds the given object, either a constant, a sort, a predicate, or a functor, to this signature. If a constant is added its sort is added as well, the same is for any sort mentioned in predicates and functors. Alternatively, you can pass over a formula, then all predicates, sorts, constants, and functors of this formula are added to the signature.
        Specified by:
        add in interface Signature
        Overrides:
        add in class FolSignature
        Parameters:
        obj - the object to be added, either a constant, a sort, a predicate, a functor, or a formula.
        Throws:
        java.lang.IllegalArgumentException - if the given object is neither a constant, a sort, a predicate, a functor, or a formula.