Uses of Package
jason.asSyntax

Packages that use jason.asSyntax
jason   
jason.architecture   
jason.asSemantics   
jason.asSyntax   
jason.asSyntax.directives   
jason.asSyntax.patterns.goal   
jason.bb   
jason.environment   
jason.functions   
jason.infra.centralised   
jason.infra.jade   
jason.infra.saci   
jason.mas2j   
jason.stdlib Provides all default internal actions of Jason. 
 

Classes in jason.asSyntax used by jason
ListTerm
          The interface for lists of the AgentSpeak language
Term
          Common interface for all kind of terms
 

Classes in jason.asSyntax used by jason.architecture
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
 

Classes in jason.asSyntax used by jason.asSemantics
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
LogicalFormula
          Represents a logical formula (p, p & q, not p, 3 > X, ...) which can be evaluated into a truth value.
Plan
          Represents an AgentSpack plan (it extends structure to be used as a term)
PlanBody
          Interface for elements of a plans's body.
PlanLibrary
          Represents a set of plans used by an agent
Pred
          A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2].
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
Term
          Common interface for all kind of terms
Trigger
          Represents an AgentSpeak trigger (like +!g, +p, ...).
VarTerm
          Represents a variable Term: like X (starts with upper case).
 

Classes in jason.asSyntax used by jason.asSyntax
ArithExpr.ArithmeticOp
           
ArithFunctionTerm
          Represents an arithmetic function, like math.max(arg1,arg2) -- a functor (math.max) and two arguments.
Atom
          Represents an atom (a positive literal with no argument and no annotation, e.g.
BinaryStructure
          Represents a binary/unary logical/relational operator.
BodyLiteral.BodyType
          Deprecated. Use BodyType of PlanBody instead
DefaultTerm
          Base class for all terms.
InternalActionLiteral
          A particular type of literal used to represent internal actions (has a "." in the functor).
ListTerm
          The interface for lists of the AgentSpeak language
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
LiteralImpl
          A Literal extends a Pred with strong negation (~).
LogExpr.LogicalOp
           
LogicalFormula
          Represents a logical formula (p, p & q, not p, 3 > X, ...) which can be evaluated into a truth value.
NumberTerm
          The interface for numeric terms of AgentSpeak language
NumberTermImpl
          Immutable class that implements a term that represents a number
ObjectTerm
          Interface for terms that encapsulate java objects
Plan
          Represents an AgentSpack plan (it extends structure to be used as a term)
PlanBody
          Interface for elements of a plans's body.
PlanBody.BodyType
           
PlanBodyImpl
          Represents a plan body item (achieve, test, action, ...) and its successors.
PlanLibrary
          Represents a set of plans used by an agent
Pred
          A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2].
PredicateIndicator
          Represents the "type" of a predicate based on the functor and the arity, e.g.: ask/4
RelExpr.RelationalOp
           
Rule
          A rule is a Literal (head) with a body, as in "a :- b & c".
SourceInfo
          Store information about the file source of some term (atom, literal, etc).
StringTerm
          The interface for string terms of the AgentSpeak language
StringTermImpl
          Immutable class for string terms.
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
Term
          Common interface for all kind of terms
Trigger
          Represents an AgentSpeak trigger (like +!g, +p, ...).
Trigger.TEOperator
           
Trigger.TEType
           
VarTerm
          Represents a variable Term: like X (starts with upper case).
 

Classes in jason.asSyntax used by jason.asSyntax.directives
Pred
          A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2].
 

Classes in jason.asSyntax used by jason.asSyntax.patterns.goal
Pred
          A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2].
 

Classes in jason.asSyntax used by jason.bb
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
PredicateIndicator
          Represents the "type" of a predicate based on the functor and the arity, e.g.: ask/4
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
Term
          Common interface for all kind of terms
 

Classes in jason.asSyntax used by jason.environment
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
 

Classes in jason.asSyntax used by jason.functions
Term
          Common interface for all kind of terms
 

Classes in jason.asSyntax used by jason.infra.centralised
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
 

Classes in jason.asSyntax used by jason.infra.jade
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
 

Classes in jason.asSyntax used by jason.infra.saci
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
 

Classes in jason.asSyntax used by jason.mas2j
Structure
          Represents a structure: a functor with n arguments, e.g.: val(10,x(3)).
 

Classes in jason.asSyntax used by jason.stdlib
Literal
          This class represents an abstract literal (an Atom, Structure, Predicate, etc), it is mainly the interface of a literal.
Term
          Common interface for all kind of terms