jason.asSyntax
Class Literal

Package class diagram package Literal
java.lang.Object
  extended by jason.asSyntax.DefaultTerm
      extended by jason.asSyntax.Literal
All Implemented Interfaces:
LogicalFormula, Term, ToDOM, java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<Term>
Direct Known Subclasses:
Atom

public abstract class Literal
extends DefaultTerm
implements LogicalFormula

This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal. To create a new Literal, one of the following concrete classes may be used:

The latter class supports all the operations of the Literal interface.

There are useful static methods in class ASSyntax to create Literals.

See Also:
ASSyntax, Atom, Structure, Pred, LiteralImpl, Serialized Form

Field Summary
static Literal LFalse
           
static boolean LNeg
           
static boolean LPos
           
static Literal LTrue
           
protected  PredicateIndicator predicateIndicatorCache
           
 
Fields inherited from class jason.asSyntax.DefaultTerm
hashCodeCache, srcInfo
 
Constructor Summary
Literal()
           
 
Method Summary
 boolean addAnnot(Term t)
           
 Literal addAnnots(java.util.List<Term> l)
          adds some annots and return this
 Literal addAnnots(Term... terms)
          adds some annots and return this
 void addSource(Term agName)
          adds the annotation source(agName)
 void addTerm(Term t)
           
 Literal addTerms(java.util.List<Term> l)
          adds some terms and return this
 Literal addTerms(Term... ts)
          adds some terms and return this
 boolean canBeAddedInBB()
          returns this if this literal can be added in the belief base (Atoms, for instance, can not be)
 void clearAnnots()
          removes all annotations
 Literal copy()
           
 boolean delAnnot(Term t)
           
 boolean delAnnots(java.util.List<Term> l)
          removes all annots in this pred that are in the list l.
 boolean delSource(Term agName)
          deletes one source(agName) annotation, return true if deleted
 void delSources()
          deletes all source annotations
 void delTerm(int index)
           
 boolean equalsAsStructure(java.lang.Object p)
           
 Literal forceFullLiteralImpl()
          Transforms this into a full literal (which implements all methods of Literal), if it is an Atom; otherwise returns 'this'
 ListTerm getAnnots()
          returns all annotations of the literal
 ListTerm getAnnots(java.lang.String functor)
          returns all annots with the specified functor e.g.: from annots [t(a), t(b), source(tom)] and functor "t", it returns [t(a),t(b)] in case that there is no such an annot, it returns an empty list.
 int getArity()
          returns the number of terms of this literal
 ListTerm getAsListOfTerms()
          returns this literal as a list with three elements: [functor, list of terms, list of annots]
abstract  java.lang.String getFunctor()
          returns the functor of this literal
 PredicateIndicator getPredicateIndicator()
          returns functor symbol "/" arity
 java.util.List<VarTerm> getSingletonVars()
          returns all singleton vars (that appears once) in this literal
 ListTerm getSources()
          returns the sources of this literal as a new list.
 Term getTerm(int i)
          returns the i-th term (first term is 0)
 java.util.List<Term> getTerms()
          returns all terms of this literal
 Term[] getTermsArray()
          returns all terms of this literal as an array
 boolean hasAnnot()
          returns true if the pred has at least one annot
 boolean hasAnnot(Term t)
          returns true if there is some annotation t in the literal
 boolean hasSource()
          returns true if this literal has some source annotation
 boolean hasSource(Term agName)
          returns true if this literal has a "source(agName)"
 boolean hasSubsetAnnot(Literal p)
          returns true if all this predicate annots are in p's annots
 boolean hasSubsetAnnot(Literal p, Unifier u)
          Returns true if all this predicate's annots are in p's annots using the unifier u.
 boolean hasTerm()
          returns true if this literal has some term
 boolean importAnnots(Literal p)
          "import" annots from another predicate p.
 boolean isLiteral()
           
 java.util.Iterator<Unifier> logicalConsequence(Agent ag, Unifier un)
          logicalConsequence checks whether one particular predicate is a logical consequence of the belief base.
 void makeTermsAnnon()
          replaces all terms by unnamed variables (_).
 Literal makeVarsAnnon()
          replaces all variables by unnamed variables (_).
 Literal makeVarsAnnon(Unifier un)
          replaces all variables of the term for unnamed variables (_).
 boolean negated()
          returns whether this literal is negated or not, use Literal.LNeg and Literal.LPos to compare the returned value
static Literal newFromListOfTerms(ListTerm lt)
          creates a literal from a list with three elements: [functor, list of terms, list of annots]
static Literal parseLiteral(java.lang.String sLiteral)
          creates a new literal by parsing a string -- ASSyntax.parseLiteral or createLiteral are preferred.
 Literal setAnnots(ListTerm l)
           
 Literal setNegated(boolean b)
          changes the negation of the literal and return this
 void setTerm(int i, Term t)
           
 Literal setTerms(java.util.List<Term> l)
          set all terms of the literal and return this
 
Methods inherited from class jason.asSyntax.DefaultTerm
apply, calcHashCode, clone, compareTo, countVars, getErrorMsg, getSrcInfo, hashCode, hasVar, isArithExpr, isAtom, isGround, isInternalAction, isList, isNumeric, isPlanBody, isPred, isRule, isString, isStructure, isUnnamedVar, isVar, parse, resetHashCodeCache, setSrcInfo
 
Methods inherited from class java.lang.Object
equals, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface jason.asSyntax.Term
apply, clone, countVars, equals, getSrcInfo, hasVar, isArithExpr, isAtom, isGround, isInternalAction, isList, isNumeric, isPlanBody, isPred, isRule, isString, isStructure, isUnnamedVar, isVar, setSrcInfo
 
Methods inherited from interface java.lang.Comparable
compareTo
 
Methods inherited from interface jason.util.ToDOM
getAsDOM
 

Field Detail

LPos

public static final boolean LPos
See Also:
Constant Field Values

LNeg

public static final boolean LNeg
See Also:
Constant Field Values

LTrue

public static final Literal LTrue

LFalse

public static final Literal LFalse

predicateIndicatorCache

protected PredicateIndicator predicateIndicatorCache
Constructor Detail

Literal

public Literal()
Method Detail

parseLiteral

public static Literal parseLiteral(java.lang.String sLiteral)
creates a new literal by parsing a string -- ASSyntax.parseLiteral or createLiteral are preferred.


copy

public Literal copy()

getFunctor

public abstract java.lang.String getFunctor()
returns the functor of this literal


isLiteral

public boolean isLiteral()
Specified by:
isLiteral in interface Term
Overrides:
isLiteral in class DefaultTerm

getPredicateIndicator

public PredicateIndicator getPredicateIndicator()
returns functor symbol "/" arity


getArity

public int getArity()
returns the number of terms of this literal


hasTerm

public boolean hasTerm()
returns true if this literal has some term


getTerms

public java.util.List<Term> getTerms()
returns all terms of this literal


getTermsArray

public Term[] getTermsArray()
returns all terms of this literal as an array


getSingletonVars

public java.util.List<VarTerm> getSingletonVars()
returns all singleton vars (that appears once) in this literal


makeTermsAnnon

public void makeTermsAnnon()
replaces all terms by unnamed variables (_).


makeVarsAnnon

public Literal makeVarsAnnon()
replaces all variables by unnamed variables (_).


makeVarsAnnon

public Literal makeVarsAnnon(Unifier un)
replaces all variables of the term for unnamed variables (_).

Parameters:
un - is the unifier that contains the map of replacements

getAnnots

public ListTerm getAnnots()
returns all annotations of the literal


hasAnnot

public boolean hasAnnot(Term t)
returns true if there is some annotation t in the literal


hasAnnot

public boolean hasAnnot()
returns true if the pred has at least one annot


hasSubsetAnnot

public boolean hasSubsetAnnot(Literal p)
returns true if all this predicate annots are in p's annots


hasSubsetAnnot

public boolean hasSubsetAnnot(Literal p,
                              Unifier u)
Returns true if all this predicate's annots are in p's annots using the unifier u. if p annots has a Tail, p annots's Tail will receive this predicate's annots, e.g.: this[a,b,c] = p[x,y,b|T] unifies and T is [a,c] (this will be a subset if p has a and c in its annots). if this annots has a tail, the Tail will receive all necessary term to be a subset, e.g.: this[b|T] = p[x,y,b] unifies and T is [x,y] (this will be a subset if T is [x,y].


clearAnnots

public void clearAnnots()
removes all annotations


getAnnots

public ListTerm getAnnots(java.lang.String functor)
returns all annots with the specified functor e.g.: from annots [t(a), t(b), source(tom)] and functor "t", it returns [t(a),t(b)] in case that there is no such an annot, it returns an empty list.


getSources

public ListTerm getSources()
returns the sources of this literal as a new list. e.g.: from annots [source(a), source(b)], it returns [a,b]


hasSource

public boolean hasSource()
returns true if this literal has some source annotation


hasSource

public boolean hasSource(Term agName)
returns true if this literal has a "source(agName)"


canBeAddedInBB

public boolean canBeAddedInBB()
returns this if this literal can be added in the belief base (Atoms, for instance, can not be)


negated

public boolean negated()
returns whether this literal is negated or not, use Literal.LNeg and Literal.LPos to compare the returned value


equalsAsStructure

public boolean equalsAsStructure(java.lang.Object p)

addTerm

public void addTerm(Term t)

delTerm

public void delTerm(int index)

addTerms

public Literal addTerms(Term... ts)
adds some terms and return this


addTerms

public Literal addTerms(java.util.List<Term> l)
adds some terms and return this


getTerm

public Term getTerm(int i)
returns the i-th term (first term is 0)


setTerms

public Literal setTerms(java.util.List<Term> l)
set all terms of the literal and return this


setTerm

public void setTerm(int i,
                    Term t)

setAnnots

public Literal setAnnots(ListTerm l)

addAnnot

public boolean addAnnot(Term t)

addAnnots

public Literal addAnnots(Term... terms)
adds some annots and return this


addAnnots

public Literal addAnnots(java.util.List<Term> l)
adds some annots and return this


delAnnot

public boolean delAnnot(Term t)

delAnnots

public boolean delAnnots(java.util.List<Term> l)
removes all annots in this pred that are in the list l.

Returns:
true if some annot was removed.

importAnnots

public boolean importAnnots(Literal p)
"import" annots from another predicate p. p will be changed to contain only the annots actually imported (for Event), for example: p = b[a,b] this = b[b,c] after import, p = b[a] It is used to generate event <+b[a]>.

Returns:
true if some annot was imported.

addSource

public void addSource(Term agName)
adds the annotation source(agName)


delSource

public boolean delSource(Term agName)
deletes one source(agName) annotation, return true if deleted


delSources

public void delSources()
deletes all source annotations


setNegated

public Literal setNegated(boolean b)
changes the negation of the literal and return this


logicalConsequence

public java.util.Iterator<Unifier> logicalConsequence(Agent ag,
                                                      Unifier un)
logicalConsequence checks whether one particular predicate is a logical consequence of the belief base. Returns an iterator for all unifiers that are logCons.

Specified by:
logicalConsequence in interface LogicalFormula

getAsListOfTerms

public ListTerm getAsListOfTerms()
returns this literal as a list with three elements: [functor, list of terms, list of annots]


newFromListOfTerms

public static Literal newFromListOfTerms(ListTerm lt)
                                  throws JasonException
creates a literal from a list with three elements: [functor, list of terms, list of annots]

Throws:
JasonException

forceFullLiteralImpl

public Literal forceFullLiteralImpl()
Transforms this into a full literal (which implements all methods of Literal), if it is an Atom; otherwise returns 'this'