inline fun <K, V> Iterable<V>.groupByMultipleKeys(keysSelector: (V) -> Iterable<K>, onDuplicate: (K, V, V) -> Unit = { key, value1, value2 -> throw IllegalArgumentException("Duplicate mapping for $key ($value1, $value2)") }): Map<K, V>

Map the elements of the Iterable to multiple keys. By default duplicate mappings are not allowed. The returned Map preserves the iteration order of the values.

hashCode

open override fun hashCode(): Int

head

fun head(): T

Returns the first element of the set.

isEmpty

open override fun isEmpty(): Boolean

iterator

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

mapToSet

inline fun <T, R> Collection<T>.mapToSet(transform: (T) -> R): Set<R>

Similar to Iterable.map except it maps to a Set which preserves the iteration order.

noneOrSingle

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

Returns the single element matching the given predicate, or null if the collection is empty, or throws exception if more than one element was found.

parallelStream

open override fun parallelStream(): Stream<T>

requireSingleCommand

inline fun <T : CommandData> Collection<CommandWithParties<CommandData>>.requireSingleCommand(): Nothing

fun <C : CommandData> Collection<CommandWithParties<CommandData>>.requireSingleCommand(klass: Class<C>): Nothing

Ensures that a transaction has only one command that is of the given type, otherwise throws an exception.

select

inline fun <T : CommandData> Collection<CommandWithParties<CommandData>>.select(signer: PublicKey? = null, party: AbstractParty? = null): <Error class: unknown class>

fun <C : CommandData> Collection<CommandWithParties<CommandData>>.select(klass: Class<C>, signer: PublicKey? = null, party: AbstractParty? = null): <Error class: unknown class>

Filters the command list by type, party and public key all at once.

inline fun <T : CommandData> Collection<CommandWithParties<CommandData>>.select(signers: Collection<PublicKey>?, parties: Collection<Party>?): <Error class: unknown class>

fun <C : CommandData> Collection<CommandWithParties<CommandData>>.select(klass: Class<C>, signers: Collection<PublicKey>?, parties: Collection<Party>?): <Error class: unknown class>

Filters the command list by type, parties and public keys all at once.

spliterator

open override fun spliterator(): Spliterator<T>

stream

open override fun stream(): Stream<T>

sumCash

fun Iterable<ContractState>.sumCash(): Amount<Issued<Currency>>

Sums the cash states in the list, throwing an exception if there are none, or if any of the cash states cannot be added together (i.e. are different currencies or issuers).

sumCashBy

fun Iterable<ContractState>.sumCashBy(owner: AbstractParty): Amount<Issued<Currency>>

Sums the cash states in the list belonging to a single owner, throwing an exception if there are none, or if any of the cash states cannot be added together (i.e. are different currencies or issuers).

sumCashOrNull

fun Iterable<ContractState>.sumCashOrNull(): Amount<Issued<Currency>>?

Sums the cash states in the list, returning null if there are none.

sumCashOrZero

fun Iterable<ContractState>.sumCashOrZero(currency: Issued<Currency>): Amount<Issued<Currency>>

Sums the cash states in the list, returning zero of the given currency+issuer if there are none.

sumFungibleOrNull

fun <T : Any> Iterable<ContractState>.sumFungibleOrNull(): Amount<Issued<T>>?

Sums the asset states in the list, returning null if there are none.

sumFungibleOrZero

fun <T : Any> Iterable<ContractState>.sumFungibleOrZero(token: Issued<T>): Amount<Issued<T>>

Sums the asset states in the list, returning zero of the given token if there are none.

sumObligations

fun Iterable<ContractState>.sumObligations(): Amount<Issued<Obligation.Terms>>

Sums the obligation states in the list, throwing an exception if there are none. All state objects in the list are presumed to be nettable.

sumObligationsOrNull

fun Iterable<ContractState>.sumObligationsOrNull(): Amount<Issued<Obligation.Terms>>?

Sums the obligation states in the list, returning null if there are none.

sumObligationsOrZero

fun Iterable<ContractState>.sumObligationsOrZero(issuanceDef: Issued<Obligation.Terms>): Amount<Issued<Obligation.Terms>>

Sums the obligation states in the list, returning zero of the given product if there are none.

sumOrNull

fun <T : Any> Iterable<Amount<T>>.sumOrNull(): Nothing?

If the given iterable of Amounts yields any elements, sum them, throwing an IllegalArgumentException if any of the token types are mismatched; if the iterator yields no elements, return null.

sumOrThrow

fun <T : Any> Iterable<Amount<T>>.sumOrThrow(): <Error class: unknown class>

Sums the amounts yielded by the given iterable, throwing an IllegalArgumentException if any of the token types are mismatched.

sumOrZero

fun <T : Any> Iterable<Amount<T>>.sumOrZero(token: T): Amount<T>

If the given iterable of Amounts yields any elements, sum them, throwing an IllegalArgumentException if any of the token types are mismatched; if the iterator yields no elements, return a zero amount of the given token type.

toArray

open fun <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>

toMultiMap

fun <K, V> Iterable<<Error class: unknown class><K, V>>.toMultiMap(): Map<K, List<V>>

toNonEmptySet

fun <T> Collection<T>.toNonEmptySet(): NonEmptySet<T>

toString

open override fun toString(): String

transpose

fun <V> Collection<CordaFuture<out V>>.transpose(): CordaFuture<List<V>>

If all of the given futures succeed, the returned future's outcome is a list of all their values. The values are in the same order as the futures in the collection, not the order of completion. If at least one given future fails, the returned future's outcome is the first throwable that was thrown. Any subsequent throwables are added to the first one as suppressed throwables, in the order they are thrown. If no futures were given, the returned future has an immediate outcome of empty list. Otherwise the returned future does not have an outcome until all given futures have an outcome. Unlike Guava's Futures.allAsList, this method never hides failures/hangs subsequent to the first failure.