Uses of Class
org.jpc.term.Term

Packages that use Term

Package	Description
org.jpc
org.jpc.converter
org.jpc.converter.catalog
org.jpc.converter.catalog.datetime
org.jpc.converter.catalog.error
org.jpc.converter.catalog.list
org.jpc.converter.catalog.map
org.jpc.converter.typesolver	This package provides classes supporting the inference of the best target type for a given object in a conversion.
org.jpc.engine.embedded
org.jpc.engine.embedded.database
org.jpc.engine.logtalk
org.jpc.engine.prolog
org.jpc.error
org.jpc.error.handling
org.jpc.query
org.jpc.salt	SALT: The Streaming API for Logic Term processing (inspired by the SAX library for event-based processing of XML documents)
org.jpc.term
org.jpc.term.compiler	Classes in this package are used internally by the embedded Prolog engine.
org.jpc.term.expansion
org.jpc.term.refterm
org.jpc.term.unification
org.jpc.util
org.jpc.util.engine
org.jpc.util.salt

Uses of Term in org.jpc

Methods in org.jpc with type parameters of type Term

Modifier and Type	Method and Description
abstract <T extends Term> T	Jpc.toTerm(Object object)
<T extends Term> T	DefaultJpc.toTerm(Object object)
abstract <T extends Term> T	Jpc.toTerm(Object object, Class<T> termClass)
<T extends Term> T	DefaultJpc.toTerm(Object object, Class<T> targetType)

Methods in org.jpc with parameters of type Term

Modifier and Type	Method and Description
abstract <T> T	Jpc.fromTerm(Term term)
<T> T	DefaultJpc.fromTerm(Term term)
abstract <T> T	Jpc.fromTerm(Term term, Type type)
<T> T	DefaultJpc.fromTerm(Term term, Type targetType)
abstract boolean	Jpc.handleError(Term errorTerm, Term goal)
boolean	DefaultJpc.handleError(Term errorTerm, Term goal)
JpcBuilder	JpcBuilder.register(JpcConverter converter, Term term)
JpcBuilder	JpcBuilder.register(TypeSolver<?> typeSolver, Term term)

Uses of Term in org.jpc.converter

Classes in org.jpc.converter with type parameters of type Term

Modifier and Type	Interface and Description
interface	FromTermConverter<T extends Term,U>
class	FromTermConverterAdapter<T extends Term,V>
interface	TermConvertable<T extends Term> Implementors can be adapted to terms
interface	ToTermConverter<U,T extends Term>
class	ToTermConverterAdapter<T,V extends Term>

Methods in org.jpc.converter with type parameters of type Term

Modifier and Type	Method and Description
static <T extends Term,V> org.jgum.strategy.ChainOfResponsibility<org.jconverter.converter.Converter<T,V>,V>	FromTermConverterAdapter.chainConverters(List<FromTermConverter<T,V>> converters)
static <T,V extends Term> org.jgum.strategy.ChainOfResponsibility<org.jconverter.converter.Converter<T,V>,V>	ToTermConverterAdapter.chainConverters(List<ToTermConverter<T,V>> converters)
static <T extends Term,V> FromTermConverterAdapter	FromTermConverterAdapter.forConverter(FromTermConverter<T,V> converter)
static <T,V extends Term> ToTermConverterAdapter	ToTermConverterAdapter.forConverter(ToTermConverter<T,V> converter)
<T extends Term> T	JpcConverterManager.toTerm(Object object, Class<T> termClass, Jpc jpc)

Methods in org.jpc.converter with parameters of type Term

Modifier and Type	Method and Description
<T> T	JpcConverterManager.fromTerm(Object key, Term term, Type targetType, Jpc jpc)
<T> T	JpcConverterManager.fromTerm(Term term, Type targetType, Jpc jpc)
void	JpcConverterManager.register(JpcConverter converter, Term term)

Uses of Term in org.jpc.converter.catalog

Classes in org.jpc.converter.catalog with type parameters of type Term

Modifier and Type	Class and Description
class	TermConvertableConverter<T extends Term>
class	TermSpecifierConverter<T extends Term>

Uses of Term in org.jpc.converter.catalog.datetime

Classes in org.jpc.converter.catalog.datetime with type parameters of type Term

Modifier and Type	Class and Description
class	XMLGregorianCalendarConverter<T extends Term>

Uses of Term in org.jpc.converter.catalog.error

Methods in org.jpc.converter.catalog.error with parameters of type Term

Modifier and Type	Method and Description
PrologError	PrologErrorConverter.fromTerm(Term term, Type type, Jpc context)
static boolean	DomainErrorConverter.isDomainError(Term term)
static boolean	EvaluationErrorConverter.isEvaluationError(Term term)
static boolean	ExistenceErrorConverter.isExistenceError(Term term)
static boolean	InstantiationErrorConverter.isInstantiationError(Term term)
static boolean	IsoPrologErrorConverter.isIsoPrologError(Term errorTerm)
static boolean	PermissionErrorConverter.isPermissionError(Term term)
static boolean	RepresentationErrorConverter.isRepresentationError(Term term)
static boolean	ResourceErrorConverter.isResourceError(Term term)
static boolean	SyntaxErrorConverter.isSyntaxError(Term term)
static boolean	SystemErrorConverter.isSystemError(Term term)
static boolean	TypeErrorConverter.isTypeError(Term term)

Uses of Term in org.jpc.converter.catalog.list

Classes in org.jpc.converter.catalog.list with type parameters of type Term

Modifier and Type	Class and Description
class	ArrayConverter<T,U extends Term>
class	CollectionConverter<U extends Term,T extends Collection<?>>
class	EnumerationConverter<T extends Term>
class	IterableConverter<T extends Term>
class	IteratorConverter<T extends Term>

Methods in org.jpc.converter.catalog.list with parameters of type Term

Modifier and Type	Method and Description
T	CollectionConverter.fromTerm(Term listTerm, Type type, Jpc context)
T[]	ArrayConverter.fromTerm(Term listTerm, Type targetType, Jpc context)

Uses of Term in org.jpc.converter.catalog.map

Classes in org.jpc.converter.catalog.map with type parameters of type Term

Modifier and Type	Class and Description
static class	MapConverter.MapToTermConverter<T extends Map<?,?>,U extends Term>
static class	MapConverter.TermToMapConverter<T extends Term,U extends Map<?,?>>

Uses of Term in org.jpc.converter.typesolver

Methods in org.jpc.converter.typesolver with parameters of type Term

Modifier and Type	Method and Description
void	JpcTypeSolverManager.register(TypeSolver<?> typeSolver, Term term)

Uses of Term in org.jpc.engine.embedded

Methods in org.jpc.engine.embedded that return Term

Modifier and Type	Method and Description
Term	JpcEngine.asTerm(String termString, Jpc context)
Term	Clause.getHead()

Methods in org.jpc.engine.embedded with parameters of type Term

Modifier and Type	Method and Description
boolean	JpcEngine.asserta(Term term)
boolean	JpcEngine.assertz(Term term)
Query	JpcEngine.basicQuery(Term goal, boolean errorHandledQuery, Jpc context)
protected void	Clause.checkClauseHead(Term head)
boolean	JpcEngine.retractAll(Term term)
boolean	JpcEngine.retractOne(Term term)

Constructors in org.jpc.engine.embedded with parameters of type Term

Constructor and Description
Clause(Term head, Environment env)
JpcQuery(JpcEngine prologEngine, Term goal, boolean errorHandledQuery, Jpc context)
Rule(Term head, List<Term> body, Environment env)

Constructor parameters in org.jpc.engine.embedded with type arguments of type Term

Constructor and Description
Rule(Term head, List<Term> body, Environment env)

Uses of Term in org.jpc.engine.embedded.database

Classes in org.jpc.engine.embedded.database with type parameters of type Term

Modifier and Type	Class and Description
class	UpdatableIndexFunction<T extends Term,U>

Methods in org.jpc.engine.embedded.database that return types with arguments of type Term

Modifier and Type	Method and Description
UpdatableIndexFunction<Term,?>	IndexDescriptor.getIndexFunction()
UpdatableIndexFunction<Term,?>	Index.getIndexFunction()
com.google.common.base.Function<Term,List<IndexDescriptor>>	IndexDescriptor.getNextIndexDescriptorsFunction()

Methods in org.jpc.engine.embedded.database with parameters of type Term

Modifier and Type	Method and Description
Object	FunctorIndexFunction.apply(Term term)
Object	ArgumentIndexFunction.apply(Term term)
void	ClauseDatabase.asserta(Term term)
void	ClauseDatabase.assertz(Term term)
IndexedClauses	Index.getIndexedClauses(Term head)
IndexedClauses	Index.getOrCreateIndexedClauses(Term head)
Iterator<Clause>	IndexedClauses.indexedClausesIterator(Term head) This method answers an iterator of clauses which heads "may" unify with the parameter according to the existing indexes applicable to it.
boolean	Index.isIndexable(Term head)
boolean	ClauseDatabase.retract(Term term)
void	ClauseDatabase.retractAll(Term term)

Method parameters in org.jpc.engine.embedded.database with type arguments of type Term

Modifier and Type	Method and Description
static IndexDescriptor	IndexDescriptor.forFunctions(List<com.google.common.base.Function<Term,Object>> indexFunctions)
void	IndexChangeListener.onIndexChange(UpdatableIndexFunction<Term,Object> updatableIndexFunction)
void	Index.onIndexChange(UpdatableIndexFunction<Term,Object> updatableIndexFunction)

Constructors in org.jpc.engine.embedded.database with parameters of type Term

Constructor and Description
IndexedClauseIterator(Index index, Term head)
NonIndexableTermException(Term term, com.google.common.base.Function<Term,Object> indexFunction)

Constructor parameters in org.jpc.engine.embedded.database with type arguments of type Term

Constructor and Description
IndexDescriptor(com.google.common.base.Function<Term,?> indexFunction)
IndexDescriptor(com.google.common.base.Function<Term,?> indexFunction, com.google.common.base.Function<Term,List<IndexDescriptor>> nextIndexDescriptorsFunction)
IndexDescriptor(com.google.common.base.Function<Term,?> indexFunction, com.google.common.base.Function<Term,List<IndexDescriptor>> nextIndexDescriptorsFunction)
IndexDescriptor(UpdatableIndexFunction<Term,?> indexFunction)
IndexDescriptor(UpdatableIndexFunction<Term,?> indexFunction, com.google.common.base.Function<Term,List<IndexDescriptor>> nextIndexDescriptorsFunction)
IndexDescriptor(UpdatableIndexFunction<Term,?> indexFunction, com.google.common.base.Function<Term,List<IndexDescriptor>> nextIndexDescriptorsFunction)
IndexDescriptorAdapter(IndexDescriptor indexDescriptor, com.google.common.base.Function<Term,Term> adaptingFunction)
IndexDescriptorAdapter(IndexDescriptor indexDescriptor, com.google.common.base.Function<Term,Term> adaptingFunction)
NonIndexableTermException(Term term, com.google.common.base.Function<Term,Object> indexFunction)

Uses of Term in org.jpc.engine.logtalk

Classes in org.jpc.engine.logtalk with type parameters of type Term

Modifier and Type	Class and Description
class	LogtalkObject<T extends Term>

Methods in org.jpc.engine.logtalk that return Term

Modifier and Type	Method and Description
Term	LogtalkLibraryDescription.getTermPath()
Term	LogtalkObject.message(Term message)
Term	LogtalkObject.name()

Methods in org.jpc.engine.logtalk with parameters of type Term

Modifier and Type	Method and Description
boolean	LogtalkObject.abolish(Term term)
Query	LogtalkEngine.abolishCategory(Term category)
Query	LogtalkEngine.abolishEvents(Term event, Term object, Term message, Term sender, Term monitor)
Query	LogtalkEngine.abolishObject(Term object)
Query	LogtalkEngine.abolishProtocol(Term protocol)
boolean	LogtalkObject.asserta(Term term)
boolean	LogtalkObject.assertz(Term term)
Query	LogtalkEngine.categoryProperty(Term category, Term property)
Query	LogtalkObject.clause(Term head, Term body)
Query	Logtalk.compileAuxClauses(Term clauses)
Query	Logtalk.compilePredicateHeads(Term heads, Term translatedHeads)
Query	Logtalk.compilePredicateHeads(Term heads, Term translatedHeads, Term contextArgument)
Query	Logtalk.compilePredicateHeads(Term heads, Term entity, Term translatedHeads, Term contextArgument)
Query	Logtalk.compilePredicateIndicators(Term predicateIndicators, Term translatedPredicateIndicators)
Query	Logtalk.compilePredicateIndicators(Term predicateIndicators, Term entity, Term translatedPredicateIndicators)
Query	LogtalkEngine.complementsObject(Term category, Term object)
Query	LogtalkEngine.conformsToProtocol(Term object, Term protocol)
Query	LogtalkEngine.conformsToProtocol(Term object, Term protocol, Term scope)
Query	LogtalkEngine.createCategory(Term category, Term relations, Term directives, Term Clauses)
Query	LogtalkEngine.createObject(Term object, Term relations, Term directives, Term Clauses)
Query	LogtalkEngine.createProtocol(Term protocol, Term relations, Term directives)
Query	LogtalkEngine.currentCategory(Term category)
Query	LogtalkEngine.currentEvent(Term event, Term object, Term message, Term sender, Term monitor)
Query	LogtalkEngine.currentObject(Term term)
Query	LogtalkObject.currentOp(Term priority, Term specifier, Term operator)
Query	LogtalkObject.currentPredicate(Term predicate)
Query	LogtalkEngine.currentProtocol(Term protocol)
Query	Logtalk.debugHandler(Term event, Term eventExecutionContext)
Query	Logtalk.debugHandlerProvider(Term provider)
Query	Logtalk.decompilePredicateHeads(Term translatedHeads, Term heads)
Query	Logtalk.decompilePredicateHeads(Term translatedHeads, Term entity, Term heads)
Query	Logtalk.decompilePredicateHeads(Term translatedHeads, Term entity, Term entityType, Term heads)
Query	Logtalk.decompilePredicateIndicators(Term translatedPredicateIndicators, Term predicateIndicators)
Query	Logtalk.decompilePredicateIndicators(Term translatedPredicateIndicators, Term entity, Term predicateIndicators)
Query	Logtalk.decompilePredicateIndicators(Term translatedPredicateIndicators, Term entity, Term entityType, Term predicateIndicators)
Query	LogtalkEngine.defineEvents(Term event, Term object, Term message, Term sender, Term monitor)
Query	Logtalk.entityPrefix(Term entity, Term prefix)
Query	Logtalk.executionContext(Term executionContext, Term sender, Term thiz, Term self, Term metacallContext, Term stack)
Query	Logtalk.expandLibraryPath(Term library, Term path)
Query	LogtalkEngine.extendsCategory(Term child, Term parent)
Query	LogtalkEngine.extendsCategory(Term child, Term parent, Term scope)
Query	LogtalkEngine.extendsObject(Term child, Term parent)
Query	LogtalkEngine.extendsObject(Term child, Term parent, Term scope)
Query	LogtalkEngine.extendsProtocol(Term child, Term parent)
Query	LogtalkEngine.extendsProtocol(Term child, Term parent, Term scope)
Query	LogtalkEngine.implementsProtocol(Term object, Term protocol)
Query	LogtalkEngine.implementsProtocol(Term object, Term protocol, Term scope)
Query	LogtalkEngine.importsCategory(Term object, Term category)
Query	LogtalkEngine.importsCategory(Term object, Term category, Term scope)
Query	LogtalkEngine.instantiatesClass(Term instance, Term clazz)
Query	LogtalkEngine.instantiatesClass(Term instance, Term clazz, Term scope)
static boolean	LogtalkObject.isLogtalkMessage(Term term)
Query	Logtalk.loadedFile(Term file, Term directory)
Query	Logtalk.loadedFile(Term file, Term directory, Term options)
Query	Logtalk.loadedFile(Term file, Term directory, Term options, Term streamProperties)
boolean	LogtalkEngine.logtalkLoad(Term... terms)
static Compound	LogtalkObject.logtalkMessage(Term receiver, String message)
static Compound	LogtalkObject.logtalkMessage(Term receiver, String message, List<? extends Term> args)
static Compound	LogtalkObject.logtalkMessage(Term receiver, Term message)
Term	LogtalkObject.message(Term message)
Query	Logtalk.messageHook(Term term, Term kind, Term component, Term tokens)
Query	Logtalk.messagePrefixStream(Term kind, Term component, Term prefix, Term stream)
Query	Logtalk.messageTokens(Term term, Term component)
Query	LogtalkEngine.objectProperty(Term object, Term property)
Query	LogtalkObject.perform(Term message)
Query	LogtalkObject.predicateProperty(Term predicate, Term property)
Query	Logtalk.printMessage(Term kind, Term component, Term term)
Query	Logtalk.printMessageTokens(Term stream, Term tokens)
Query	Logtalk.printMessageTokens(Term stream, Term prefix, Term tokens)
Query	LogtalkEngine.protocolProperty(Term protocol, Term property)
Query	LogtalkObject.retract(Term term)
boolean	LogtalkObject.retractAll(Term term)
Query	LogtalkEngine.specializesClass(Term clazz, Term superClass)
Query	LogtalkEngine.specializesClass(Term clazz, Term superClass, Term scope)
Query	LogtalkObject.threaded(Term goals)
boolean	LogtalkObject.threadedCall(Term goal)
boolean	LogtalkObject.threadedCall(Term goal, Term tag)
Query	LogtalkObject.threadedExit(Term goal)
Query	LogtalkObject.threadedExit(Term goal, Term tag)
boolean	LogtalkObject.threadedIgnore(Term goal)
Query	LogtalkObject.threadedNotify(Term term)
boolean	LogtalkObject.threadedOnce(Term goal)
boolean	LogtalkObject.threadedOnce(Term goal, Term tag)
boolean	LogtalkObject.threadedPeek(Term goal)
boolean	LogtalkObject.threadedPeek(Term goal, Term tag)
Query	Logtalk.traceEvent(Term event, Term eventExecutionContext)

Method parameters in org.jpc.engine.logtalk with type arguments of type Term

Modifier and Type	Method and Description
boolean	LogtalkEngine.logtalkLoad(List<? extends Term> terms)
static Compound	LogtalkObject.logtalkMessage(Term receiver, String message, List<? extends Term> args)

Constructors in org.jpc.engine.logtalk with parameters of type Term

Constructor and Description
LogtalkLibraryDescription(String alias, Term termPath, File dirFile)
LogtalkLibraryDescription(String alias, Term termPath, URI dirUri)

Uses of Term in org.jpc.engine.prolog

Methods in org.jpc.engine.prolog that return Term

Modifier and Type	Method and Description
Term	Flag.asTerm()
Term	PrologEngine.asTerm(String termString)
Term	AbstractPrologEngine.asTerm(String termString)
Term	PrologEngineProxy.asTerm(String termString, Jpc context)
Term	PrologEngine.asTerm(String termString, Jpc context)
Term	PrologEngine.bagof(Term select, Term exp)
Term	AbstractPrologEngine.bagof(Term select, Term exp)
Term	PrologEngine.findall(Term select, Term exp)
Term	AbstractPrologEngine.findall(Term select, Term exp)
static Term	OperatorsContext.findAllOperatorsTerm()
Term	PrologEngine.setof(Term select, Term exp)
Term	AbstractPrologEngine.setof(Term select, Term exp)
Term	PrologEngine.unify(List<? extends Term> terms)
Term	AbstractPrologEngine.unify(List<? extends Term> terms)
Term	PrologEngine.unify(Term... terms)
Term	AbstractPrologEngine.unify(Term... terms)

Methods in org.jpc.engine.prolog that return types with arguments of type Term

Modifier and Type	Method and Description
List<Term>	PrologEngine.asTerms(List<String> termsString)
List<Term>	AbstractPrologEngine.asTerms(List<String> termsString)
List<Term>	PrologEngine.asTerms(List<String> termsString, Jpc context)
List<Term>	AbstractPrologEngine.asTerms(List<String> termsString, Jpc context)

Methods in org.jpc.engine.prolog with parameters of type Term

Modifier and Type	Method and Description
boolean	PrologEngine.abolish(Term term)
boolean	PrologDatabase.abolish(Term term)
boolean	AbstractPrologEngine.abolish(Term term)
static Operator	Operator.asOperator(Term operatorTerm) Constructs an operator from a term having as structure [P,S,N] Where P is the operator's priority, S is its specifier (an integer term) and N the operator's id
boolean	PrologEngine.asserta(Term term)
boolean	PrologDatabase.asserta(Term term) Assert a clause in the logic database.
boolean	AbstractPrologEngine.asserta(Term term) Assert a clause in the logic database.
boolean	PrologEngine.assertz(Term term)
boolean	PrologDatabase.assertz(Term term) Assert a clause in the logic database.
boolean	AbstractPrologEngine.assertz(Term term) Assert a clause in the logic database.
Term	PrologEngine.bagof(Term select, Term exp)
Term	AbstractPrologEngine.bagof(Term select, Term exp)
Query	PrologEngine.bagof(Term select, Term exp, Term all)
Query	AbstractPrologEngine.bagof(Term select, Term exp, Term all)
Query	PrologEngineProxy.basicQuery(Term term, boolean errorHandledQuery, Jpc context)
Query	PrologEngine.basicQuery(Term term, boolean errorHandledQuery, Jpc context)
boolean	PrologEngine.cd(Term path)
boolean	AbstractPrologEngine.cd(Term path)
Query	PrologEngine.clause(Term head, Term body)
Query	PrologDatabase.clause(Term head, Term body)
Query	AbstractPrologEngine.clause(Term head, Term body)
Query	PrologEngine.currentOp(Term priority, Term specifier, Term operator)
Query	AbstractPrologEngine.currentOp(Term priority, Term specifier, Term operator)
Query	PrologEngine.currentPrologFlag(Term flag, Term flagValue)
Query	AbstractPrologEngine.currentPrologFlag(Term flag, Term flagValue)
boolean	PrologEngine.ensureLoaded(Term... terms)
boolean	AbstractPrologEngine.ensureLoaded(Term... terms)
Term	PrologEngine.findall(Term select, Term exp)
Term	AbstractPrologEngine.findall(Term select, Term exp)
Query	PrologEngine.findall(Term select, Term exp, Term all)
Query	AbstractPrologEngine.findall(Term select, Term exp, Term all)
Query	PrologEngine.forall(Term generator, Term test)
Query	AbstractPrologEngine.forall(Term generator, Term test)
Operator	OperatorsContext.getOperator(Term term)
Query	PrologEngine.query(Term goal)
Query	AbstractPrologEngine.query(Term goal)
Query	PrologEngine.query(Term goal, Jpc context)
Query	AbstractPrologEngine.query(Term goal, Jpc context)
Query	PrologEngine.query(Term goal, List<?> arguments, boolean errorHandledQuery, Jpc context)
Query	AbstractPrologEngine.query(Term goal, List<?> arguments, boolean errorHandledQuery, Jpc context)
Query	PrologEngine.retract(Term term)
Query	PrologDatabase.retract(Term term)
Query	AbstractPrologEngine.retract(Term term)
boolean	PrologEngine.retractAll(Term term)
boolean	PrologDatabase.retractAll(Term term)
boolean	AbstractPrologEngine.retractAll(Term term)
Term	PrologEngine.setof(Term select, Term exp)
Term	AbstractPrologEngine.setof(Term select, Term exp)
Query	PrologEngine.setof(Term select, Term exp, Term all)
Query	AbstractPrologEngine.setof(Term select, Term exp, Term all)
boolean	PrologEngine.setPrologFlag(Term flag, Term flagValue)
boolean	AbstractPrologEngine.setPrologFlag(Term flag, Term flagValue)
Term	PrologEngine.unify(Term... terms)
Term	AbstractPrologEngine.unify(Term... terms)

Method parameters in org.jpc.engine.prolog with type arguments of type Term

Modifier and Type	Method and Description
boolean	PrologEngine.allSucceed(List<? extends Term> terms)
boolean	AbstractPrologEngine.allSucceed(List<? extends Term> terms)
static OperatorsContext	OperatorsContext.asOperatorsContext(Iterable<? extends Term> operatorsListTerm)
boolean	PrologEngine.asserta(List<? extends Term> terms) Assert a list of clauses in the logic database.
boolean	AbstractPrologEngine.asserta(List<? extends Term> terms) Assert a list of clauses in the logic database.
boolean	PrologEngine.assertz(List<? extends Term> terms) Assert a list of clauses in the logic database.
boolean	AbstractPrologEngine.assertz(List<? extends Term> terms) Assert a list of clauses in the logic database.
boolean	PrologEngine.ensureLoaded(List<? extends Term> terms)
boolean	AbstractPrologEngine.ensureLoaded(List<? extends Term> terms)
Term	PrologEngine.unify(List<? extends Term> terms)
Term	AbstractPrologEngine.unify(List<? extends Term> terms)

Uses of Term in org.jpc.error

Fields in org.jpc.error declared as Term

Modifier and Type	Field and Description
protected Term	PrologError.errorTerm

Methods in org.jpc.error that return Term

Modifier and Type	Method and Description
Term	PrologError.asTerm()
Term	IsoPrologError.getContextTerm()
Term	IsoPrologError.getFormalDescriptionTerm()
Term	IsoPrologError.getLogtalkCall()
Term	IsoPrologError.getLogtalkEntity()

Constructors in org.jpc.error with parameters of type Term

Constructor and Description
PrologError(Term errorTerm)

Uses of Term in org.jpc.error.handling

Methods in org.jpc.error.handling with parameters of type Term

Modifier and Type	Method and Description
boolean	JpcConverterErrorHandler.handle(Term errorTerm, Term goal, Jpc context)
boolean	ErrorHandlerManager.handle(Term errorTerm, Term goal, Jpc context)
boolean	ErrorHandler.handle(Term errorTerm, Term goal, Jpc context)
boolean	DefaultJpcErrorHandler.handle(Term errorTerm, Term goal, Jpc context)

Uses of Term in org.jpc.query

Methods in org.jpc.query that return Term

Modifier and Type	Method and Description
Term	SolutionToTermFunction.apply(Solution solution)
protected Term	Query.asTerm(String termString)
static Term	PrologQuery.exceptionHandledQueryTerm(Term term)
Term	Solution.get(Object key)
Term	Solution.get(Object key, boolean considerAllVariables)
protected Term	Query.getAllSolutionsBindingsTerm() Answers a list term with the form [f(Name,Term), ...] Where f is an arbitrary functor id, Name is the id of a variable present in the original goal and Term the value bound to such variable.
protected Term	QueryAdapter.getDefaultSelectedTerm()
protected abstract Term	Query.getDefaultSelectedTerm() The default selected term when select* methods are called without specifying a select term By default, a PrologEngineQuery uses its goal.
protected Term	PrologQuery.getDefaultSelectedTerm()
protected Term	LogtalkQuery.getDefaultSelectedTerm()
Term	Solution.getErrorTerm()
Term	QueryAdapter.getGoal()
abstract Term	Query.getGoal()
Term	PrologQuery.getGoal()
Term	PrologQuery.getInstrumentedGoal()
Term	LogtalkQuery.getMethodTerm()
Term	LogtalkQuery.getObjectTerm()
protected Term	PrologQuery.instrumentGoal(Term goal)
Term	Solution.put(String key, Term value)
Term	Solution.remove(Object key)
static Term	PrologQuery.withOperatorsQueryTerm(Term term)

Methods in org.jpc.query that return types with arguments of type Term

Modifier and Type	Method and Description
com.google.common.collect.ListMultimap<String,Term>	Query.allSolutionsMultimap()
Set<Map.Entry<String,Term>>	Solution.entrySet()
Set<Map.Entry<String,Term>>	Solution.entrySet(boolean considerAllVariables)
Cursor<Term>	Query.select()
Cursor<Term>	Query.select(String selector)
Cursor<Term>	Query.select(Term selector) Selects a cursor of terms.
Collection<Term>	Solution.values()
Collection<Term>	Solution.values(boolean considerAllVariables)

Methods in org.jpc.query with parameters of type Term

Modifier and Type	Method and Description
T	TermToObjectFunction.apply(Term term)
<O> O	Solution.asObject(Term selector)
<O> O	Solution.asObject(Term selector, Type targetType)
static Term	PrologQuery.exceptionHandledQueryTerm(Term term)
protected Term	PrologQuery.instrumentGoal(Term goal)
Term	Solution.put(String key, Term value)
Cursor<Term>	Query.select(Term selector) Selects a cursor of terms.
<O> Cursor<O>	Query.selectObject(Term selector)
<O> Cursor<O>	Query.selectObject(Term selector, Type targetType)
static Term	PrologQuery.withOperatorsQueryTerm(Term term)

Method parameters in org.jpc.query with type arguments of type Term

Modifier and Type	Method and Description
void	Solution.putAll(Map<? extends String,? extends Term> map)

Constructors in org.jpc.query with parameters of type Term

Constructor and Description
DeterministicPrologQuery(PrologEngine prologEngine, Term goal, boolean errorHandledQuery, Jpc context)
PrologQuery(PrologEngine prologEngine, Term goal, boolean errorHandledQuery, Jpc context)
SolutionToTermFunction(Term term)

Constructor parameters in org.jpc.query with type arguments of type Term

Constructor and Description
Solution(Map<String,Term> rawSolution, PrologEngine prologEngine, Jpc context)

Uses of Term in org.jpc.salt

Methods in org.jpc.salt that return Term

Modifier and Type	Method and Description
Term	JpcTermBuilder.build()
Term	PrologWriter.getCurrentLogtalkObjectTerm()

Methods in org.jpc.salt that return types with arguments of type Term

Modifier and Type	Method and Description
protected TermBuilder<Term>	JpcTermWriter.createCompoundBuilder()

Methods in org.jpc.salt with parameters of type Term

Modifier and Type	Method and Description
protected void	PrologWriter.write(Term term)
void	PrologWriter.writeClause(Term clause)
void	PrologWriter.writeDirective(Term directive)
abstract void	PrologWriter.writeLogtalkObjectClause(Term clause)
void	PrologStreamWriter.writeLogtalkObjectClause(Term clause)
void	PrologEngineWriter.writeLogtalkObjectClause(Term clause)
abstract void	PrologWriter.writeLogtalkObjectDirective(Term directive)
void	PrologStreamWriter.writeLogtalkObjectDirective(Term directive)
void	PrologEngineWriter.writeLogtalkObjectDirective(Term directive)
abstract void	PrologWriter.writePrologClause(Term clause)
void	PrologStreamWriter.writePrologClause(Term clause)
void	PrologEngineWriter.writePrologClause(Term clause)
abstract void	PrologWriter.writePrologDirective(Term directive)
void	PrologStreamWriter.writePrologDirective(Term directive)
void	PrologEngineWriter.writePrologDirective(Term directive)

Constructors in org.jpc.salt with parameters of type Term

Constructor and Description
JpcTermBuilder(Term functor)
JpcTermBuilder(Term functor, List<Term> args)

Constructor parameters in org.jpc.salt with type arguments of type Term

Constructor and Description
JpcTermBuilder(Term functor, List<Term> args)

Uses of Term in org.jpc.term

Subclasses of Term in org.jpc.term

Modifier and Type	Class and Description
class	AbstractVar An abstract Prolog variable.
class	Atom A class reifying a logic atom
class	Compound A class reifying a logic compound term
class	FloatTerm A class reifying a logic float term
class	IntegerTerm A class reifying a logic integer term
class	JRef<T>
static class	JRef.StrongJRef<T>
static class	JRef.WeakJRef<T>
class	NumberTerm
class	Var A class reifying a logic variable Disclaimer: Some methods were inspired or taken from the JPL library

Methods in org.jpc.term with type parameters of type Term

Modifier and Type	Method and Description
static <T extends Term> String	Term.toEscapedString(List<T> terms) Converts a list of Terms to a String.
static <T extends Term> String	Term.toEscapedString(T... terms) Converts an array of Terms to its escaped String representation.

Methods in org.jpc.term that return Term

Modifier and Type	Method and Description
Term	Term.arg(int i) Returns the ith argument (if any) of this Term.
Term	ListTerm.asTerm()
Term	Functor.asTerm()
Term	Term.changeVariablesNames(Map<String,String> map) Replace all the variable names according to the map parameter
Term	Term.compile()
Term	Term.compile(boolean preserveVarNames)
Term	Term.compile(boolean preserveVarNames, Environment env)
Term	Term.compile(Environment env)
Term	Term.compileAndUnify(Term term)
Term	Functor.getName()
Term	Compound.getName() Returns the id of this Compound.
static Term	ListTerm.listTerm(List<? extends Term> terms)
static Term	ListTerm.listTerm(Term... terms)
Term	Var.preCompile(Environment env)
abstract Term	Term.preCompile(Environment env)
Term	NumberTerm.preCompile(Environment env)
Term	JRef.preCompile(Environment env)
Term	Compound.preCompile(Environment env)
Term	Atom.preCompile(Environment env)
Term	Term.prepareForFrame() Method only required for internal usage of the JPC Prolog engine.
Term	Var.prepareForFrame(Environment env)
abstract Term	Term.prepareForFrame(Environment env)
Term	NumberTerm.prepareForFrame(Environment env)
Term	JRef.prepareForFrame(Environment env)
Term	Compound.prepareForFrame(Environment env)
Term	Atom.prepareForFrame(Environment env)
Term	Term.prepareForQuery()
Term	Var.prepareForQuery(Environment env)
abstract Term	Term.prepareForQuery(Environment env)
Term	NumberTerm.prepareForQuery(Environment env)
Term	JRef.prepareForQuery(Environment env)
Term	Compound.prepareForQuery(Environment env)
Term	Atom.prepareForQuery(Environment env)
Term	Term.replaceVariables(Map<String,? extends Term> map) Returns a term with all the occurrences of the variables in the parameter map replaced with its associated value (converted to a term)
Term	Term.resolveBindings()
Term	Term.termExpansion(com.google.common.base.Function<Term,Term> termExpander)
Term	Term.unifyAndBind(Term term)

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

Modifier and Type	Method and Description
Map<String,Term>	Term.compileAndUnifyVars(Term term)
List<Term>	Term.getArgs() Returns the arguments list of this term.
List<Term>	Compound.getArgs() Returns the arguments of this Compound (1..arity) of this Compound as a List of Term.
Map<String,Term>	Term.varBindings()

Methods in org.jpc.term with parameters of type Term

Modifier and Type	Method and Description
boolean	Term.canUnify(Term term)
Term	Term.compileAndUnify(Term term)
Map<String,Term>	Term.compileAndUnifyVars(Term term)
static ListTerm	ListTerm.create(Term... terms)
static ListTerm	ListTerm.fromTermSequence(Term termSequence)
static ListTerm	ListTerm.fromTermSequence(Term termSequence, String sequenceSeparator)
boolean	Compound.hasName(Term term)
static Term	ListTerm.listTerm(Term... terms)
boolean	Var.termEquals(Term term)
boolean	Term.termEquals(Term t) Test if this object is equivalent to the term representation of the object sent as parameter This is not testing for equality in a mathematical sense, for example: 'new Variable("_").equals(new Variable("_"))' is false, since both the receiver and the arguments are anonymous variables, not the same variable.
boolean	Compound.termEquals(Term term)
static <T extends Term> String	Term.toEscapedString(T... terms) Converts an array of Terms to its escaped String representation.
void	Var.unify(Term term)
void	Term.unify(Term term)
void	JRef.unify(Term term)
void	Compound.unify(Term term)
Term	Term.unifyAndBind(Term term)

Method parameters in org.jpc.term with type arguments of type Term

Modifier and Type	Method and Description
protected abstract void	Term.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected abstract void	Term.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	JRef.StrongJRef.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	JRef.StrongJRef.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	JRef.WeakJRef.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	JRef.WeakJRef.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	IntegerTerm.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	IntegerTerm.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	FloatTerm.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	FloatTerm.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	Compound.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	Compound.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	Atom.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	Atom.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	AbstractVar.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
protected void	AbstractVar.basicRead(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
static ListTerm	ListTerm.create(List<? extends Term> terms)
static Term	ListTerm.listTerm(List<? extends Term> terms)
void	Term.read(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
void	Term.read(TermContentHandler contentHandler, com.google.common.base.Function<Term,Term> termExpander)
Term	Term.replaceVariables(Map<String,? extends Term> map) Returns a term with all the occurrences of the variables in the parameter map replaced with its associated value (converted to a term)
static boolean	Term.termEquals(List<? extends Term> list1, List<? extends Term> list2)
static boolean	Term.termEquals(List<? extends Term> list1, List<? extends Term> list2)
Term	Term.termExpansion(com.google.common.base.Function<Term,Term> termExpander)
Term	Term.termExpansion(com.google.common.base.Function<Term,Term> termExpander)

Constructors in org.jpc.term with parameters of type Term

Constructor and Description
Compound(Term name, List<? extends Term> args) Creates a Compound with id and args.
Functor(Term name, int arity)

Constructor parameters in org.jpc.term with type arguments of type Term

Constructor and Description
Compound(String name, List<? extends Term> args)
Compound(Term name, List<? extends Term> args) Creates a Compound with id and args.
ListTerm(Collection<? extends Term> terms)

Uses of Term in org.jpc.term.compiler

Subclasses of Term in org.jpc.term.compiler

Modifier and Type	Class and Description
class	BindableVar
class	CompiledVar

Methods in org.jpc.term.compiler that return Term

Modifier and Type	Method and Description
Term	VarCell.getBinding()
Term	Register.getBinding()
Term	BindableVar.getBinding()
Term	CompiledVar.preCompile(Environment env)
Term	BindableVar.preCompile(Environment env)
Term	CompiledVar.prepareForFrame(Environment env)
Term	BindableVar.prepareForFrame(Environment env)
Term	CompiledVar.prepareForQuery(Environment env)
Term	BindableVar.prepareForQuery(Environment env)

Methods in org.jpc.term.compiler with parameters of type Term

Modifier and Type	Method and Description
void	VarCell.setBinding(Term binding)
void	Register.setBinding(Term binding)
boolean	CompiledVar.termEquals(Term term)
boolean	BindableVar.termEquals(Term term)
void	CompiledVar.unify(Term term)
void	BindableVar.unify(Term term)

Constructors in org.jpc.term.compiler with parameters of type Term

Constructor and Description
Register(Term binding)
UncompiledTermException(Term term)
VarCell(Term binding)

Uses of Term in org.jpc.term.expansion

Methods in org.jpc.term.expansion that return Term

Modifier and Type	Method and Description
Term	DefaultTermExpander.apply(Term term)
Term	CachedTermExpander.apply(Term term)
protected Term	ParameterizedSymbolExpander.doExpand(Term term)
protected Term	CachedTermExpander.doExpand(Term term)
protected Term	CachedTermExpander.getCachedExpansion(Term term)

Methods in org.jpc.term.expansion with parameters of type Term

Modifier and Type	Method and Description
protected void	CachedTermExpander.addCachedExpansion(Term sourceTerm, Term expandedTerm)
Term	DefaultTermExpander.apply(Term term)
Term	CachedTermExpander.apply(Term term)
protected Term	ParameterizedSymbolExpander.doExpand(Term term)
protected Term	CachedTermExpander.doExpand(Term term)
protected Term	CachedTermExpander.getCachedExpansion(Term term)
Object	PositionalSymbolExpander.resolve(Term symbolTerm)
abstract Object	ParameterizedSymbolExpander.resolve(Term symbolTerm)
Object	DictionarySymbolExpander.resolve(Term symbolTerm)

Constructor parameters in org.jpc.term.expansion with type arguments of type Term

Constructor and Description
CachedTermExpander(Map<Term,Term> map)
CachedTermExpander(Map<Term,Term> map)

Uses of Term in org.jpc.term.refterm

Methods in org.jpc.term.refterm that return Term

Modifier and Type	Method and Description
Term	RefTermType.toTerm(Object ref, Jpc jpc)

Uses of Term in org.jpc.term.unification

Constructors in org.jpc.term.unification with parameters of type Term

Constructor and Description
NonUnifiableException(Term term1, Term term2)
NonUnifiableException(Term term1, Term term2, NonUnifiableException cause)

Uses of Term in org.jpc.util

Methods in org.jpc.util that return Term

Modifier and Type	Method and Description
static Term	PrologUtil.applyFunctor(String functor, String atom) Surround an atom with a functor
Term	TermJoiner.join(List<Term> terms)
Term	TermJoiner.join(Term... terms)
static Term	PrologUtil.replaceVariables(Term term)
static Term	PrologUtil.replaceVariables(Term term, String prefix) Renames the vars of a term adding a prefix Useful to avoid unexpected results when unifying two terms that do not share the same variable namespace
static Term	PrologUtil.varDictionaryTerm(Term term)

Methods in org.jpc.util that return types with arguments of type Term

Modifier and Type	Method and Description
static List<Term>	PrologUtil.forEachApplyFunctor(String functor, List<? extends Term> terms)
static List<Term>	PrologUtil.getChildren(Term term)

Methods in org.jpc.util with parameters of type Term

Modifier and Type	Method and Description
static List<Term>	PrologUtil.getChildren(Term term)
<T> T	PrologSpeakingObject.invoke(Term messageTerm)
static boolean	PrologUtil.isEquals(Term term) Returns whether the term is a compound with functor("=", 2)
static boolean	PrologUtil.isPair(Term term)
Term	TermJoiner.join(Term... terms)
static Term	PrologUtil.replaceVariables(Term term)
static Term	PrologUtil.replaceVariables(Term term, String prefix) Renames the vars of a term adding a prefix Useful to avoid unexpected results when unifying two terms that do not share the same variable namespace
void	PrologSpeakingObject.setField(Atom fieldName, Term fieldValueTerm)
void	PrologSpeakingObject.setFields(Term mapTerm)
static Term	PrologUtil.varDictionaryTerm(Term term)

Method parameters in org.jpc.util with type arguments of type Term

Modifier and Type	Method and Description
static List<Term>	PrologUtil.forEachApplyFunctor(String functor, List<? extends Term> terms)
<T> T	PrologSpeakingObject.invoke(Atom methodName, List<? extends Term> argTerms)
<T> T	PrologSpeakingObject.invoke(String methodName, List<? extends Term> argTerms)
Term	TermJoiner.join(List<Term> terms)
T	PrologSpeakingClass.newInstance(List<? extends Term> argTerms)
static <T> Map<String,T>	ConversionUtil.toObjectMap(Map<String,Term> termMap, Jpc jpc)
static <T> List<Map<String,T>>	ConversionUtil.toObjectMapList(List<? extends Map<String,Term>> termMapList, Jpc jpc)

Uses of Term in org.jpc.util.engine

Methods in org.jpc.util.engine that return Term

Modifier and Type	Method and Description
Term	PrologResourceLoader.resolveResource(String resource) Given a resource id (possibly inside a jar) answers a Term that represents the resource in the file system.
Term	PrologResourceLoader.resolveResource(String resourceName, URL url)

Uses of Term in org.jpc.util.salt

Constructor parameters in org.jpc.util.salt with type arguments of type Term

Constructor and Description
ReplaceVariableAdapter(TermContentHandler contentHandler, Map<String,? extends Term> map)