Package space.kscience.dataforge.data

Types

ActiveDataSet

common

interface ActiveDataSet<T : Any> : DataSet<T>

ActiveDataTree

common

class ActiveDataTree<T : Any>(dataType: KType) : DataTree<T> , DataSetBuilder<T> , ActiveDataSet<T>

A mutable DataTree.Companion.active. It

CachingAction

common

abstract class CachingAction<in T : Any, out R : Any>(outputType: KType) : Action<T, R>

An action that caches results on-demand and recalculates them on source push

CoroutineMonitor

common

class CoroutineMonitor : CoroutineContext.Element

A monitor of goal state that could be accessed only form inside the goal

Data

common

@Type(id = "data")

interface Data<out T : Any> : Goal<T> , MetaRepr

A data element characterized by its meta

DataSet

common

interface DataSet<out T : Any>

DataSetBuilder

common

interface DataSetBuilder<in T : Any>

DataTree

common

@Type(id = "dataTree")

interface DataTree<out T : Any> : DataSet<T>

A tree-like DataSet grouped into the node. All data inside the node must inherit its type

DataTreeItem

common

sealed class DataTreeItem<out T : Any>

Dependencies

common

class Dependencies(values: Collection<Job>) : CoroutineContext.Element

Goal

common

interface Goal<out T>

Lazy computation result with its dependencies to allowing to stat computing dependencies ahead of time

GoalExecutionRestriction

common

class GoalExecutionRestriction(policy: GoalExecutionRestrictionPolicy) : CoroutineContext.Element

GoalExecutionRestrictionPolicy

common

enum GoalExecutionRestrictionPolicy : Enum<GoalExecutionRestrictionPolicy>

GoalLogger

common

interface GoalLogger : CoroutineContext.Element

GroupRule

common

interface GroupRule

LazyGoal

common

open class LazyGoal<T>(coroutineContext: CoroutineContext, dependencies: Collection<Goal<*>>, block: suspend () -> T) : Goal<T>

NamedData

common

interface NamedData<out T : Any> : Named, Data<T>

StaticData

common

class StaticData<T : Any>(type: KType, value: T, meta: Meta) : StaticGoal<T> , Data<T>

StaticGoal

common

open class StaticGoal<T>(value: T) : Goal<T>

Functions

ActiveDataTree

common

inline suspend fun <T : Any> ActiveDataTree(crossinline block: suspend ActiveDataTree<T>.() -> Unit): ActiveDataTree<T>

suspend fun <T : Any> ActiveDataTree(type: KType, block: suspend ActiveDataTree<T>.() -> Unit): ActiveDataTree<T>

Create a dynamic tree. Initial data is placed synchronously. Updates are propagated via updatesScope

await

common

suspend fun <T> Goal<T>.await(): T

branch

common

fun <T : Any> DataSet<T>.branch(branchName: String): DataSet<T>

fun <T : Any> DataSet<T>.branch(branchName: Name): DataSet<T>

Get a subset of data starting with a given branchName

fun <T : Any> DataTree<T>.branch(branchName: Name): DataTree<T>

Get a branch of this DataTree with a given branchName. The difference from similar method for DataSet is that internal logic is more simple and the return value is a DataTree

combine

common

inline fun <T1 : Any, T2 : Any, R : Any> Data<T1>.combine(other: Data<T2>, coroutineContext: CoroutineContext = EmptyCoroutineContext, meta: Meta = this.meta, crossinline block: suspend (T1, T2) -> R): Data<R>

Combine this data with the other data using block. See map for other details

Data

common

inline fun <T : Any> Data(meta: Meta = Meta.EMPTY, context: CoroutineContext = EmptyCoroutineContext, dependencies: Collection<Data<*>> = emptyList(), noinline block: suspend () -> T): Data<T>

fun <T : Any> Data(type: KType, meta: Meta = Meta.EMPTY, context: CoroutineContext = EmptyCoroutineContext, dependencies: Collection<Data<*>> = emptyList(), block: suspend () -> T): Data<T>

DataTree

common

inline suspend fun <T : Any> DataTree(noinline block: suspend DataSetBuilder<T>.() -> Unit): DataTree<T>

suspend fun <T : Any> DataTree(dataType: KType, block: suspend DataSetBuilder<T>.() -> Unit): DataTree<T>

emit

common

suspend fun <T : Any> DataSetBuilder<T>.emit(data: NamedData<T>)

inline suspend fun <T : Any> ActiveDataTree<T>.emit(name: String, noinline block: suspend ActiveDataTree<T>.() -> Unit)

inline suspend fun <T : Any> ActiveDataTree<T>.emit(name: Name, noinline block: suspend ActiveDataTree<T>.() -> Unit)

suspend fun <T : Any> DataSetBuilder<T>.emit(name: String, block: suspend DataSetBuilder<T>.() -> Unit)

suspend fun <T : Any> DataSetBuilder<T>.emit(name: String, set: DataSet<T>)

suspend fun <T : Any> DataSetBuilder<T>.emit(name: String, data: Data<T>)

suspend fun <T : Any> DataSetBuilder<T>.emit(name: Name, block: suspend DataSetBuilder<T>.() -> Unit)

filter

common

fun <T : Any> DataSet<T>.filter(predicate: suspend (Name, Data<T>) -> Boolean): ActiveDataSet<T>

A stateless filtered DataSet

flowChildren

common

fun <T : Any> DataSet<T>.flowChildren(branchName: Name): Flow<NamedData<T>>

Flow all data nodes with names starting with branchName

foldToData

common

inline suspend fun <T : Any, R : Any> Flow<NamedData<T>>.foldToData(initial: R, coroutineContext: CoroutineContext = EmptyCoroutineContext, meta: Meta = Meta.EMPTY, noinline block: suspend (R, data: NamedData<T>) -> R): Data<R>

Fold a flow of named data into a single Data

inline suspend fun <T : Any, R : Any> DataSet<T>.foldToData(initial: R, coroutineContext: CoroutineContext = EmptyCoroutineContext, meta: Meta = Meta.EMPTY, noinline block: suspend (R, data: NamedData<T>) -> R): Data<R>

forEach

common

suspend fun <T : Any> DataSet<T>.forEach(block: suspend (NamedData<T>) -> Unit)

getData

common

suspend fun <T : Any> DataSet<T>.getData(name: String): Data<T>?

getItem

common

suspend tailrec fun <T : Any> DataTree<T>.getItem(name: Name): DataTreeItem<T>?

Get a DataTreeItem with given name or null if the item does not exist

getMeta

common

suspend fun DataSet<*>.getMeta(): Meta?

Get a metadata node for this set if it is present

itemFlow

common

fun <T : Any> DataTree<T>.itemFlow(): Flow<Pair<Name, DataTreeItem<T>>>

Flow of all children including nodes

join

common

suspend fun <T : Any> DataSet<T>.join()

launch

common

fun Goal<*>.launch(coroutineScope: CoroutineScope): Job

map

common

inline suspend fun <T : Any, R : Any> DataSet<T>.map(coroutineContext: CoroutineContext = EmptyCoroutineContext, noinline metaTransform: MutableMeta.() -> Unit = {}, noinline block: suspend (T) -> R): DataTree<R>

suspend fun <T : Any, R : Any> DataSet<T>.map(outputType: KType, coroutineContext: CoroutineContext = EmptyCoroutineContext, metaTransform: MutableMeta.() -> Unit = {}, block: suspend (T) -> R): DataTree<R>

inline fun <T : Any, R : Any> Data<T>.map(coroutineContext: CoroutineContext = EmptyCoroutineContext, meta: Meta = this.meta, crossinline block: suspend (T) -> R): Data<R>

Lazily transform this data to another data. By convention block should not use external data (be pure).