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

## Uses of Interface
jason.asSyntax.Term

Packages that use Term
jason |
jason.asSemantics |
jason.asSyntax |
jason.bb |
jason.functions |
jason.stdlib | Provides all default internal actions of Jason.

Uses of Term in jason

Fields in jason declared as Term
`static Term` | `JasonException.UNKNOW_ERROR`
`static Term` | `JasonException.WRONG_ARGS`

Methods in jason with parameters of type Term
`void` | `JasonException.addErrorAnnot(Term t)`
`static ListTerm` | `JasonException.createBasicErrorAnnots(Term id, java.lang.String msg)`

Constructors in jason with parameters of type Term
`JasonException(java.lang.String msg, Term error)` Constructs an instance of `JasonException` with the specified detail message and error description term.
`JasonException(java.lang.String msg, Term error, java.lang.Exception cause)`

Uses of Term in jason.asSemantics

Fields in jason.asSemantics with type parameters of type Term
`protected java.util.HashMap<VarTerm,Term>` | `Unifier.function`

Methods in jason.asSemantics that return Term
`Term` | `Unifier.get(java.lang.String var)` gets the value for a Var, if it is unified with another var, gets this other's value
`Term` | `Unifier.get(VarTerm vtp)` gets the value for a Var, if it is unified with another var, gets this other's value
`Term` | `Unifier.getAsTerm()`
`Term` | `Intention.getAsTerm()`
`Term` | `IntendedMeans.getAsTerm()`
`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)`
`Term` | `IntendedMeans.removeCurrentStep()` removes the current action of the IM and returns the term of the body

Methods in jason.asSemantics with parameters of type Term
`void` | `Unifier.apply(Term t)` Deprecated. use t.apply(un) instead.
`protected void` | `DefaultInternalAction.checkArguments(Term[] args)`
`double` | `DefaultArithFunction.evaluate(TransitionSystem ts, Term[] args)`
`double` | `ArithFunction.evaluate(TransitionSystem ts, Term[] args)` evaluates/computes the function based on the args
`java.lang.Object` | `InternalAction.execute(TransitionSystem ts, Unifier un, Term[] args)` Executes the internal action.
`java.lang.Object` | `DefaultInternalAction.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `ConcurrentInternalAction.execute(TransitionSystem ts, Unifier un, Term[] args)`
`boolean` | `Unifier.unifies(Term t1, Term t2)` this version of unifies undo the variables' mapping if the unification fails.
`boolean` | `Unifier.unifiesNoUndo(Term t1g, Term t2g)` this version of unifies does not undo the variables' mapping in case of failure.
`protected boolean` | `Unifier.unifyTerms(Term t1g, Term t2g)`

Method parameters in jason.asSemantics with type arguments of type Term
`boolean` | `TransitionSystem.generateGoalDeletion(Intention i, java.util.List<Term> failAnnots)` generate a failure event for an intention
`static void` | `ConcurrentInternalAction.resume(TransitionSystem ts, java.lang.String intentionKey, boolean abort, java.util.List<Term> failAnnots)`

Uses of Term in jason.asSyntax

Subinterfaces of Term in jason.asSyntax
`interface` | `ListTerm` The interface for lists of the AgentSpeak language
`interface` | `LogicalFormula` Represents a logical formula (p, p & q, not p, 3 > X, ...) which can be evaluated into a truth value.
`interface` | `NumberTerm` The interface for numeric terms of AgentSpeak language
`interface` | `ObjectTerm` Interface for terms that encapsulate java objects
`interface` | `PlanBody` Interface for elements of a plans's body.
`interface` | `StringTerm` The interface for string terms of the AgentSpeak language

Classes in jason.asSyntax that implement Term
`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` | `DefaultTerm` Base class for all terms.
`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` | `Literal` This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
`class` | `LiteralImpl` A Literal extends a Pred with strong negation (~).
`class` | `LogExpr` Represents a logical formula with some logical operator ("&", "|", "not").
`class` | `NumberTermImpl` Immutable class that implements a term that represents a number
`class` | `ObjectTermImpl`
`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` | `StringTermImpl` Immutable class for string terms.
`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 Term
`protected static Term[]` | `Structure.emptyTermArray`

Fields in jason.asSyntax with type parameters of type Term
`protected static java.util.List<Term>` | `Structure.emptyTermList`

Methods in jason.asSyntax that return Term
`Term` | `VarTerm.clone()`
`Term` | `UnnamedVar.clone()`
`Term` | `Term.clone()`
`Term` | `Structure.clone()` make a deep copy of the terms
`Term` | `Pred.clone()`
`Term` | `Plan.clone()`
`Term` | `LiteralImpl.clone()`
`abstract Term` | `DefaultTerm.clone()`
`Term` | `Atom.clone()`
`static Term` | `Pred.createSource(Term source)`
`Term` | `VarTerm.get(int index)`
`Term` | `ListTermImpl.get(int index)`
`Term` | `VarTerm.getBodyTerm()`
`Term` | `PlanBodyImpl.getBodyTerm()`
`Term` | `PlanBody.getBodyTerm()`
`Term` | `BinaryStructure.getLHS()` gets the LHS of this operation
`Term` | `BinaryStructure.getRHS()` gets the RHS of this operation
`Term` | `VarTerm.getTerm()`
`Term` | `ListTermImpl.getTerm()` gets the term of this ListTerm
`Term` | `ListTerm.getTerm()`
`Term` | `VarTerm.getTerm(int i)`
`Term` | `Trigger.getTerm(int i)`
`Term` | `Structure.getTerm(int i)`
`Term` | `PlanBodyImpl.getTerm(int i)`
`Term` | `Plan.getTerm(int i)`
`Term` | `Literal.getTerm(int i)` returns the i-th term (first term is 0)
`Term` | `ListTermImpl.getTerm(int i)`
`Term[]` | `VarTerm.getTermsArray()`
`Term[]` | `Literal.getTermsArray()` returns all terms of this literal as an array
`Term` | `VarTerm.getValue()` returns the value of this var.
`static Term` | `DefaultTerm.parse(java.lang.String sTerm)` Deprecated. it is preferable to use ASSyntax.parseTerm
`static Term` | `ASSyntax.parseTerm(java.lang.String sTerm)` creates a new term by parsing a string
`Term` | `VarTerm.remove(int index)`
`Term` | `ListTermImpl.remove(int index)`
`Term` | `VarTerm.removeBody(int index)`
`Term` | `PlanBodyImpl.removeBody(int index)`
`Term` | `PlanBody.removeBody(int index)`
`Term` | `VarTerm.removeLast()`
`Term` | `ListTermImpl.removeLast()`
`Term` | `ListTerm.removeLast()`
`Term` | `VarTerm.set(int index, Term o)`
`Term` | `ListTermImpl.set(int index, Term t)`

Methods in jason.asSyntax that return types with arguments of type Term
`java.util.List<Term>` | `VarTerm.getAsList()`
`java.util.List<Term>` | `ListTermImpl.getAsList()` Returns this ListTerm as a Java List (implemented by ArrayList).
`java.util.List<Term>` | `ListTerm.getAsList()`
`java.util.List<Term>` | `VarTerm.getTerms()`
`java.util.List<Term>` | `Structure.getTerms()`
`java.util.List<Term>` | `Literal.getTerms()` returns all terms of this literal
`java.util.List<Term>` | `ListTermImpl.getTerms()` return the this ListTerm elements (0=Term, 1=ListTerm)
`java.util.Iterator<Term>` | `VarTerm.iterator()`
`java.util.Iterator<Term>` | `ListTermImpl.iterator()` returns an iterator where each element is a Term of this list, the tail of the list is not considered.
`java.util.ListIterator<Term>` | `VarTerm.listIterator()`
`java.util.ListIterator<Term>` | `ListTermImpl.listIterator()`
`java.util.ListIterator<Term>` | `VarTerm.listIterator(int index)`
`java.util.ListIterator<Term>` | `ListTermImpl.listIterator(int startIndex)`
`java.util.List<Term>` | `VarTerm.subList(int arg0, int arg1)`
`java.util.List<Term>` | `ListTermImpl.subList(int arg0, int arg1)`
`java.util.Iterator<java.util.List<Term>>` | `VarTerm.subSets(int k)`
`java.util.Iterator<java.util.List<Term>>` | `ListTermImpl.subSets(int k)` returns all subsets that take k elements of this list
`java.util.Iterator<java.util.List<Term>>` | `ListTerm.subSets(int k)` returns all subsets that take k elements of this list

Methods in jason.asSyntax with parameters of type Term
`void` | `VarTerm.add(int index, Term o)`
`void` | `ListTermImpl.add(int index, Term o)`
`Plan` | `PlanLibrary.add(Plan p, Term source, boolean before)` Add a new plan in PL.
`Plan` | `PlanLibrary.add(StringTerm stPlan, Term tSource)` Deprecated. parse the plan before (ASSyntax methods) and call add(Plan, ...) methods
`Plan` | `PlanLibrary.add(StringTerm stPlan, Term tSource, boolean before)` Deprecated. parse the plan before (ASSyntax methods) and call add(Plan, ...) methods
`boolean` | `VarTerm.add(Term o)`
`boolean` | `ListTermImpl.add(Term o)`
`boolean` | `VarTerm.addAnnot(Term t)`
`boolean` | `Pred.addAnnot(Term t)`
`boolean` | `Literal.addAnnot(Term t)`
`Literal` | `Pred.addAnnots(Term... l)`
`Literal` | `Literal.addAnnots(Term... terms)` adds some annots and return this
`void` | `VarTerm.addSource(Term t)`
`void` | `Pred.addSource(Term agName)`
`void` | `Literal.addSource(Term agName)` adds the annotation source(agName)
`void` | `VarTerm.addTerm(Term t)`
`void` | `Structure.addTerm(Term t)`
`void` | `Literal.addTerm(Term t)`
`void` | `ListTermImpl.addTerm(Term t)`
`Literal` | `Structure.addTerms(Term... ts)`
`Literal` | `Literal.addTerms(Term... ts)` adds some terms and return this
`ListTerm` | `VarTerm.append(Term t)`
`ListTerm` | `ListTermImpl.append(Term t)` Adds a term in the end of the list
`ListTerm` | `ListTerm.append(Term t)`
`int` | `VarTerm.compareTo(Term t)`
`int` | `UnnamedVar.compareTo(Term t)`
`int` | `Structure.compareTo(Term t)`
`int` | `StringTermImpl.compareTo(Term o)`
`int` | `Pred.compareTo(Term t)`
`int` | `NumberTermImpl.compareTo(Term o)`
`int` | `LiteralImpl.compareTo(Term t)`
`int` | `ListTermImpl.compareTo(Term o)`
`int` | `DefaultTerm.compareTo(Term t)`
`int` | `Atom.compareTo(Term t)`
`int` | `ArithFunctionTerm.compareTo(Term o)`
`static ListTerm` | `ASSyntax.createList(Term... terms)` Creates a new list with n elements, n can be 0
`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.
`static Term` | `Pred.createSource(Term source)`
`static Structure` | `ASSyntax.createStructure(java.lang.String functor, Term... terms)` Creates a new structure (compound) term, the first argument is the functor (a string), and the n remainder arguments are terms.
`boolean` | `VarTerm.delAnnot(Term t)`
`boolean` | `Pred.delAnnot(Term t)`
`boolean` | `Literal.delAnnot(Term t)`
`boolean` | `VarTerm.delSource(Term s)`
`boolean` | `Pred.delSource(Term agName)`
`boolean` | `Literal.delSource(Term agName)` deletes one source(agName) annotation, return true if deleted
`boolean` | `VarTerm.hasAnnot(Term t)`
`boolean` | `Pred.hasAnnot(Term t)`
`boolean` | `Literal.hasAnnot(Term t)` returns true if there is some annotation t in the literal
`boolean` | `VarTerm.hasSource(Term s)`
`boolean` | `Pred.hasSource(Term agName)`
`boolean` | `Literal.hasSource(Term agName)` returns true if this literal has a "source(agName)"
`ListTerm` | `VarTerm.insert(Term t)`
`ListTerm` | `ListTermImpl.insert(Term t)` insert a term in the begin of this list
`ListTerm` | `ListTerm.insert(Term t)`
`boolean` | `PlanLibrary.remove(Atom pLabel, Term source)` Remove a plan represented by the label pLabel.
`Term` | `VarTerm.set(int index, Term o)`
`Term` | `ListTermImpl.set(int index, Term t)`
`void` | `VarTerm.setBodyTerm(Term t)`
`void` | `PlanBodyImpl.setBodyTerm(Term t)`
`void` | `PlanBody.setBodyTerm(Term t)`
`void` | `VarTerm.setNext(Term t)`
`void` | `ListTermImpl.setNext(Term l)`
`void` | `ListTerm.setNext(Term l)`
`void` | `VarTerm.setTerm(int i, Term t)`
`void` | `Trigger.setTerm(int i, Term t)`
`void` | `Structure.setTerm(int i, Term t)`
`void` | `PlanBodyImpl.setTerm(int i, Term t)`
`void` | `Plan.setTerm(int i, Term t)`
`void` | `Literal.setTerm(int i, Term t)`
`void` | `ListTermImpl.setTerm(int i, Term t)`
`void` | `VarTerm.setTerm(Term t)`
`void` | `ListTermImpl.setTerm(Term t)`
`void` | `ListTerm.setTerm(Term t)`
`boolean` | `VarTerm.setValue(Term vl)` grounds a variable, set a value for this var (e.g.
`static Trigger` | `Trigger.tryToGetTrigger(Term t)` try to convert the term t into a trigger, in case t is a trigger term, a string that can be parsed to a trigger, a var with value trigger, ....
`protected VarTerm` | `Structure.varToReplace(Term t, Unifier un)`

Method parameters in jason.asSyntax with type arguments of type Term
`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` | `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
`static ListTerm` | `ASSyntax.createList(java.util.Collection<Term> terms)` Creates a new list from a collection of terms (each element of the collection is cloned)
`boolean` | `VarTerm.delAnnots(java.util.List<Term> l)`
`boolean` | `Pred.delAnnots(java.util.List<Term> l)`
`boolean` | `Literal.delAnnots(java.util.List<Term> l)` removes all annots in this pred that are in the list l.
`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

Constructors in jason.asSyntax with parameters of type Term
`BinaryStructure(java.lang.String id, Term arg)` Constructor for unary operator
`BinaryStructure(Term t1, java.lang.String id, Term t2)` Constructor for binary operator
`BodyLiteral(BodyLiteral.BodyType t, Term b)` Deprecated.
`PlanBodyImpl(PlanBody.BodyType t, Term b)`
`RelExpr(Term t1, RelExpr.RelationalOp oper, Term t2)`

Uses of Term in jason.bb

Fields in jason.bb declared as Term
`static Term` | `BeliefBase.APercept`
`static Term` | `BeliefBase.ASelf`
`static Term` | `BeliefBase.TPercept` represents the structure 'source(percept)'
`static Term` | `BeliefBase.TSelf` represents the structure 'source(self)'

Methods in jason.bb with parameters of type Term
`static java.sql.Timestamp` | `JDBCPersistentBB.structure2timestamp(Term timestamp)` translates structure like "timestamp(Y,M,D,H,M,S)" into a SQL timestamp

Uses of Term in jason.functions

Methods in jason.functions with parameters of type Term
`double` | `time.evaluate(TransitionSystem ts, Term[] args)`
`double` | `pi.evaluate(TransitionSystem ts, Term[] args)`
`double` | `log.evaluate(TransitionSystem ts, Term[] args)`
`double` | `floor.evaluate(TransitionSystem ts, Term[] args)`
`double` | `e.evaluate(TransitionSystem ts, Term[] args)`
`double` | `ceil.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Sum.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Sqrt.evaluate(TransitionSystem ts, Term[] args)`
`double` | `RuleToFunction.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Round.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Random.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Min.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Max.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Length.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Count.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Average.evaluate(TransitionSystem ts, Term[] args)`
`double` | `Abs.evaluate(TransitionSystem ts, Term[] args)`

Uses of Term in jason.stdlib

Methods in jason.stdlib that return Term
`Term` | `add_nested_source.addAnnotToList(Unifier unif, Term l, Term source)`
`protected Term` | `add_annot.addAnnotToList(Unifier unif, Term l, Term annot)`
`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)`

Methods in jason.stdlib with parameters of type Term
`Term` | `add_nested_source.addAnnotToList(Unifier unif, Term l, Term source)`
`protected Term` | `add_annot.addAnnotToList(Unifier unif, Term l, Term annot)`
`protected java.lang.String` | `println.argsToString(Term[] args)`
`protected void` | `suspended.checkArguments(Term[] args)`
`protected void` | `suspend.checkArguments(Term[] args)`
`protected void` | `suffix.checkArguments(Term[] args)`
`protected void` | `succeed_goal.checkArguments(Term[] args)`
`protected void` | `sublist.checkArguments(Term[] args)`
`protected void` | `sort.checkArguments(Term[] args)`
`protected void` | `send.checkArguments(Term[] args)`
`protected void` | `resume.checkArguments(Term[] args)`
`protected void` | `range.checkArguments(Term[] args)`
`protected void` | `random.checkArguments(Term[] args)`
`protected void` | `prefix.checkArguments(Term[] args)`
`protected void` | `nth.checkArguments(Term[] args)`
`protected void` | `min.checkArguments(Term[] args)`
`protected void` | `member.checkArguments(Term[] args)`
`protected void` | `loop.checkArguments(Term[] args)`
`protected void` | `intend.checkArguments(Term[] args)`
`protected void` | `if_then_else.checkArguments(Term[] args)`
`protected void` | `foreach.checkArguments(Term[] args)`
`protected void` | `findall.checkArguments(Term[] args)`
`protected void` | `drop_intention.checkArguments(Term[] args)`
`protected void` | `difference.checkArguments(Term[] args)`
`protected void` | `create_agent.checkArguments(Term[] args)`
`protected void` | `count.checkArguments(Term[] args)`
`protected void` | `broadcast.checkArguments(Term[] args)`
`protected void` | `abolish.checkArguments(Term[] args)`
`protected boolean` | `min.compare(Term a, Term t)`
`protected boolean` | `max.compare(Term a, Term t)`
`java.lang.Object` | `wait.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `union.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `time.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `term2string.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `suspended.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `suspend.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `suffix.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `succeed_goal.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `substring.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `sublist.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `structure.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `string.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `stopMAS.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `sort.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `send.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `reverse.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `resume.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `remove_plan.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `relevant_plans.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `range.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `random.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `puts.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `println.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `prefix.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `plan_label.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `perceive.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `number.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `nth.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `my_name.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `min.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `member.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `loop.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `literal.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `list_plans.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `list.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `length.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `kill_agent.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `intersection.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `intend.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `if_then_else.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `ground.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `foreach.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `findall.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `fail_goal.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `fail.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `drop_intention.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `drop_event.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `drop_desire.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `drop_all_intentions.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `drop_all_events.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `drop_all_desires.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `difference.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `desire.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `delete.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `date.execute(TransitionSystem ts, Unifier un, Term[] args)` date(YY,MM,DD)
`java.lang.Object` | `current_intention.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `create_agent.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `count.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `concat.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `broadcast.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `atom.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `at.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `all_names.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `add_plan.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `add_nested_source.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `add_annot.execute(TransitionSystem ts, Unifier un, Term[] args)`
`java.lang.Object` | `abolish.execute(TransitionSystem ts, Unifier un, Term[] args)`

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