net.corda.client.fxutils / MappedList

MappedList

class MappedList<A, B> : TransformationList<B, A>

This is a variant of EasyBind.map where the mapped list is backed, therefore the mapping function will only be run when an element is inserted or updated. Use this instead of EasyBind.map to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.



Constructors

<init> MappedList(list: ObservableList<A>, function: (A) -> B)

This is a variant of EasyBind.map where the mapped list is backed, therefore the mapping function will only be run when an element is inserted or updated. Use this instead of EasyBind.map to trade off memory vs CPU, or if (god forbid) the mapped function is side-effecting.

Properties

function val function: (A) -> B
size val size: Int

Functions

get fun get(index: Int): B
getSourceIndex fun getSourceIndex(index: Int): Int
sourceChanged fun sourceChanged(change: Change<out A>): Unit

Extension Functions

associateBy fun <K, A, B> ObservableList<out A>.associateBy(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, B>

data class Person(val height: Long) val people: ObservableList = (..) val nameToHeight: ObservableMap<String, Long> = people.associateBy(Person::name) { name, person -> person.height }

fun <K, A> ObservableList<out A>.associateBy(toKey: (A) -> K): ObservableMap<K, A>

val people: ObservableList = (..) val nameToPerson: ObservableMap<String, Person> = people.associateBy(Person::name)

associateByAggregation fun <K : Any, A : Any, B> ObservableList<out A>.associateByAggregation(toKey: (A) -> K, assemble: (K, A) -> B): ObservableMap<K, ObservableList<B>>

val people: ObservableList = (..) val heightToNames: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height) { name, person -> person.name }

fun <K : Any, A : Any> ObservableList<out A>.associateByAggregation(toKey: (A) -> K): ObservableMap<K, ObservableList<A>>

val people: ObservableList = (..) val heightToPeople: ObservableMap<Long, ObservableList> = people.associateByAggregation(Person::height)

filter fun <A> ObservableList<out A>.filter(predicate: ObservableValue<(A) -> Boolean>): ObservableList<A>

enum class FilterCriterion { HEIGHT, NAME } val filterCriterion: ObservableValue = (..) val people: ObservableList = (..) fun filterFunction(filterCriterion: FilterCriterion): (Person) -> Boolean { .. }

filterNotNull fun <A> ObservableList<out A?>.filterNotNull(): ObservableList<A>

data class Dog(val owner: Person?) val dogs: ObservableList = (..) val owners: ObservableList = dogs.map(Dog::owner).filterNotNull()

first fun <A> ObservableList<A>.first(): ObservableValue<A?>
foldObservable fun <A, B> ObservableList<out A>.foldObservable(initial: B, folderFunction: (B, A) -> B): ObservableValue<B>

val people: ObservableList = (..) val concatenatedNames = people.foldObservable("", { names, person -> names + person.name }) val concatenatedNames2 = people.map(Person::name).fold("", String::plus)

getValueAt fun <A> ObservableList<A>.getValueAt(index: Int): ObservableValue<A?>
indexOfOrThrow fun <T> List<T>.indexOfOrThrow(item: T): Int

Returns the index of the given item or throws IllegalArgumentException if not found.

last fun <A> ObservableList<A>.last(): ObservableValue<A?>
leftOuterJoin fun <A : Any, B : Any, C, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K, assemble: (A, ObservableList<B>) -> C): ObservableList<C>

data class Person(val name: String, val managerName: String) val people: ObservableList = (..) val managerEmployeeMapping: ObservableList<Pair<Person, ObservableList>> = people.leftOuterJoin(people, Person::name, Person::managerName) { manager, employees -> Pair(manager, employees) }

fun <A : Any, B : Any, K : Any> ObservableList<A>.leftOuterJoin(rightTable: ObservableList<B>, leftToJoinKey: (A) -> K, rightToJoinKey: (B) -> K): ObservableMap<K, <ERROR CLASS><ObservableList<A>, ObservableList<B>>>

data class Person(name: String, favouriteSpecies: Species) data class Animal(name: String, species: Species) val people: ObservableList = (..) val animals: ObservableList = (..) val peopleToFavouriteAnimals: ObservableMap<Species, Pair<ObservableList, ObservableList>> = people.leftOuterJoin(animals, Person::favouriteSpecies, Animal::species)

map fun <A, B> ObservableList<out A>.map(cached: Boolean = true, function: (A) -> B): ObservableList<B>

val dogs: ObservableList = (..) val dogOwners: ObservableList = dogs.map { it.owner }

noneOrSingle fun <T> Iterable<T>.noneOrSingle(predicate: (T) -> Boolean): T?

Returns the single element matching the given predicate, or null if element was not found, or throws if more than one element was found.

fun <T> Iterable<T>.noneOrSingle(): T?

Returns single element, or null if element was not found, or throws if more than one element was found.