dsl-utilities/top.ltfan.dslutilities/AbstractDslMutableList

AbstractDslMutableList

abstract class AbstractDslMutableList<I, O>(initial: MutableList<I> = mutableListOf()) : AbstractMutableList<O> , DslReplaceableList<O> (source)

An abstract class that provides a mutable list DSL implementation.

This class allows you to create a mutable list that transforms elements from type I to type O and vice versa. It provides methods to get, set, add, and remove elements while maintaining the transformation logic.

Parameters

The original type of the elements in the list.

The output type of the elements in the list after transformation.

Inheritors

ListProperty

Constructors

AbstractDslMutableList

constructor(initial: MutableList<I> = mutableListOf())

Properties

delegate

protected open var delegate: MutableList<I>

The delegate list that stores the original type I values. This is mutable and can be replaced with a new list.

modCount

protected expect var modCount: Int

size

open override val size: Int

Functions

add

abstract override fun add(element: O): Boolean

open override fun add(index: Int, element: O)

addAll

abstract override fun addAll(elements: Collection<O>): Boolean

abstract fun addAll(index: Int, elements: Collection<O>): Boolean

clear

abstract override fun clear()

contains

abstract operator override fun contains(element: O): Boolean

containsAll

abstract override fun containsAll(elements: Collection<O>): Boolean

get

open operator override fun get(index: Int): O

getTransform

protected abstract fun getTransform(original: I): O

Transforms the original type I to the output type O. This method should be implemented to define how the transformation from I to O is done.

indexOf

abstract fun indexOf(element: O): Int

isEmpty

abstract override fun isEmpty(): Boolean

iterator

abstract operator override fun iterator(): Iterator<O>

lastIndexOf

abstract fun lastIndexOf(element: O): Int

listIterator

abstract override fun listIterator(): MutableListIterator<O>

abstract override fun listIterator(index: Int): MutableListIterator<O>

originalAdd

protected fun originalAdd(index: Int, element: O)

originalGet

protected fun originalGet(index: Int): O

originalRemoveAt

protected fun originalRemoveAt(index: Int): O

originalSet

protected fun originalSet(index: Int, element: O): O

remove

abstract override fun remove(element: O): Boolean

removeAll

abstract override fun removeAll(elements: Collection<O>): Boolean

removeAt

open override fun removeAt(index: Int): O

removeRange

protected expect open fun removeRange(fromIndex: Int, toIndex: Int)

replace

open override fun replace(list: MutableList<O>)

Replaces the current list with a new one.

retainAll

abstract override fun retainAll(elements: Collection<O>): Boolean

set

open operator override fun set(index: Int, element: O): O

setTransform

protected abstract fun setTransform(original: O): I

Transforms the output type O back to the original type I. This method should be implemented to define how the transformation from O to I is done.

subList

abstract override fun subList(fromIndex: Int, toIndex: Int): MutableList<O>