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)