|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Literal | |
---|---|
jason.architecture | |
jason.asSemantics | |
jason.asSyntax | |
jason.bb | |
jason.environment | |
jason.infra.centralised | |
jason.infra.jade | |
jason.stdlib | Provides all default internal actions of Jason. |
Uses of Literal in jason.architecture |
---|
Methods in jason.architecture that return types with arguments of type Literal | |
---|---|
java.util.List<Literal> |
AgArchInfraTier.perceive()
Gets the agent's perception as a list of Literals |
java.util.List<Literal> |
AgArch.perceive()
Gets the agent's perception as a list of Literals. |
Uses of Literal in jason.asSemantics |
---|
Methods in jason.asSemantics that return Literal | |
---|---|
Literal |
Agent.findBel(Literal bel,
Unifier un)
Find a literal in BB using unification to test. |
Literal |
ActionExec.getFailureReason()
|
Methods in jason.asSemantics that return types with arguments of type Literal | |
---|---|
java.util.List<Literal> |
Agent.getInitialBels()
|
Methods in jason.asSemantics with parameters of type Literal | |
---|---|
void |
Agent.abolish(Literal bel,
Unifier un)
Removes all occurrences of bel in BB. |
Event |
Circumstance.addAchvGoal(Literal l,
Intention i)
|
boolean |
Agent.addBel(Literal bel)
Adds bel in belief base (calling brf) and generates the events. |
void |
Agent.addInitialBel(Literal b)
|
void |
Agent.addInitialGoal(Literal g)
|
java.util.List<Literal>[] |
Agent.brf(Literal beliefToAdd,
Literal beliefToDel,
Intention i)
This function should revise the belief base with the given literal to add, to remove, and the current intention that triggered the operation. |
boolean |
Agent.delBel(Literal bel)
If the agent believes in bel, removes it (calling brf) and generate the event. |
Literal |
Agent.findBel(Literal bel,
Unifier un)
Find a literal in BB using unification to test. |
Term[] |
InternalAction.prepareArguments(Literal body,
Unifier un)
Prepare body's terms to be used in 'execute', normally it consist of cloning and applying each term |
Term[] |
DefaultInternalAction.prepareArguments(Literal body,
Unifier un)
|
Term[] |
ConcurrentInternalAction.prepareArguments(Literal body,
Unifier un)
|
void |
ActionExec.setFailureReason(Literal reason,
java.lang.String msg)
|
Method parameters in jason.asSemantics with type arguments of type Literal | |
---|---|
void |
Agent.buf(java.util.List<Literal> percepts)
Belief Update Function: adds/removes percepts into belief base |
Constructors in jason.asSemantics with parameters of type Literal | |
---|---|
ActionExec(Literal ac,
Intention i)
|
Uses of Literal in jason.asSyntax |
---|
Subclasses of Literal in jason.asSyntax | |
---|---|
class |
ArithExpr
Represents and solve arithmetic expressions like "10 + 30". |
class |
ArithFunctionTerm
Represents an arithmetic function, like math.max(arg1,arg2) -- a functor (math.max) and two arguments. |
class |
Atom
Represents an atom (a positive literal with no argument and no annotation, e.g. |
class |
BinaryStructure
Represents a binary/unary logical/relational operator. |
class |
BodyLiteral
Deprecated. use PlanBodyImpl instead. |
class |
InternalActionLiteral
A particular type of literal used to represent internal actions (has a "." in the functor). |
class |
ListTermImpl
Represents a list node as in prolog .(t1,.(t2,.(t3,.))). |
class |
LiteralImpl
A Literal extends a Pred with strong negation (~). |
class |
LogExpr
Represents a logical formula with some logical operator ("&", "|", "not"). |
class |
Plan
Represents an AgentSpack plan (it extends structure to be used as a term) |
class |
PlanBodyImpl
Represents a plan body item (achieve, test, action, ...) and its successors. |
class |
Pred
A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2]. |
class |
RelExpr
Represents a relational expression like 10 > 20. |
class |
Rule
A rule is a Literal (head) with a body, as in "a :- b & c". |
class |
Structure
Represents a structure: a functor with n arguments, e.g.: val(10,x(3)). |
class |
Trigger
Represents an AgentSpeak trigger (like +!g, +p, ...). |
class |
UnnamedVar
Represents an unnamed variable '_'. |
class |
VarTerm
Represents a variable Term: like X (starts with upper case). |
Fields in jason.asSyntax declared as Literal | |
---|---|
static Literal |
Literal.LFalse
|
static Literal |
Literal.LTrue
|
Methods in jason.asSyntax that return Literal | |
---|---|
Literal |
VarTerm.addAnnots(java.util.List<Term> l)
|
Literal |
Pred.addAnnots(java.util.List<Term> l)
|
Literal |
Literal.addAnnots(java.util.List<Term> l)
adds some annots and return this |
Literal |
Pred.addAnnots(Term... l)
|
Literal |
Literal.addAnnots(Term... terms)
adds some annots and return this |
Literal |
VarTerm.addTerms(java.util.List<Term> l)
|
Literal |
Structure.addTerms(java.util.List<Term> l)
|
Literal |
Literal.addTerms(java.util.List<Term> l)
adds some terms and return this |
Literal |
Structure.addTerms(Term... ts)
|
Literal |
Literal.addTerms(Term... ts)
adds some terms and return this |
Literal |
Literal.copy()
|
static Literal |
ASSyntax.createLiteral(boolean positive,
java.lang.String functor,
Term... terms)
Creates a new literal, the first argument is either Literal.LPos or Literal.LNeg, the second is the functor (a string), and the n remainder arguments are terms. |
static Literal |
ASSyntax.createLiteral(java.lang.String functor,
Term... terms)
Creates a new positive literal, the first argument is the functor (a string) and the n remainder arguments are terms. |
Literal |
Literal.forceFullLiteralImpl()
Transforms this into a full literal (which implements all methods of Literal), if it is an Atom; otherwise returns 'this' |
Literal |
Trigger.getLiteral()
|
Literal |
Rule.headClone()
|
Literal |
Structure.makeVarsAnnon()
|
Literal |
Literal.makeVarsAnnon()
replaces all variables by unnamed variables (_). |
Literal |
VarTerm.makeVarsAnnon(Unifier un)
|
Literal |
Structure.makeVarsAnnon(Unifier un)
|
Literal |
Rule.makeVarsAnnon(Unifier un)
|
Literal |
Pred.makeVarsAnnon(Unifier un)
|
Literal |
Literal.makeVarsAnnon(Unifier un)
replaces all variables of the term for unnamed variables (_). |
Literal |
ArithFunctionTerm.makeVarsAnnon(Unifier un)
|
static Literal |
Literal.newFromListOfTerms(ListTerm lt)
creates a literal from a list with three elements: [functor, list of terms, list of annots] |
static Literal |
Literal.parseLiteral(java.lang.String sLiteral)
creates a new literal by parsing a string -- ASSyntax.parseLiteral or createLiteral are preferred. |
static Literal |
ASSyntax.parseLiteral(java.lang.String sLiteral)
creates a new literal by parsing a string |
Literal |
VarTerm.setAnnots(ListTerm l)
|
Literal |
Pred.setAnnots(ListTerm l)
|
Literal |
Literal.setAnnots(ListTerm l)
|
Literal |
LiteralImpl.setNegated(boolean b)
|
Literal |
Literal.setNegated(boolean b)
changes the negation of the literal and return this |
Literal |
VarTerm.setTerms(java.util.List<Term> l)
|
Literal |
Structure.setTerms(java.util.List<Term> l)
|
Literal |
Literal.setTerms(java.util.List<Term> l)
set all terms of the literal and return this |
Methods in jason.asSyntax with parameters of type Literal | |
---|---|
static Rule |
ASSyntax.createRule(Literal head,
LogicalFormula body)
Creates a new rule with a head and a body |
boolean |
VarTerm.hasSubsetAnnot(Literal p)
|
boolean |
Pred.hasSubsetAnnot(Literal p)
|
boolean |
Literal.hasSubsetAnnot(Literal p)
returns true if all this predicate annots are in p's annots |
boolean |
VarTerm.hasSubsetAnnot(Literal p,
Unifier u)
|
boolean |
Pred.hasSubsetAnnot(Literal p,
Unifier u)
|
boolean |
Literal.hasSubsetAnnot(Literal p,
Unifier u)
Returns true if all this predicate's annots are in p's annots using the unifier u. |
boolean |
VarTerm.importAnnots(Literal p)
|
boolean |
Pred.importAnnots(Literal p)
|
boolean |
Literal.importAnnots(Literal p)
"import" annots from another predicate p. |
void |
Trigger.setLiteral(Literal literal)
|
Constructors in jason.asSyntax with parameters of type Literal | |
---|---|
Atom(Literal l)
|
|
LiteralImpl(boolean pos,
Literal l)
if pos == true, the literal is positive, otherwise it is negative |
|
LiteralImpl(Literal l)
|
|
Pred(Literal l)
|
|
Rule(Literal head,
LogicalFormula body)
|
|
Structure(Literal l)
|
|
Trigger(Trigger.TEOperator op,
Trigger.TEType t,
Literal l)
|
Uses of Literal in jason.bb |
---|
Fields in jason.bb with type parameters of type Literal | |
---|---|
protected java.util.Set<Literal> |
DefaultBeliefBase.percepts
set of beliefs with percept annot, used to improve performance of buf |
Methods in jason.bb that return Literal | |
---|---|
Literal |
JDBCPersistentBB.contains(Literal l)
|
Literal |
DefaultBeliefBase.contains(Literal l)
|
Literal |
ChainBBAdapter.contains(Literal l)
|
Literal |
BeliefBase.contains(Literal l)
Returns the literal l as it is in BB, this method does not consider annotations in the search. |
protected Literal |
JDBCPersistentBB.resultSetToLiteral(java.sql.ResultSet rs,
PredicateIndicator pi)
translates the current line of a result set into a Literal |
Methods in jason.bb that return types with arguments of type Literal | |
---|---|
java.util.Iterator<Literal> |
DefaultBeliefBase.getAll()
Deprecated. use iterator() instead of getAll |
java.util.Iterator<Literal> |
ChainBBAdapter.getAll()
|
java.util.Iterator<Literal> |
BeliefBase.getAll()
Deprecated. use iterator() instead of getAll |
java.util.Iterator<Literal> |
JDBCPersistentBB.getCandidateBeliefs(Literal l,
Unifier u)
|
java.util.Iterator<Literal> |
DefaultBeliefBase.getCandidateBeliefs(Literal l,
Unifier u)
|
java.util.Iterator<Literal> |
ChainBBAdapter.getCandidateBeliefs(Literal l,
Unifier u)
|
java.util.Iterator<Literal> |
BeliefBase.getCandidateBeliefs(Literal l,
Unifier u)
Returns an iterator for all literals relevant for l's predicate indicator, if l is a var, returns all beliefs. The unifier u may contain values for variables in l. |
java.util.Iterator<Literal> |
DefaultBeliefBase.getCandidateBeliefs(PredicateIndicator pi)
|
java.util.Iterator<Literal> |
ChainBBAdapter.getCandidateBeliefs(PredicateIndicator pi)
|
java.util.Iterator<Literal> |
BeliefBase.getCandidateBeliefs(PredicateIndicator pi)
Returns an iterator for all literals in BB that match the functor/arity of the parameter. |
java.util.Iterator<Literal> |
DefaultBeliefBase.getPercepts()
|
java.util.Iterator<Literal> |
ChainBBAdapter.getPercepts()
|
java.util.Iterator<Literal> |
BeliefBase.getPercepts()
Returns all beliefs that have "percept" as source |
java.util.Iterator<Literal> |
DefaultBeliefBase.getRelevant(Literal l)
Deprecated. use getCandidateBeliefs(l,null) instead |
java.util.Iterator<Literal> |
ChainBBAdapter.getRelevant(Literal l)
|
java.util.Iterator<Literal> |
BeliefBase.getRelevant(Literal l)
Deprecated. use getCandidateBeliefs(l,null) instead |
java.util.Iterator<Literal> |
JDBCPersistentBB.iterator()
|
java.util.Iterator<Literal> |
DefaultBeliefBase.iterator()
|
java.util.Iterator<Literal> |
ChainBBAdapter.iterator()
|
java.util.Iterator<Literal> |
BeliefBase.iterator()
Returns an iterator for all beliefs. |
Methods in jason.bb with parameters of type Literal | |
---|---|
boolean |
DefaultBeliefBase.add(int index,
Literal l)
|
boolean |
ChainBBAdapter.add(int index,
Literal l)
|
boolean |
BeliefBase.add(int index,
Literal l)
Adds a belief in the BB at index position, returns true if succeed |
boolean |
JDBCPersistentBB.add(Literal l)
|
boolean |
IndexedBB.add(Literal bel)
|
boolean |
DefaultBeliefBase.add(Literal l)
|
boolean |
ChainBBAdapter.add(Literal l)
|
boolean |
BeliefBase.add(Literal l)
Adds a belief in the end of the BB, returns true if succeed. |
protected boolean |
DefaultBeliefBase.add(Literal l,
boolean addInEnd)
|
Literal |
JDBCPersistentBB.contains(Literal l)
|
Literal |
DefaultBeliefBase.contains(Literal l)
|
Literal |
ChainBBAdapter.contains(Literal l)
|
Literal |
BeliefBase.contains(Literal l)
Returns the literal l as it is in BB, this method does not consider annotations in the search. |
java.util.Iterator<Literal> |
JDBCPersistentBB.getCandidateBeliefs(Literal l,
Unifier u)
|
java.util.Iterator<Literal> |
DefaultBeliefBase.getCandidateBeliefs(Literal l,
Unifier u)
|
java.util.Iterator<Literal> |
ChainBBAdapter.getCandidateBeliefs(Literal l,
Unifier u)
|
java.util.Iterator<Literal> |
BeliefBase.getCandidateBeliefs(Literal l,
Unifier u)
Returns an iterator for all literals relevant for l's predicate indicator, if l is a var, returns all beliefs. The unifier u may contain values for variables in l. |
protected java.lang.String |
JDBCPersistentBB.getInsert(Literal l)
returns the SQL command to insert l into the DB |
protected java.lang.String |
AgentJDBCPersistentBB.getInsert(Literal l)
|
java.util.Iterator<Literal> |
DefaultBeliefBase.getRelevant(Literal l)
Deprecated. use getCandidateBeliefs(l,null) instead |
java.util.Iterator<Literal> |
ChainBBAdapter.getRelevant(Literal l)
|
java.util.Iterator<Literal> |
BeliefBase.getRelevant(Literal l)
Deprecated. use getCandidateBeliefs(l,null) instead |
protected java.lang.String |
JDBCPersistentBB.getSelect(Literal l)
returns the SQL command for a select that retrieves the literal l from the DB |
protected java.lang.String |
JDBCPersistentBB.getTableName(Literal l)
|
protected java.lang.String |
JDBCPersistentBB.getWhere(Literal l)
returns the where clausule for a select for literal l |
protected java.lang.String |
AgentJDBCPersistentBB.getWhere(Literal l)
|
protected boolean |
JDBCPersistentBB.isDB(Literal l)
returns true if the literal is stored in a DB |
boolean |
JDBCPersistentBB.remove(Literal l)
|
boolean |
DefaultBeliefBase.remove(Literal l)
|
boolean |
ChainBBAdapter.remove(Literal l)
|
boolean |
BeliefBase.remove(Literal l)
Removes a literal from BB, returns true if succeed |
Uses of Literal in jason.environment |
---|
Methods in jason.environment that return types with arguments of type Literal | |
---|---|
java.util.List<Literal> |
TimeSteppedEnvironment.getPercepts(java.lang.String agName)
stops perception while executing the step's actions |
java.util.List<Literal> |
Environment.getPercepts(java.lang.String agName)
Returns percepts for an agent. |
Methods in jason.environment with parameters of type Literal | |
---|---|
void |
Environment.addPercept(Literal per)
Adds a perception for all agents |
void |
Environment.addPercept(java.lang.String agName,
Literal per)
Adds a perception for a specific agent |
boolean |
Environment.containsPercept(Literal per)
Returns true if the list of common percepts contains the perception per. |
boolean |
Environment.containsPercept(java.lang.String agName,
Literal per)
|
boolean |
Environment.removePercept(Literal per)
Removes a perception in the common perception list |
boolean |
Environment.removePercept(java.lang.String agName,
Literal per)
Removes a perception for an agent |
int |
Environment.removePerceptsByUnif(Literal per)
Removes all percepts in the common perception list that unifies with per. |
int |
Environment.removePerceptsByUnif(java.lang.String agName,
Literal per)
Removes from an agent perception all percepts that unifies with per. |
Uses of Literal in jason.infra.centralised |
---|
Methods in jason.infra.centralised that return types with arguments of type Literal | |
---|---|
java.util.List<Literal> |
CentralisedAgArch.perceive()
|
Uses of Literal in jason.infra.jade |
---|
Methods in jason.infra.jade that return types with arguments of type Literal | |
---|---|
java.util.List<Literal> |
JadeAgArch.perceive()
|
Uses of Literal in jason.stdlib |
---|
Methods in jason.stdlib with parameters of type Literal | |
---|---|
boolean |
desire.desires(Circumstance C,
Literal l,
Unifier un)
|
void |
succeed_goal.drop(TransitionSystem ts,
Literal l,
Unifier un)
|
void |
drop_desire.dropEvt(Circumstance C,
Literal l,
Unifier un)
|
void |
drop_intention.dropInt(Circumstance C,
Literal l,
Unifier un)
|
boolean |
intend.intends(Circumstance C,
Literal l,
Unifier un)
|
Term[] |
loop.prepareArguments(Literal body,
Unifier un)
|
Term[] |
if_then_else.prepareArguments(Literal body,
Unifier un)
|
Term[] |
foreach.prepareArguments(Literal body,
Unifier un)
|
Term[] |
findall.prepareArguments(Literal body,
Unifier un)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |