theory/it.unibo.tuprolog.theory/MutableTheory

MutableTheory

interface MutableTheory : Theory

Types

Companion

object Companion

Functions

abolish

abstract override fun abolish(indicator: <ERROR CLASS>): MutableTheory

assertA

abstract override fun assertA(clause: <ERROR CLASS>): MutableTheory

open override fun assertA(struct: <ERROR CLASS>): MutableTheory

abstract override fun assertA(clauses: Iterable<<ERROR CLASS>>): MutableTheory

abstract override fun assertA(clauses: Sequence<<ERROR CLASS>>): MutableTheory

Adds given clause before all other clauses in this theory

assertZ

abstract override fun assertZ(clause: <ERROR CLASS>): MutableTheory

open override fun assertZ(struct: <ERROR CLASS>): MutableTheory

abstract override fun assertZ(clauses: Iterable<<ERROR CLASS>>): MutableTheory

abstract override fun assertZ(clauses: Sequence<<ERROR CLASS>>): MutableTheory

Adds given clause after all other clauses in this theory

clone

abstract override fun clone(): MutableTheory

contains

abstract operator fun contains(clause: <ERROR CLASS>): Boolean

Checks if given clause is contained in this theory

abstract operator fun contains(indicator: <ERROR CLASS>): Boolean

Checks if clauses exists in this theory having the specified Indicator as head; this should be Indicator.isWellFormed

abstract operator fun contains(head: <ERROR CLASS>): Boolean

Checks if given clause is present in this theory

equals

abstract fun equals(other: Theory, useVarCompleteName: Boolean): Boolean

get

abstract operator fun get(clause: <ERROR CLASS>): Sequence<<ERROR CLASS>>

Retrieves matching clauses from this theory

abstract operator fun get(indicator: <ERROR CLASS>): Sequence<<ERROR CLASS>>

Retrieves all rules in this theory having the specified Indicator as head; this should be Indicator.isWellFormed

abstract operator fun get(head: <ERROR CLASS>): Sequence<<ERROR CLASS>>

Retrieves matching rules from this theory

iterator

abstract operator fun iterator(): Iterator<<ERROR CLASS>>

plus

open operator override fun plus(clause: <ERROR CLASS>): MutableTheory

abstract operator override fun plus(theory: Theory): MutableTheory

Adds given Theory to this

replaceTags

abstract fun replaceTags(tags: Map<String, Any>): MutableTheory

retract

abstract override fun retract(clause: <ERROR CLASS>): RetractResult<MutableTheory>

open override fun retract(head: <ERROR CLASS>): RetractResult<MutableTheory>

abstract override fun retract(clauses: Iterable<<ERROR CLASS>>): RetractResult<MutableTheory>

abstract override fun retract(clauses: Sequence<<ERROR CLASS>>): RetractResult<MutableTheory>

Tries to delete a matching clause from this theory

retractAll

abstract override fun retractAll(clause: <ERROR CLASS>): RetractResult<MutableTheory>

open override fun retractAll(head: <ERROR CLASS>): RetractResult<MutableTheory>

Tries to delete all matching clauses from this theory

toImmutableTheory

abstract fun toImmutableTheory(): Theory

toMutableTheory

open override fun toMutableTheory(): MutableTheory

toString

abstract fun toString(asPrologText: Boolean): String

An enhanced toString that prints the theory in a Prolog program format, if asPrologText is true

Properties

clauses

abstract val clauses: Iterable<<ERROR CLASS>>

All Clauses in this theory

directives

open val directives: Iterable<<ERROR CLASS>>

Only clauses that are Directives

isMutable

open override val isMutable: Boolean

rules

open val rules: Iterable<<ERROR CLASS>>

Only clauses that are Rules

size

abstract val size: Long

The amount of clauses in this Theory