Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## jason.asSyntax
Class Literal

    java.lang.Object
      jason.asSyntax.DefaultTerm
          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:

- Atom -- the most simple literal, is composed by only a functor (no term, no annots);
- Structure -- has functor and terms;
- Pred -- has functor, terms, and annotations;
- LiteralImpl -- Pred + negation.

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'

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD