Uses of Interface
astra.term.Term

Packages that use Term

Package	Description
astra.core
astra.debugger
astra.formula
astra.messaging
astra.reasoner
astra.reasoner.node
astra.reasoner.unifier
astra.reasoner.util
astra.statement
astra.term
astra.tr
astra.type

Uses of Term in astra.core

Methods in astra.core that return Term

Modifier and Type	Method	Description
Term	Intention.getValue(Variable term)
Term	RuleExecutor.getValue(Variable term)
Term	ActionParam.toLogic()

Methods in astra.core that return types with arguments of type Term

Modifier and Type	Method	Description
Map<Integer,Term>	Intention.bindings()
Map<Integer,Term>	RuleExecutor.bindings()
Map<Integer,Term>	StatementExecutor.bindings()
static Map<Integer,Term>	Helper.evaluateRule(Agent agent, Rule rule, Event event)
Map<Integer,Term>	RuleExecutor.getAllBindings()
Map<Integer,Term>	RuleExecutor.getUnboundBindings()
List<Map<Integer,Term>>	Agent.query(Formula formula, Map<Integer,Term> bindings)
Map<Integer,Term>	Intention.query(Formula formula)
List<Map<Integer,Term>>	Agent.queryAll(Formula formula)
List<Map<Integer,Term>>	Intention.queryAll(Formula formula)

Methods in astra.core with parameters of type Term

Modifier and Type	Method	Description
void	Fragment.addModule(String name, Class<?> cls, Term[] params, Agent agent)
void	RuleExecutor.addVariable(Variable variable, Term term)
<T> T	Intention.evaluate(Term term)
boolean	Intention.updateVariable(Variable term, Term logic)	Moves down through the ruleexecutor stack looking for a ruleexecutor that has the variable being updated...
boolean	RuleExecutor.updateVariable(Variable term, Term logic)
boolean	StatementExecutor.updateVariable(Variable term, Term logic)

Method parameters in astra.core with type arguments of type Term

Modifier and Type	Method	Description
void	RuleExecutor.addBindings(Map<Integer,Term> bindings)
void	RuleExecutor.addStatement(StatementHandler handler, Map<Integer,Term> bindings)
void	Intention.addSubGoal(Event event, Rule rule, Map<Integer,Term> bindings, RuleExecutor parent)
List<Map<Integer,Term>>	Agent.query(Formula formula, Map<Integer,Term> bindings)
void	RuleExecutor.updateRuleBindings(Map<Integer,Term> bindings)

Constructor parameters in astra.core with type arguments of type Term

Constructor	Description
Intention(Agent agent, Event event, Rule rule, Map<Integer,Term> bindings)
RuleExecutor(Event event, Rule rule, Map<Integer,Term> bindings, RuleExecutor parent, Intention intention)
StatementExecutor(StatementHandler handler, Map<Integer,Term> bindings)

Uses of Term in astra.debugger

Method parameters in astra.debugger with type arguments of type Term

Modifier and Type	Method	Description
void	Breakpoints.check(Agent agent, Rule rule, Event _event, Map<Integer,Term> bindings)
void	Breakpoints.check(Agent agent, Rule rule, Formula context, List<Map<Integer,Term>> results)

Uses of Term in astra.formula

Methods in astra.formula that return Term

Modifier and Type	Method	Description
Term	AcreFormula.cid()
Term	IsNull.formula()
Term	Predicate.getTerm(int i)
Term	AcreFormula.index()
Term	Comparison.left()
Term	AcreFormula.performative()
Term	Comparison.right()
Term	Bind.term()
Term	Predicate.termAt(int i)
Term[]	Predicate.terms()
Term	AcreFormula.type()

Constructors in astra.formula with parameters of type Term

Constructor	Description
AcreFormula(Term cid, Term index, Term type, Term performative, Formula content)
Bind(Variable variable, Term term)
Comparison(String operator, Term left, Term right)
IsNull(Term term)
Predicate(String predicate, Term[] terms)

Uses of Term in astra.messaging

Fields in astra.messaging declared as Term

Modifier and Type	Field	Description
Term[]	Utilities.PredicateState.terms

Methods in astra.messaging that return Term

Modifier and Type	Method	Description
Term	MessageEvent.params()
Term	MessageEvent.performative()
Term	MessageEvent.sender()

Constructors in astra.messaging with parameters of type Term

Constructor	Description
MessageEvent(Term performative, Term sender, Formula content)
MessageEvent(Term performative, Term sender, Formula content, Term params)

Uses of Term in astra.reasoner

Methods in astra.reasoner that return types with arguments of type Term

Modifier and Type	Method	Description
List<Map<Integer,Term>>	NewReasoner.query(Formula formula)
List<Map<Integer,Term>>	NewReasoner.query(Formula formula, Map<Integer,Term> bindings)
List<Map<Integer,Term>>	Reasoner.query(Formula formula)
List<Map<Integer,Term>>	Reasoner.query(Formula formula, Map<Integer,Term> bindings)
List<Map<Integer,Term>>	NewReasoner.queryAll(Formula formula)
List<Map<Integer,Term>>	Reasoner.queryAll(Formula formula)
Map<Integer,Term>	EventUnifier.unify(T source, T target, Agent agent)
Map<Integer,Term>	FormulaUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
static Map<Integer,Term>	Unifier.unify(Event source, Event target, Agent agent)
static Map<Integer,Term>	Unifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
static Map<Integer,Term>	Unifier.unify(Goal source, Goal target, Agent agent)	Generate variable bindings for two achievement goals or return null if there is no binding...
static Map<Integer,Term>	Unifier.unify(Predicate source, Predicate target, Agent agent)	Generate variable bindings for two predicates or return null if there is no binding...
static Map<Integer,Term>	Unifier.unify(Term[] source, Term[] target, Map<Integer,Term> bindings, Agent agent)

Methods in astra.reasoner with parameters of type Term

Modifier and Type	Method	Description
static Map<Integer,Term>	Unifier.unify(Term[] source, Term[] target, Map<Integer,Term> bindings, Agent agent)

Method parameters in astra.reasoner with type arguments of type Term

Modifier and Type	Method	Description
ReasonerNode	NewReasoner.createReasonerNode(ReasonerNode parent, Formula formula, Map<Integer,Term> bindings, boolean singleResult)
List<Map<Integer,Term>>	NewReasoner.query(Formula formula, Map<Integer,Term> bindings)
List<Map<Integer,Term>>	Reasoner.query(Formula formula, Map<Integer,Term> bindings)
Map<Integer,Term>	FormulaUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
static Map<Integer,Term>	Unifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
static Map<Integer,Term>	Unifier.unify(Term[] source, Term[] target, Map<Integer,Term> bindings, Agent agent)

Uses of Term in astra.reasoner.node

Fields in astra.reasoner.node with type parameters of type Term

Modifier and Type	Field	Description
protected Map<Integer,Term>	ReasonerNode.initial
protected List<Map<Integer,Term>>	ReasonerNode.solutions

Methods in astra.reasoner.node that return types with arguments of type Term

Modifier and Type	Method	Description
List<Map<Integer,Term>>	ReasonerNode.solutions()

Method parameters in astra.reasoner.node with type arguments of type Term

Modifier and Type	Method	Description
ReasonerNode	ANDReasonerNodeFactory.create(AND formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ANDReasonerNodeFactory.create(ReasonerNode parent, AND formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	BindReasonerNodeFactory.create(Bind formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	BindReasonerNodeFactory.create(ReasonerNode parent, Bind formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	BracketReasonerNodeFactory.create(BracketFormula formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	BracketReasonerNodeFactory.create(ReasonerNode parent, BracketFormula formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ComparisonReasonerNodeFactory.create(Comparison formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ComparisonReasonerNodeFactory.create(ReasonerNode parent, Comparison formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	IsDoneReasonerNodeFactory.create(IsDone formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	IsDoneReasonerNodeFactory.create(ReasonerNode parent, IsDone formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ModuleFormulaReasonerNodeFactory.create(ModuleFormula formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ModuleFormulaReasonerNodeFactory.create(ReasonerNode parent, ModuleFormula formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	NOTReasonerNodeFactory.create(NOT formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	NOTReasonerNodeFactory.create(ReasonerNode parent, NOT formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ORReasonerNodeFactory.create(OR formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ORReasonerNodeFactory.create(ReasonerNode parent, OR formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	PredicateReasonerNodeFactory.create(Predicate formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	PredicateReasonerNodeFactory.create(ReasonerNode parent, Predicate formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ReasonerNodeFactory.create(ReasonerNode node, T formula, Map<Integer,Term> bindings, boolean singleResult)
ReasonerNode	ReasonerNodeFactory.create(T formula, Map<Integer,Term> bindings, boolean singleResult)

Constructor parameters in astra.reasoner.node with type arguments of type Term

Constructor	Description
ANDReasonerNode(ReasonerNode parent, AND and, Map<Integer,Term> initial, boolean singleResult)
BindReasonerNode(ReasonerNode parent, Bind bind, Map<Integer,Term> initial, boolean singleResult)
BracketReasonerNode(ReasonerNode parent, BracketFormula formula, Map<Integer,Term> initial, boolean singleResult)
ComparisonReasonerNode(ReasonerNode parent, Comparison comparison, Map<Integer,Term> initial, boolean singleResult)
IsDoneReasonerNode(ReasonerNode parent, IsDone isDone, Map<Integer,Term> initial, boolean singleResult)
ModuleFormulaReasonerNode(ReasonerNode parent, ModuleFormula formula, Map<Integer,Term> initial, boolean singleResult)
NOTReasonerNode(ReasonerNode parent, NOT not, Map<Integer,Term> initial, boolean singleResult)
ORReasonerNode(ReasonerNode parent, OR or, Map<Integer,Term> initial, boolean singleResult)
PredicateReasonerNode(ReasonerNode parent, Predicate predicate, Map<Integer,Term> initial, boolean singleResult)

Uses of Term in astra.reasoner.unifier

Methods in astra.reasoner.unifier that return types with arguments of type Term

Modifier and Type	Method	Description
Map<Integer,Term>	AcreFormulaUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
Map<Integer,Term>	ANDUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
Map<Integer,Term>	BeliefEventUnifier.unify(BeliefEvent source, BeliefEvent target, Agent agent)
Map<Integer,Term>	FormulaVariableUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
Map<Integer,Term>	GoalEventUnifier.unify(GoalEvent source, GoalEvent target, Agent agent)
Map<Integer,Term>	MessageEventUnifier.unify(MessageEvent s, MessageEvent t, Agent agent)
Map<Integer,Term>	PredicateUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)

Method parameters in astra.reasoner.unifier with type arguments of type Term

Modifier and Type	Method	Description
Map<Integer,Term>	AcreFormulaUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
Map<Integer,Term>	ANDUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
Map<Integer,Term>	FormulaVariableUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)
Map<Integer,Term>	PredicateUnifier.unify(Formula source, Formula target, Map<Integer,Term> bindings, Agent agent)

Uses of Term in astra.reasoner.util

Methods in astra.reasoner.util with type parameters of type Term

Modifier and Type	Method	Description
static <T extends Term> void	AbstractEvaluateVisitor.addTermHandler(AbstractEvaluateVisitor.Handler<T> handler)
static <T extends Term> void	BindingsEvaluateVisitor.addTermHandler(BindingsEvaluateVisitor.Handler<T> handler)
static <T extends Term> void	ContextEvaluateVisitor.addTermHandler(ContextEvaluateVisitor.Handler<T> handler)
static <T extends Term> void	RenameVisitor.addTermHandler(RenameVisitor.Handler<T> handler)
static <T extends Term> void	VariableVisitor.addTermHandler(VariableVisitor.Handler<T> handler)

Methods in astra.reasoner.util that return types with arguments of type Term

Modifier and Type	Method	Description
Map<Integer,Term>	RenameVisitor.bindings()
static Map<Integer,Term>	Utilities.filter(Map<Integer,Term> source, Set<Variable> variables)
static Map<Integer,Term>	Utilities.merge(Map<Integer,Term> mapA, Map<Integer,Term> mapB)
static Map<Integer,Term>	Utilities.mgu(Map<Integer,Term> source)

Methods in astra.reasoner.util with parameters of type Term

Modifier and Type	Method	Description
<T> T	BindingsEvaluateVisitor.evaluate(Term term)
Object	AbstractEvaluateVisitor.visit(Term term)
Object	BindingsEvaluateVisitor.visit(Term term)
Object	ContextEvaluateVisitor.visit(Term term)
Object	LogicVisitor.visit(Term term)
Object	RenameVisitor.visit(Term term)
Object	VariableVisitor.visit(Term term)

Method parameters in astra.reasoner.util with type arguments of type Term

Modifier and Type	Method	Description
static Map<Integer,Term>	Utilities.filter(Map<Integer,Term> source, Set<Variable> variables)
Object	BindingsEvaluateVisitor.Handler.handle(LogicVisitor visitor, T object, Map<Integer,Term> bindings, Agent agent)
Object	RenameVisitor.Handler.handle(LogicVisitor visitor, T object, String modifier, Map<Integer,Term> bindings)
static Map<Integer,Term>	Utilities.merge(Map<Integer,Term> mapA, Map<Integer,Term> mapB)
static Map<Integer,Term>	Utilities.mgu(Map<Integer,Term> source)

Constructor parameters in astra.reasoner.util with type arguments of type Term

Constructor	Description
BindingsEvaluateVisitor(Map<Integer,Term> bindings, Agent agent)

Uses of Term in astra.statement

Constructors in astra.statement with parameters of type Term

Constructor	Description
Assignment(Variable variable, Term value)
Assignment(Variable variable, String clazz, int[] data, Term value)
Declaration(Variable variable, Term value)
Declaration(Variable variable, String clazz, int[] data, Term value)
ForAll(String clazz, int[] data, Variable variable, Term list, Statement body)
MinusMinus(Variable variable, String clazz, int[] data, Term value)
PlusPlus(Variable variable, String clazz, int[] data, Term value)
Send(String clazz, int[] data, Term performative, Term name, Formula content)
Send(String clazz, int[] data, Term performative, Term name, Formula content, Term params)
Wait(String clazz, int[] data, Formula guard, Term timeout)

Uses of Term in astra.term

Classes in astra.term that implement Term

Modifier and Type	Class	Description
class	AtIndex
class	Brackets
class	Count
class	FormulaTerm
class	FromJson
class	Funct
class	Head
class	ListSplitter
class	ListTerm
class	ModuleTerm
class	NullTerm
class	Operator
class	Performative
class	Primitive<T>
class	QueryTerm
class	Tail
class	ToJson
class	Variable

Fields in astra.term declared as Term

Modifier and Type	Field	Description
static Term[]	Term.EMPTY_ARRAY
static Term	Term.NULL_TERM

Methods in astra.term that return Term

Modifier and Type	Method	Description
Term	Term.clone()
Term	ListTerm.get(int i)
Term	Funct.getTerm(int i)
Term	ListSplitter.head()
Term	AtIndex.index()
Term	Operator.left()
Term	ListTerm.remove(int index)
Term	Operator.right()
Term	ListTerm.set(int index, Term element)
Term	AtIndex.term()
Term	Brackets.term()
Term	Count.term()
Term	FromJson.term()
Term	Head.term()
Term	Tail.term()
Term	ToJson.term()
Term	Funct.termAt(int i)
Term[]	Funct.terms()
Term[]	ListTerm.terms()
Term[]	ListTerm.toArray()

Methods in astra.term that return types with arguments of type Term

Modifier and Type	Method	Description
Iterator<Term>	ListTerm.iterator()
ListIterator<Term>	ListTerm.listIterator()
ListIterator<Term>	ListTerm.listIterator(int index)

Methods in astra.term with parameters of type Term

Modifier and Type	Method	Description
void	ListTerm.add(int index, Term element)
boolean	ListTerm.add(Term e)
<T> T	ModuleTermAdaptor.evaluate(BindingsEvaluateVisitor visitor, Term term)
boolean	AtIndex.matches(Term right)
boolean	Brackets.matches(Term term)
boolean	Count.matches(Term right)
boolean	FormulaTerm.matches(Term term)
boolean	FromJson.matches(Term right)
boolean	Funct.matches(Term term)
boolean	Head.matches(Term right)
boolean	ListSplitter.matches(Term term)
boolean	ListTerm.matches(Term right)
boolean	ModuleTerm.matches(Term right)
boolean	NullTerm.matches(Term right)
boolean	Operator.matches(Term term)
boolean	Performative.matches(Term term)
boolean	Primitive.matches(Term term)
boolean	QueryTerm.matches(Term term)
boolean	Tail.matches(Term right)
boolean	Term.matches(Term right)
boolean	ToJson.matches(Term right)
boolean	Variable.matches(Term right)
static Operator	Operator.newOperator(char op, Term left, Term right)
void	Funct.set(int i, Term term)
Term	ListTerm.set(int index, Term element)
static Object[]	LangUtils.toArray(Term[] terms)

Method parameters in astra.term with type arguments of type Term

Modifier and Type	Method	Description
boolean	ListTerm.addAll(int index, Collection<? extends Term> c)
boolean	ListTerm.addAll(Collection<? extends Term> c)

Constructors in astra.term with parameters of type Term

Constructor	Description
AtIndex(Term term, Term index, Type type)
Brackets(Term term)
Count(Term term)
FromJson(Term term, String type)
Funct(String predicate, Term[] terms)
Head(Term term, Type type)
ListSplitter(Term head, Variable tail)
ListTerm(Term[] terms)
Operator(char op, Type type, Term left, Term right)
Tail(Term term)
ToJson(Term term)

Uses of Term in astra.tr

Methods in astra.tr with parameters of type Term

Modifier and Type	Method	Description
<T> T	TRContext.getValue(Term term)

Method parameters in astra.tr with type arguments of type Term

Modifier and Type	Method	Description
boolean	ActionHandler.execute(TRContext context, Map<Integer,Term> bindings)
void	TRRule.execute(TRContext Context, Map<Integer,Term> bindings)

Uses of Term in astra.type

Fields in astra.type declared as Term

Modifier and Type	Field	Description
static Term	Type.NO_VALUE

Methods in astra.type that return Term

Modifier and Type	Method	Description
static Term	Type.defaultValue(Type type)

Methods in astra.type with parameters of type Term

Modifier and Type	Method	Description
static double	Type.doubleValue(Term term)
static float	Type.floatValue(Term term)
static int	Type.integerValue(Term term)
static boolean	Type.isNumeric(Term il)
static long	Type.longValue(Term term)
static String	Type.stringValue(Term term)