Provides a filtered view of an underlying ObservableList. Changes to this list affect the underlying list, but their effects may not be visible once applied due to filter.

HorizontalAlignment

enum HorizontalAlignment : Enum<HorizontalAlignment>

LeastRecentlyUsedCache

class LeastRecentlyUsedCache<K, V>(maxSize: Int) : MutableMap<K, V>

Created by Nicholas Eddy on 3/22/20.

ListObserver

typealias ListObserver<S, T> = (source: S, changes: Differences<T>) -> Unit

Handler for arbitrary changes to some source.

ListObservers

typealias ListObservers<S, T> = Pool<ListObserver<S, T>>

MatchedChunk

class MatchedChunk(val match: String, val delimiter: String)

MatchResult

class MatchResult(val matches: List<MatchedChunk>, val remaining: String)

Matrix

interface Matrix<out T : Number>

An NxM Matrix.

MatrixImpl

open class MatrixImpl<T : Number> : Matrix<T>

An (NxM) Matrix.

Node

interface Node<T>

A node within a tree.

ObservableList

interface ObservableList<E> : MutableList<E>

A List that notifies observers of changes to its contents.

ObservableListImpl

open class ObservableListImpl<E> : ObservableList<E> , MutableList<E>

ObservablePool

interface ObservablePool<T> : Pool<T>

A Pool that notifies of changes to its contents.

ObservableSet

open class ObservableSet<E> : MutableSet<E>

ObservableSetPool

expect open class ObservableSetPool<T>(delegate: SetPool<T>) : ObservablePool<T> , Set<T>

Implementation of ObservablePool based on a Set. Contents are stored in the provided delegate.

Orientation

enum Orientation : Enum<Orientation>

Created by Nicholas Eddy on 2/13/18.

Path

class Path<T>(items: List<T>) : Iterable<T>

Created by Nicholas Eddy on 3/23/18.

Pausable

interface Pausable : Completable

Defines an activity that can be paused and resumed.

PausableImpl

open class PausableImpl : CompletableImpl, Pausable

Pool

interface Pool<in T>

A collection of items that only exposes add/remove semantics that is used for observers.

PoolObserver

interface PoolObserver<T>

Observer of changes to ObservablePool.

PropertyObserver

typealias PropertyObserver<S, T> = (source: S, old: T, new: T) -> Unit

Handler for changes to some property of a source.

PropertyObservers

typealias PropertyObservers<S, T> = Pool<PropertyObserver<S, T>>

PropertyObserversImpl

class PropertyObserversImpl<S, T>(source: S) : SetPool<PropertyObserver<S, T>>

PropertyObservers implemented using a SetPool.

RelativeBoundsListener

typealias RelativeBoundsListener = (view: View, relativeTo: View, old: Rectangle, new: Rectangle) -> Unit

RelativePositionMonitor

interface RelativePositionMonitor

RelativePositionMonitorImpl

class RelativePositionMonitorImpl : RelativePositionMonitor

Resizer

class Resizer(view: View, manageCursor: Boolean = true, var movable: Boolean = true, during: Resizer.Phase = EventBubbling) : PointerListener, PointerMotionListener

Utility for resizing/moving a View. It supports compass direction resizing and dragging.

RotationDirection

enum RotationDirection : Enum<RotationDirection>

SetObserver

typealias SetObserver<S, T> = (source: S, removed: Set<T>, added: Set<T>) -> Unit

Handler for arbitrary changes to some source.

SetObservers

typealias SetObservers<S, T> = Pool<SetObserver<S, T>>

SetPool

expect open class SetPool<T> : Pool<T> , Set<T>

Implementation of Pool based on a Set.

SquareMatrix

open class SquareMatrix<T : Number> : MatrixImpl<T>

A square (NxN) Matrix.

TemporalDirection

enum TemporalDirection : Enum<TemporalDirection>

TextAlignment

enum TextAlignment : Enum<TextAlignment>

VerticalAlignment

enum VerticalAlignment : Enum<VerticalAlignment>

Properties

isEven

val Int.isEven: Boolean

Created by Nicholas Eddy on 10/20/17.

val Long.isEven: Boolean

isOdd

val Int.isOdd: Boolean

val Long.isOdd: Boolean

NoOpCompletable

val NoOpCompletable: Completable

NoOpPausable

val NoOpPausable: Pausable

size

val ClosedRange<Double>.size: Double

val ClosedRange<Float>.size: Float

val ClosedRange<Int>.size: Int

The span of a range: endInclusive - start

zeroMillis

val zeroMillis: Measure<Time>

Functions

addOrAppend

fun <T> MutableList<T>.addOrAppend(at: Int, value: T)

Ads value to the list at the specify index, or at the end of the list if that index exceeds the current list length.

allCompleted

fun Collection<Completable>.allCompleted(completed: () -> Unit)

autoCanceling

fun <V, T : Cancelable> autoCanceling(default: T? = null, onChanged: (old: T?, new: T?) -> Unit = { _,_ -> }): ReadWriteProperty<V, T?>

Creates a ReadWriteProperty that will cancel the previous value when changed.

contains

operator fun <E> Collection<E>?.contains(element: E): Boolean

Nullable helper

ifFalse

fun Boolean.ifFalse(block: () -> Unit): Boolean

ifNull

fun <T> T?.ifNull(block: () -> Unit): T?

ifTrue

fun Boolean.ifTrue(block: () -> Unit): Boolean

intersect

infix fun <T : Comparable<T>> ClosedRange<T>.intersect(other: ClosedRange<T>): ClosedRange<T>

intersects

infix fun <T : Comparable<T>> ClosedRange<T>.intersects(other: ClosedRange<T>): Boolean

lerp

fun <T : Units> lerp(first: Measure<T>, second: Measure<T>, fraction: Float): Measure<T>

Interpolates between two Measure.

fun lerp(first: Double, second: Double, fraction: Float): Double

fun lerp(first: Float, second: Float, fraction: Float): Float

Interpolates between two values.

map

fun <T, V> Pool<T>.map(by: (V) -> T): Pool<V>

Creates a new Pool that is based on another of a different type.

@JvmName(name = "mapDD")

fun SquareMatrix<Double>.map(transform: (Double) -> Double): SquareMatrix<Double>

@JvmName(name = "mapDF")

fun SquareMatrix<Double>.map(transform: (Double) -> Float): SquareMatrix<Float>

@JvmName(name = "mapDI")

fun SquareMatrix<Double>.map(transform: (Double) -> Int): SquareMatrix<Int>

@JvmName(name = "mapDL")

fun SquareMatrix<Double>.map(transform: (Double) -> Long): SquareMatrix<Long>

@JvmName(name = "mapFD")

fun SquareMatrix<Float>.map(transform: (Float) -> Double): SquareMatrix<Double>

@JvmName(name = "mapFF")

fun SquareMatrix<Float>.map(transform: (Float) -> Float): SquareMatrix<Float>

@JvmName(name = "mapFI")

fun SquareMatrix<Float>.map(transform: (Float) -> Int): SquareMatrix<Int>

@JvmName(name = "mapFL")

fun SquareMatrix<Float>.map(transform: (Float) -> Long): SquareMatrix<Long>

@JvmName(name = "mapID")

fun SquareMatrix<Int>.map(transform: (Int) -> Double): SquareMatrix<Double>

@JvmName(name = "mapIF")

fun SquareMatrix<Int>.map(transform: (Int) -> Float): SquareMatrix<Float>

@JvmName(name = "mapIL")

fun SquareMatrix<Int>.map(transform: (Int) -> Long): SquareMatrix<Long>

@JvmName(name = "mapLD")

fun SquareMatrix<Long>.map(transform: (Long) -> Double): SquareMatrix<Double>

@JvmName(name = "mapLF")

fun SquareMatrix<Long>.map(transform: (Long) -> Float): SquareMatrix<Float>

@JvmName(name = "mapLI")

fun SquareMatrix<Long>.map(transform: (Long) -> Int): SquareMatrix<Int>

@JvmName(name = "mapLL")

fun SquareMatrix<Long>.map(transform: (Long) -> Long): SquareMatrix<Long>

@JvmName(name = "mapII")

fun SquareMatrix<Int>.map(transform: (Int) -> Int): SquareMatrix<Int>

Creates a new SquareMatrix whose members are the transform of those in this one.

mapIndexed

@JvmName(name = "mapIndexedD")

fun SquareMatrix<Double>.mapIndexed(transform: (col: Int, row: Int, Double) -> Double): SquareMatrix<Double>

@JvmName(name = "mapIndexedF")

fun SquareMatrix<Float>.mapIndexed(transform: (col: Int, row: Int, Float) -> Float): SquareMatrix<Float>

@JvmName(name = "mapIndexedL")

fun SquareMatrix<Long>.mapIndexed(transform: (col: Int, row: Int, Long) -> Long): SquareMatrix<Long>

@JvmName(name = "mapIndexedI")

fun SquareMatrix<Int>.mapIndexed(transform: (col: Int, row: Int, Int) -> Int): SquareMatrix<Int>

Like map, but with col, row given for each item during tranformation.

matrixOf

@JvmName(name = "matrixOfD")

fun matrixOf(rows: Int, cols: Int, init: (row: Int, col: Int) -> Double): Matrix<Double>

@JvmName(name = "matrixOfF")

fun matrixOf(rows: Int, cols: Int, init: (row: Int, col: Int) -> Float): Matrix<Float>

@JvmName(name = "matrixOfI")

fun matrixOf(rows: Int, cols: Int, init: (row: Int, col: Int) -> Int): Matrix<Int>

@JvmName(name = "matrixOfL")

fun matrixOf(rows: Int, cols: Int, init: (row: Int, col: Int) -> Long): Matrix<Long>

Creates an NxM Matrix, where N == rows and M == cols.

minus

operator fun Matrix<Double>.minus(other: Matrix<Double>): Matrix<Double>

Matrix subtraction of two Matrixes.

observable

fun <S, T> observable(initial: T, onChange: S.(old: T, new: T) -> Unit): ReadWriteProperty<S, T>

fun <S, T> observable(initial: T, observers: Iterable<PropertyObserver<S, T>>): ReadWriteProperty<S, T>

fun <S, T> observable(initial: T, observers: Iterable<PropertyObserver<S, T>>, onChange: (old: T, new: T) -> Unit): ReadWriteProperty<S, T>

plus

operator fun Matrix<Double>.plus(other: Matrix<Double>): Matrix<Double>

Matrix addition of two Matrixes.

roundToNearest

fun Double.roundToNearest(value: Double): Double

Rounds this number to the nearest value.

sortWith

fun <T> ObservableList<T>.sortWith(comparator: Comparator<in T>)

sortWithDescending

fun <T> ObservableList<T>.sortWithDescending(comparator: Comparator<in T>)

splitMatches

fun CharSequence.splitMatches(regex: Regex, limit: Int = 0): MatchResult

Splits the character sequence based on a regex into a set of MatchedChunks, which indicates the match and the delimiter that separates it from its neighbor on the right.