dsl-solve/it.unibo.tuprolog.dsl.solve/LogicProgrammingScopeWithResolutionImpl

LogicProgrammingScopeWithResolutionImpl

class LogicProgrammingScopeWithResolutionImpl(val solverFactory: SolverFactory, val unificator: Unificator, scope: Scope, val defaultSolver: MutableSolver = solverFactory.mutableSolverWithDefaultBuiltins()) : LogicProgrammingScopeWithResolution, LogicProgrammingScopeWithTheories, MutableSolver

Constructors

fun LogicProgrammingScopeWithResolutionImpl(solverFactory: SolverFactory, unificator: Unificator, scope: Scope, defaultSolver: MutableSolver = solverFactory.mutableSolverWithDefaultBuiltins())

Functions

abolish

open override fun abolish(indicator: Any): Struct

and

open infix override fun Any.and(other: Any): Struct

anonymous

open override fun anonymous(): Var

append

open override fun <T> List<T>.append(item: T, vararg items: T): List<T>

open override fun append(left: Any, right: Any, result: Any): Struct

appendDynamicKb

open override fun appendDynamicKb(theory: Theory)

appendStaticKb

open override fun appendStaticKb(theory: Theory)

arg

open override fun arg(index: Any, compound: Any, argument: Any): Struct

arithEq

open infix override fun Any.arithEq(right: Any): Struct

arithNeq

open infix override fun Any.arithNeq(right: Any): Struct

assert

open override fun assert(clause: Any): Struct

assertA

open override fun asserta(clause: Any): Struct

assertZ

open override fun assertz(clause: Any): Struct

at_end_of_stream

open override fun at_end_of_stream(alias: Any): Struct

atom

open override fun atom(atom: Any): Struct

atom_chars

open override fun atom_chars(atom: Any, chars: Any): Struct

atom_codes

open override fun atom_codes(atom: Any, codes: Any): Struct

atom_concat

open override fun atom_concat(first: Any, second: Any, result: Any): Struct

atom_length

open override fun atom_length(atom: Any, length: Any): Struct

atomic

open override fun atomic(atomic: Any): Struct

atomOf

open override fun atomOf(value: String): Atom

bagof

open override fun bagof(template: Any, goal: Any, bag: Any): Struct

between

open override fun between(min: Any, max: Any, number: Any): Struct

blockOf

open override fun blockOf(vararg terms: Term): Block

open override fun blockOf(terms: Iterable<Term>): Block

open override fun blockOf(terms: Sequence<Term>): Block

open override fun blockOf(vararg terms: Any): Block

call

open override fun call(goal: Any): Struct

callable

open override fun callable(goal: Any): Struct

catch

open override fun catch(goal: Any, error: Any, continuation: Any): Struct

char_code

open override fun char_code(char: Any, code: Any): Struct

clause

open override fun clause(function: LogicProgrammingScope.() -> Any): Clause

open override fun clause(head: Any, body: Any): Struct

clauseOf

open override fun clauseOf(head: Struct?, vararg body: Term): Clause

clone

open override fun clone(): MutableSolver

compound

open override fun compound(struct: Any): Struct

concat

open override fun <T> List<T>.concat(other: Iterable<T>): List<T>

consOf

open override fun consOf(head: Term, tail: Term): Cons

open override fun consOf(head: Any, tail: Any): Cons

consult

open override fun consult(url: Any): Struct

contains

open operator override fun contains(variable: Var): Boolean

open operator override fun contains(variable: String): Boolean

open operator override fun Substitution.contains(term: Any): Boolean

containsKey

open override fun Substitution.containsKey(term: Any): Boolean

containsValue

open override fun Substitution.containsValue(term: Any): Boolean

copy

open override fun copy(unificator: Unificator, libraries: Runtime, flags: FlagStore, staticKb: Theory, dynamicKb: Theory, stdIn: InputChannel<String>, stdOut: OutputChannel<String>, stdErr: OutputChannel<String>, warnings: OutputChannel<Warning>): MutableSolver

copy_term

open override fun copy_term(term: Any, copy: Any): Struct

current_flag

open override fun current_flag(name: Any, value: Any): Struct

current_op

open override fun current_op(precedence: Any, specifier: Any, functor: Any): Struct

current_prolog_flag

open override fun ~~current_prolog_flag~~(name: Any, value: Any): Struct

directive

open override fun directive(function: LogicProgrammingScope.() -> Any): Directive

directiveOf

open override fun directiveOf(body1: Term, vararg body: Term): Directive

open override fun directiveOf(term: Any, vararg terms: Any): Directive

div

open operator override fun Any.div(other: Any): Indicator

dynamic

open override fun dynamic(indicator: Any): Struct

dynamicKb

open fun dynamicKb(theory: Theory)

open fun dynamicKb(vararg clauses: Clause)

open fun dynamicKb(clauses: Iterable<Clause>)

open fun dynamicKb(clauses: Sequence<Clause>)

emptyMutableTheory

open override fun emptyMutableTheory(): MutableTheory

emptyTheory

open override fun emptyTheory(): Theory

open infix override fun Any.eq(right: Any): Struct

equalsTo

open infix override fun Any.equalsTo(other: Any): Struct

fact

open override fun fact(function: LogicProgrammingScope.() -> Any): Fact

factOf

open override fun factOf(head: Struct): Fact

open override fun factOf(term: Any): Fact

findall

open override fun findall(template: Any, goal: Any, bag: Any): Struct

float

open override fun float(number: Any): Struct

functor

open override fun functor(struct: Any, functor: Any, arity: Any): Struct

get

open operator override fun get(variable: String): Var?

open operator override fun Substitution.get(term: Any): Term?

getValue

open operator override fun getValue(thisRef: Any?, property: KProperty<*>): Var

greaterThan

open infix override fun Any.greaterThan(other: Any): Struct

greaterThanOrEqualsTo

open infix override fun Any.greaterThanOrEqualsTo(other: Any): Struct

ground

open override fun ground(term: Any): Struct

open infix override fun Any.id(right: Any): Struct

open infix override fun Any.if(other: Any): Rule

open override fun Any.if(vararg other: Any): Rule

impliedBy

open infix override fun Any.impliedBy(other: Any): Rule

open override fun Any.impliedBy(vararg other: Any): Rule

include

open override fun include(url: Any): Struct

indicatorOf

open override fun indicatorOf(name: Term, arity: Term): Indicator

open override fun indicatorOf(name: String, arity: Int): Indicator

initialization

open override fun initialization(goal: Any): Struct

intDiv

open infix override fun Any.intDiv(other: Any): Struct

integer

open override fun integer(number: Any): Struct

intOf

open override fun intOf(value: Byte): Integer

open override fun intOf(value: Int): Integer

open override fun intOf(value: Long): Integer

open override fun intOf(value: Short): Integer

open override fun intOf(value: String): Integer

open override fun intOf(value: BigInteger): Integer

open override fun intOf(value: String, radix: Int): Integer

invoke

open operator override fun String.invoke(term: Any, vararg terms: Any): Struct

open infix override fun Any.is(other: Any): Struct

ktEmptyList

open override fun <T> ktEmptyList(): List<T>

ktEmptySet

open override fun <T> ktEmptySet(): Set<T>

ktListOf

open override fun <T> ktListOf(vararg items: T): List<T>

ktSetOf

open override fun <T> ktSetOf(vararg items: T): Set<T>

list

open override fun list(vararg items: Any, tail: Any?): List

listFrom

open override fun listFrom(vararg terms: Term, last: Term?): List

open override fun listFrom(terms: Iterable<Term>, last: Term?): List

open override fun listFrom(terms: Sequence<Term>, last: Term?): List

listOf

open override fun listOf(vararg terms: Term): List

open override fun listOf(terms: Iterable<Term>): List

open override fun listOf(terms: Sequence<Term>): List

open override fun listOf(vararg terms: Any): List

load

open override fun load(url: Any): Struct

loadDynamicClauses

open override fun loadDynamicClauses(vararg clauses: Clause)

open override fun loadDynamicClauses(clauses: Iterable<Clause>)

open override fun loadDynamicClauses(clauses: Sequence<Clause>)

loadDynamicKb

open override fun loadDynamicKb(theory: Theory)

loadLibrary

open override fun loadLibrary(library: Library)

loadStaticClauses

open override fun loadStaticClauses(vararg clauses: Clause)

open override fun loadStaticClauses(clauses: Iterable<Clause>)

open override fun loadStaticClauses(clauses: Sequence<Clause>)

loadStaticKb

open override fun loadStaticKb(theory: Theory)

lowerThan

open infix override fun Any.lowerThan(other: Any): Struct

lowerThanOrEqualsTo

open infix override fun Any.lowerThanOrEqualsTo(other: Any): Struct

match

open override fun match(term1: Term, term2: Term): Boolean

open override fun match(term1: Any, term2: Any, occurCheckEnabled: Boolean): Boolean

open override fun match(term1: Term, term2: Term, occurCheckEnabled: Boolean): Boolean

matches

open infix override fun Any.matches(other: Any): Boolean

member

open override fun member(item: Any, list: Any): Struct

merge

open override fun merge(substitution1: Substitution, substitution2: Substitution): Substitution

open override fun merge(substitution1: Substitution, substitution2: Substitution, occurCheckEnabled: Boolean): Substitution

mgu

open override fun mgu(term1: Term, term2: Term): Substitution

open override fun mgu(term1: Any, term2: Any, occurCheckEnabled: Boolean): Substitution

open override fun mgu(term1: Term, term2: Term, occurCheckEnabled: Boolean): Substitution

mguWith

open infix override fun Any.mguWith(other: Any): Substitution

minus

open operator override fun Any.minus(other: Any): Struct

mutableTheory

open override fun mutableTheory(vararg clauseFunctions: LogicProgrammingScope.() -> Any): MutableTheory

mutableTheoryOf

open override fun mutableTheoryOf(vararg clause: Clause): MutableTheory

open override fun mutableTheoryOf(clauses: Iterable<Clause>, vararg otherClauses: Iterable<Clause>): MutableTheory

open override fun mutableTheoryOf(clauses: Sequence<Clause>, vararg otherClauses: Sequence<Clause>): MutableTheory

naf

open override fun naf(goal: Any): Struct

natural

open override fun natural(number: Any): Struct

neq

open infix override fun Any.neq(right: Any): Struct

nid

open infix override fun Any.nid(right: Any): Struct

nonGreaterThan

open infix override fun Any.nonGreaterThan(other: Any): Struct

nonLowerThan

open infix override fun Any.nonLowerThan(other: Any): Struct

nonvar

open override fun nonvar(number: Any): Struct

not

open override fun not(goal: Any): Struct

notEqualsTo

open infix override fun Any.notEqualsTo(other: Any): Struct

number

open override fun number(number: Any): Struct

number_chars

open override fun number_chars(first: Any, second: Any): Struct

number_codes

open override fun number_codes(first: Any, second: Any): Struct

numOf

open override fun numOf(value: Byte): Integer

open override fun numOf(value: Double): Real

open override fun numOf(value: Float): Real

open override fun numOf(value: Int): Integer

open override fun numOf(value: Long): Integer

open override fun numOf(value: Number): Numeric

open override fun numOf(value: Short): Integer

open override fun numOf(value: String): Numeric

open override fun numOf(value: BigDecimal): Real

open override fun numOf(value: BigInteger): Integer

open override fun op(precedence: Any, specifier: Any, functor: Any): Struct

open infix override fun Any.or(other: Any): Struct

plus

open operator override fun Any.plus(other: Any): Struct

pow

open infix override fun Any.pow(other: Any): Struct

realOf

open override fun realOf(value: Double): Real

open override fun realOf(value: Float): Real

open override fun realOf(value: String): Real

open override fun realOf(value: BigDecimal): Real

rem

open operator override fun Any.rem(other: Any): Struct

resetDynamicKb

open override fun resetDynamicKb()

resetStaticKb

open override fun resetStaticKb()

retract

open override fun retract(clause: Any): Struct

open override fun retract(clause: Clause): RetractResult<Theory>

open override fun retract(fact: Struct): RetractResult<Theory>

retractAll

open override fun retractall(clause: Any): Struct

rule

open override fun rule(function: LogicProgrammingScope.() -> Any): Rule

ruleOf

open override fun ruleOf(head: Struct, body1: Term, vararg body: Term): Rule

scope

open override fun <R> scope(function: LogicProgrammingScope.() -> R): R

set_flag

open override fun set_flag(name: Any, value: Any): Struct

set_prolog_flag

open override fun ~~set_prolog_flag~~(name: Any, value: Any): Struct

setFlag

open override fun setFlag(flag: NotableFlag)

open override fun setFlag(flag: Pair<String, Term>)

open override fun setFlag(name: String, value: Term)

setof

open override fun setof(template: Any, goal: Any, bag: Any): Struct

setRuntime

open override fun setRuntime(libraries: Runtime)

setStandardError

open override fun setStandardError(stdErr: OutputChannel<String>)

setStandardInput

open override fun setStandardInput(stdIn: InputChannel<String>)

setStandardOutput

open override fun setStandardOutput(stdOut: OutputChannel<String>)

setWarnings

open override fun setWarnings(warnings: OutputChannel<Warning>)

solve

open override fun solve(goal: Any): Struct

open override fun solve(goal: Struct): Sequence<Solution>

open override fun solve(goal: Struct, options: SolveOptions): Sequence<Solution>

open override fun solve(goal: Struct, timeout: TimeDuration): Sequence<Solution>

solveList

open override fun solveList(goal: Struct): List<Solution>

open override fun solveList(goal: Struct, options: SolveOptions): List<Solution>

open override fun solveList(goal: Struct, timeout: TimeDuration): List<Solution>

solveOnce

open override fun solveOnce(goal: Struct): Solution

open override fun solveOnce(goal: Struct, options: SolveOptions): Solution

open override fun solveOnce(goal: Struct, timeout: TimeDuration): Solution

solverOf

open fun solverOf(unificator: Unificator = solverFactory.defaultUnificator, otherLibraries: Runtime = solverFactory.defaultRuntime, flags: FlagStore = solverFactory.defaultFlags, staticKb: Theory = solverFactory.defaultStaticKb, dynamicKb: Theory = solverFactory.defaultDynamicKb, stdIn: InputChannel<String> = solverFactory.defaultInputChannel, stdOut: OutputChannel<String> = solverFactory.defaultOutputChannel, stdErr: OutputChannel<String> = solverFactory.defaultErrorChannel, warnings: OutputChannel<Warning> = solverFactory.defaultWarningsChannel): MutableSolver

static