solve/it.unibo.tuprolog.solve.channel.impl/AbstractChannelStore

AbstractChannelStore

abstract class AbstractChannelStore<T : Any, C : Channel<T>, Self : ChannelStore<T, C, Self>>(channels: Map<String, C>) : ChannelStore<T, C, Self> , Map<String, C>

Base ChannelStore implementation, backing the map by an immutable channels and implementing ChannelStore.findByTerm/ChannelStore.aliasesOf plus equals/hashCode/toString in terms of it; concrete stores (it.unibo.tuprolog.solve.channel.InputStore/it.unibo.tuprolog.solve.channel.OutputStore implementations) only need to add their well-known channels on top.

Constructors

constructor(channels: Map<String, C>)

Properties

current

open val current: C?

The channel aliased as CURRENT in this store, or null if none is set.

currentAliases

open val currentAliases: Sequence<String>

Every alias, other than CURRENT itself, under which current is also reachable.

entries

open override val entries: Set<Map.Entry<String, C>>

keys

open override val keys: Set<String>

size

open override val size: Int

values

open override val values: Collection<C>

Functions

aliasesOf

open override fun aliasesOf(channel: C): Sequence<String>

Returns every alias under which channel is reachable in this store, excluding CURRENT.

open fun close(channel: C): Self

Channel.closes channel and returns a copy of this store without any alias pointing to it.

containsKey

open override fun containsKey(key: String): Boolean

containsValue

open override fun containsValue(value: C): Boolean

equals

open operator override fun equals(other: Any?): Boolean

findByTerm

open override fun findByTerm(streamTerm: Term): Sequence<C>

Returns every channel in this store whose Channel.streamTerm unifies with streamTerm.

get

open operator override fun get(key: String): C?

hashCode

open override fun hashCode(): Int

isEmpty

open override fun isEmpty(): Boolean

minus

open operator fun minus(other: String): Self

Returns a copy of this store without the entry aliased other (if any).

open operator fun minus(others: Iterable<String>): Self

abstract operator fun minus(others: Sequence<String>): Self

Returns a copy of this store without the entries aliased in others.

open fun minus(other: String, vararg others: String): Self

Returns a copy of this store without the entries aliased other or in others.

plus

open operator fun plus(other: Pair<String, C>): Self

Returns a copy of this store with other added (overriding an existing entry with the same alias).

open operator fun plus(others: Iterable<Pair<String, C>>): Self

abstract operator fun plus(others: Map<String, C>): Self

open operator fun plus(others: Sequence<Pair<String, C>>): Self

Returns a copy of this store with every entry of others added (overriding same-named existing ones).

open fun plus(first: Pair<String, C>, vararg others: Pair<String, C>): Self

Returns a copy of this store with first and others added (overriding same-named existing entries).

setCurrent

abstract fun setCurrent(channel: C): Self

Returns a copy of this store with CURRENT pointing to channel.

abstract fun setCurrent(alias: String): Self

Returns a copy of this store with CURRENT pointing to the channel already aliased as alias.

toString

open override fun toString(): String