Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
jason.asSyntax.Literal

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)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES