korge-foundation/korlibs.datastructure/BaseSubMutableList

BaseSubMutableList

open class BaseSubMutableList<T>(val mlist: MutableList<T>, start: Int, end: Int) : BaseSubList<T> , BaseMutableList<T>

Constructors

BaseSubMutableList

constructor(mlist: MutableList<T>, start: Int, end: Int)

Properties

var end: Int

val list: List<T>

val mlist: MutableList<T>

open override val size: Int

unhexIgnoreSpaces

val List<String>.unhexIgnoreSpaces: ByteArray

Functions

open override fun add(element: T): Boolean

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

open override fun addAll(elements: Collection<T>): Boolean

open override fun addAll(index: Int, elements: Collection<T>): Boolean

fun <K> Collection<K>.asFakeMutable(): FakeMutableCollection<K>

fun <T> Iterable<T>.associateByInt(block: (index: Int, value: T) -> Int): IntMap<T>

fun Iterable<Rectangle>.bounds(): Rectangle

fun Iterable<Point>.bounds(): Rectangle

fun List<Point>.bounds(): Rectangle

fun Iterable<MRectangle>.bounds(target: MRectangle = MRectangle()): MRectangle

fun Iterable<MPoint>.bounds(out: MRectangle = MRectangle(), bb: MBoundsBuilder = MBoundsBuilder()): MRectangle

fun List<MPoint>.bounds(out: MRectangle = MRectangle(), bb: MBoundsBuilder = MBoundsBuilder()): MRectangle

fun checkIndex(index: Int): Int

open override fun clear()

open operator override fun contains(element: T): Boolean

open override fun containsAll(elements: Collection<T>): Boolean

fun List<MPoint>.containsPoint(x: Double, y: Double): Boolean

fun <T> List<T>.countMap(): Map<T, Int>

fun <T> List<T>.ensureFastList(): FastArrayList<T>

inline fun <T> List<T>.fastForEach(callback: (T) -> Unit)

fastForEachBezier

inline fun List<Curves>.fastForEachBezier(block: (Bezier) -> Unit)

fastForEachReverse

inline fun <T> List<T>.fastForEachReverse(callback: (T) -> Unit)

fastForEachWithIndex

inline fun <T> List<T>.fastForEachWithIndex(callback: (index: Int, value: T) -> Unit)

fastForEachWithTemp

inline fun <T> List<T>.fastForEachWithTemp(temp: FastArrayList<T>, callback: (T) -> Unit)

fastIterateRemove

inline fun <T> MutableList<T>.fastIterateRemove(callback: (T) -> Boolean): MutableList<T>

inline fun <T> Collection<T>.fastRandom(): T

fun List<PointList>.flatten(): PointList

fun <T : Comparable<T>> MutableList<T>.genericSort(left: Int = 0, right: Int = size - 1): MutableList<T>

fun <T : Comparable<T>> List<T>.genericSorted(left: Int = 0, right: Int = size - 1): List<T>

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

fun <T> List<T>.getCyclic(index: Int): T

getCyclicOrNull

fun <T> List<T>.getCyclicOrNull(index: Int): T?

getPolylineLength

fun List<MPoint>.getPolylineLength(): Double

fun List<Point>.getPolylineLength(): Double

open override fun indexOf(element: T): Int

open override fun isEmpty(): Boolean

open operator override fun iterator(): Iterator<T>

open override fun lastIndexOf(element: T): Int

open override fun listIterator(): ListIterator<T>

open override fun listIterator(index: Int): ListIterator<T>

inline fun <T> Iterable<T>.mapDouble(callback: (T) -> Double): DoubleArrayList

inline fun <T> Iterable<T>.mapFloat(callback: (T) -> Float): FloatArrayList

inline fun <T> Iterable<T>.mapInt(callback: (T) -> Int): IntArrayList

fun <T> Iterable<T>.multisorted(vararg props: KProperty1<T, Comparable<*>>): List<T>

inline fun <T, R> List<T>.parallelMap(crossinline transform: (T) -> R): List<R>

inline fun <T> List<T>.parallelMapInt(crossinline transform: (T) -> Int): IntArray

fun List<TrapezoidInt>.pointInside(x: Int, y: Int, assumeSorted: Boolean = false): TrapezoidInt?

fun <T> List<T>.random(random: Random = Random): T

randomWithWeights

fun <T> List<T>.randomWithWeights(weights: List<Double>, random: Random = Random): T

fun <T> List<T>.reader(): ListReader<T>

open override fun remove(element: T): Boolean

open override fun removeAll(elements: Collection<T>): Boolean

open override fun removeAt(index: Int): T

open override fun retainAll(elements: Collection<T>): Boolean

fun <T> MutableList<T>.reverse(fromIndex: Int, toIndex: Int)

fun <T> List<T>.rotated(offset: Int): List<T>

fun <T> List<T>.rotatedLeft(offset: Int = +1): List<T>

fun <T> List<T>.rotatedRight(offset: Int = +1): List<T>

fun <T> MutableList<T>.rotateLeft(offset: Int = +1)

fun <T> MutableList<T>.rotateRight(offset: Int = +1)

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

open override fun subList(fromIndex: Int, toIndex: Int): List<T>

@JvmName(name = "sumOfFloat")

inline fun <T> Iterable<T>.sumOfDouble(selector: (T) -> Double): Double

@JvmName(name = "sumOfFloat")

inline fun <T> Iterable<T>.sumOfFloat(selector: (T) -> Float): Float

fun <T> MutableList<T>.swap(lIndex: Int, rIndex: Int)

fun <T : Comparable<T>> MutableList<T>.timSort(left: Int = 0, right: Int = size - 1): MutableList<T>

fun <T : Comparable<T>> List<T>.timSorted(): List<T>

@JvmName(name = "ListCurve_toCurves")

fun List<Bezier>.toCurves(closed: Boolean): Curves

@JvmName(name = "ListCurves_toCurves")

fun List<Curves>.toCurves(closed: Boolean = this.last().closed): Curves

fun <T> Collection<T>.toDeque(): Deque<T>

inline fun Iterable<Double>.toDoubleList(): DoubleArrayList

fun <T> List<T>.toFastList(): List<T>

fun <T> List<T>.toFastList(out: FastArrayList<T> = FastArrayList()): FastArrayList<T>

inline fun Iterable<Float>.toFloatList(): FloatArrayList

fun List<MSegmentInt>.toFSegmentsInt(): FSegmentsInt

toFTrapezoidsInt

fun List<TrapezoidInt>.toFTrapezoidsInt(): FTrapezoidsInt

toFTrianglesInt

fun List<MTriangleInt>.toFTrianglesInt(): FTrianglesInt

fun List<HitTestable>.toHitTestable(): HitTestable

inline fun Iterable<Int>.toIntList(): IntArrayList

fun <T> Collection<Pair<Int, T>>.toIntMap(): IntMap<T>

fun <K, V> Iterable<Pair<K, V>>.toLinkedMap(): LinkedHashMap<K, V>

toPointArrayList

fun List<Point>.toPointArrayList(): PointArrayList

fun Iterable<DateTimeRange>.toRangeSet(): DateTimeRangeSet

fun List<Shape2D>.toShape2D(): Shape2D

fun List<Shape2D>.~~toShape2d~~(): Shape2D

fun List<DateTimeRange>.toStringLongs(): String

toStrokePointsList

fun List<Curves>.toStrokePointsList(info: StrokeInfo, mode: StrokePointsMode = StrokePointsMode.NON_SCALABLE_POS, generateDebug: Boolean = false, forceClosed: Boolean? = null): List<StrokePoints>

fun List<Curves>.toStrokePointsList(width: Double, join: LineJoin = LineJoin.MITER, startCap: LineCap = LineCap.BUTT, endCap: LineCap = LineCap.BUTT, miterLimit: Double = 10.0, mode: StrokePointsMode = StrokePointsMode.NON_SCALABLE_POS, lineDash: DoubleList? = null, lineDashOffset: Double = 0.0, generateDebug: Boolean = false, forceClosed: Boolean? = null): List<StrokePoints>

fun List<Curve>.toVectorPath(out: VectorPath = VectorPath()): VectorPath

fun List<TrapezoidInt>.triangulate(out: FTrianglesInt = FTrianglesInt()): FTrianglesInt

withoutSortedDuplicates

fun <T> List<T>.withoutSortedDuplicates(out: ArrayList<T> = arrayListOf()): List<T>