Package jason.asSyntax
Class Literal
java.lang.Object
jason.asSyntax.DefaultTerm
jason.asSyntax.Literal
- All Implemented Interfaces:
LogicalFormula
,Term
,ToDOM
,ToJson
,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.
There are useful static methods in class ASSyntax
to create Literals.
- Author:
- jomi
- See Also:
ASSyntax
,Atom
,Structure
,Pred
,LiteralImpl
, Serialized Form
-
Nested Class Summary
Nested Classes Modifier and Type Class Description private static class
Literal.DefaultNameSpace
(package private) static class
Literal.FalseLiteral
(package private) static class
Literal.TrueLiteral
-
Field Summary
Fields Modifier and Type Field Description static Atom
DefaultNS
private static java.util.List<VarTerm>
emptyListVar
static Literal
LFalse
static boolean
LNeg
private static java.util.logging.Logger
logger
static boolean
LPos
static Literal
LTrue
protected PredicateIndicator
predicateIndicatorCache
private static long
serialVersionUID
Fields inherited from class jason.asSyntax.DefaultTerm
hashCodeCache, srcInfo
-
Constructor Summary
Constructors Constructor Description Literal()
-
Method Summary
Modifier and Type Method Description boolean
addAnnot(Term t)
Literal
addAnnots(Term... terms)
adds some annots and return thisLiteral
addAnnots(java.util.List<Term> l)
adds some annots and return thisLiteral
addSource(Term agName)
adds the annotation source(agName)Literal
addSourceInfoAsAnnots(SourceInfo info)
void
addTerm(Term t)
Literal
addTerms(Term... ts)
adds some terms and return thisLiteral
addTerms(java.util.List<Term> l)
adds some terms and return thisboolean
canBeAddedInBB()
returns this if this literal can be added in the belief base (Atoms, for instance, can not be)Literal
clearAnnots()
removes all annotations and returns itselfLiteral
copy()
boolean
delAnnot(Term t)
boolean
delAnnots()
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 deletedvoid
delSources()
deletes all source annotationsvoid
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'Literal
getAnnot(java.lang.String functor)
returns the first annotation (literal) that has the functorListTerm
getAnnots()
returns all annotations of the literalListTerm
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 literaljavax.json.JsonValue
getAsJson()
ListTerm
getAsListOfTerms()
returns this literal as a list with three elements: [namespace, functor, list of terms, list of annots]abstract java.lang.String
getFunctor()
returns the functor of this literalabstract Atom
getNS()
returns the name spaceof this literalPredicateIndicator
getPredicateIndicator()
returns name space :: functor symbol / arityjava.util.List<VarTerm>
getSingletonVars()
returns all singleton vars (that appears once) in this literalListTerm
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 literalTerm[]
getTermsArray()
returns all terms of this literal as an arrayboolean
hasAnnot()
returns true if the pred has at least one annotboolean
hasAnnot(Term t)
returns true if there is some annotation t in the literalboolean
hasSource()
returns true if this literal has some source annotationboolean
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 annotsboolean
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 termboolean
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 valuestatic Literal
newFromListOfTerms(ListTerm lt)
creates a literal from a list with four elements: [namespace, functor, list of terms, list of annots] (namespace is optional)Literal
newFunctor(java.lang.String f)
Literal
noSource()
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 thisvoid
setTerm(int i, Term t)
Literal
setTerms(java.util.List<Term> l)
set all terms of the literal and return thisboolean
subjectToBUF()
returns this if this literal should be removed from BB while doing BUFprivate void
useDerefVars(Term p, Unifier un)
Methods inherited from class jason.asSyntax.DefaultTerm
calcHashCode, capply, clone, cloneNS, compareTo, countVars, getCyclicVar, getErrorMsg, getSrcInfo, hashCode, hasVar, isArithExpr, isAtom, isCyclicTerm, isGround, isInternalAction, isList, isMap, isNumeric, isPlanBody, isPred, isRule, isSet, isString, isStructure, isUnnamedVar, isVar, parse, resetHashCodeCache, setSrcInfo, subsumes
Methods inherited from class java.lang.Object
equals, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface java.lang.Comparable
compareTo
Methods inherited from interface jason.asSyntax.Term
capply, clone, cloneNS, countVars, equals, getCyclicVar, getSrcInfo, hasVar, isArithExpr, isAtom, isCyclicTerm, isGround, isInternalAction, isList, isMap, isNumeric, isPlanBody, isPred, isRule, isSet, isString, isStructure, isUnnamedVar, isVar, setSrcInfo, subsumes
Methods inherited from interface jason.util.ToJson
getAsJsonStr
-
Field Details
-
serialVersionUID
private static final long serialVersionUID- See Also:
- Constant Field Values
-
logger
private static java.util.logging.Logger logger -
LPos
public static final boolean LPos- See Also:
- Constant Field Values
-
LNeg
public static final boolean LNeg- See Also:
- Constant Field Values
-
DefaultNS
-
LTrue
-
LFalse
-
predicateIndicatorCache
-
emptyListVar
-
-
Constructor Details
-
Literal
public Literal()
-
-
Method Details
-
parseLiteral
creates a new literal by parsing a string -- ASSyntax.parseLiteral or createLiteral are preferred. -
copy
-
getFunctor
public abstract java.lang.String getFunctor()returns the functor of this literal -
newFunctor
-
getNS
returns the name spaceof this literal -
isLiteral
public boolean isLiteral()- Specified by:
isLiteral
in interfaceTerm
- Overrides:
isLiteral
in classDefaultTerm
-
getPredicateIndicator
returns name space :: 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
returns all terms of this literal -
getTermsArray
returns all terms of this literal as an array -
getSingletonVars
returns all singleton vars (that appears once) in this literal -
makeTermsAnnon
public void makeTermsAnnon()replaces all terms by unnamed variables (_). -
makeVarsAnnon
replaces all variables by unnamed variables (_). -
makeVarsAnnon
replaces all variables of the term for unnamed variables (_).- Parameters:
un
- is the unifier that contains the map of replacements
-
getAnnots
returns all annotations of the literal -
hasAnnot
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
returns true if all this predicate annots are in p's annots -
hasSubsetAnnot
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
removes all annotations and returns itself -
getAnnots
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. -
getAnnot
returns the first annotation (literal) that has the functor -
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
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) -
subjectToBUF
public boolean subjectToBUF()returns this if this literal should be removed from BB while doing BUF -
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
-
delTerm
public void delTerm(int index) -
addTerms
adds some terms and return this -
addTerms
adds some terms and return this -
getTerm
returns the i-th term (first term is 0) -
setTerms
set all terms of the literal and return this -
setTerm
-
setAnnots
-
addAnnot
-
addAnnots
adds some annots and return this -
addAnnots
adds some annots and return this -
delAnnot
-
delAnnots
removes all annots in this pred that are in the list l.- Returns:
- true if some annot was removed.
-
delAnnots
public boolean delAnnots() -
importAnnots
"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
adds the annotation source(agName) -
delSource
deletes one source(agName) annotation, return true if deleted -
delSources
public void delSources()deletes all source annotations -
noSource
-
setNegated
changes the negation of the literal and return this -
logicalConsequence
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 interfaceLogicalFormula
-
useDerefVars
-
getAsListOfTerms
returns this literal as a list with three elements: [namespace, functor, list of terms, list of annots] -
newFromListOfTerms
creates a literal from a list with four elements: [namespace, functor, list of terms, list of annots] (namespace is optional)- Throws:
JasonException
-
forceFullLiteralImpl
Transforms this into a full literal (which implements all methods of Literal), if it is an Atom; otherwise returns 'this' -
addSourceInfoAsAnnots
-
getAsJson
public javax.json.JsonValue getAsJson()
-