core/org.jetbrains.kotlinx.dataframe.impl.columns/ColumnWithParent

ColumnWithParent

internal interface ColumnWithParent<out C> : ColumnReference<C>

Inheritors

ColumnGroupWithParent

FrameColumnWithParent

ValueColumnWithParent

Properties

name

internal val ColumnReference<*>.name: String

parent

abstract val parent: ColumnGroupReference?

source

abstract val source: BaseColumn<C>

Functions

addFlag

internal fun <C> ColumnsResolver<C>.addFlag(flag: SortFlag): ColumnSetWithSortFlag<C>

allAfterInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allAfterInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a new ColumnSet containing all columns after the first column that matches the given predicate.

allBeforeInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allBeforeInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a new ColumnSet containing all columns before the first column that satisfies the given predicate.

allColsExceptInternal

internal fun SingleColumn<DataRow<*>>.allColsExceptInternal(other: ColumnsResolver<*>): ColumnSet<Any?>

Returns a new ColumnSet that contains all columns from inside the receiver column group except those specified in the "other" ColumnsResolver.

allColumnsInternal

@PublishedApi

internal fun ColumnsResolver<*>.allColumnsInternal(removePaths: Boolean = false): TransformableColumnSet<*>

If this is a SingleColumn containing a single ColumnGroup (like SingleColumn<AnyRow> or ColumnsSelectionDsl), it returns a (transformable) ColumnSet containing the children of this ColumnGroup, else it simply returns a (transformable) ColumnSet from this (like when this is a ColumnSet).

allFromInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allFromInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a column set containing all columns from the internal column set that satisfy the given predicate.

allUpToInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.allUpToInternal(crossinline colByPredicate: ColumnFilter<*>): ColumnSet<*>

Returns a ColumnSet containing all columns up to (and including) the first column that satisfies the given predicate.

asColumnGroup

fun <C> SingleColumn<C>.asColumnGroup(): SingleColumn<DataRow<C>>

@JvmName(name = "asColumnGroupDataRow")

fun <C> SingleColumn<DataRow<C>>.asColumnGroup(): SingleColumn<DataRow<C>>

Creates a ColumnAccessor<DataRow<C>> from this. This is especially useful when you want to use ColumnGroup functions in the ColumnsSelectionDsl but your column type is not recognized as a ColumnGroup. If you're not sure whether a column is recognized as ColumnGroup or not, you can always call asColumnGroup and it will return the same type if it is already a ColumnGroup.

asColumnSet

internal fun <C> ColumnsResolver<C>.asColumnSet(): ColumnSet<C>

@PublishedApi

internal fun <C> SingleColumn<C>.asColumnSet(): ColumnSet<C>

asComparable

fun <T> SingleColumn<T>.asComparable(): SingleColumn<Comparable<T>>

asNumbers

@JvmName(name = "asNumbersAnyNullable")

fun SingleColumn<Any?>.asNumbers(): SingleColumn<Number?>

@JvmName(name = "asNumbersAny")

fun SingleColumn<Any>.asNumbers(): SingleColumn<Number>

cast

fun <C> ColumnReference<*>.cast(): ColumnReference<C>

fun <C> ColumnsResolver<*>.cast(): ColumnsResolver<C>

fun <C> SingleColumn<*>.cast(): SingleColumn<C>

castToNotNullable

fun <T> ColumnReference<T?>.castToNotNullable(): ColumnReference<T>

castToNullable

fun <T> ColumnReference<T>.castToNullable(): ColumnReference<T?>

colsAtAnyDepthInternal

internal fun ColumnsResolver<*>.colsAtAnyDepthInternal(predicate: ColumnFilter<*>): ColumnSet<*>

Returns all columns inside this ColumnsResolver at any depth if they satisfy the given predicate.

colsInternal

@PublishedApi

internal inline fun ColumnsResolver<*>.colsInternal(crossinline predicate: ColumnFilter<*>): TransformableColumnSet<*>

If this ColumnsResolver is a SingleColumn, it returns a new ColumnSet containing the columns inside of this SingleColumn that match the given predicate.

internal fun ColumnsResolver<*>.colsInternal(indices: IntArray): TransformableColumnSet<*>

internal fun ColumnsResolver<*>.colsInternal(range: IntRange): TransformableColumnSet<*>

internal fun SingleColumn<DataRow<*>>.colsInternal(refs: Iterable<ColumnReference<*>>): ColumnSet<*>

colsOf

inline fun <reified C> SingleColumn<DataRow<*>>.colsOf(noinline filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

fun <C> SingleColumn<DataRow<*>>.colsOf(type: KType, filter: (ColumnWithPath<C>) -> Boolean = { true }): ColumnSet<C>

Returns a ColumnSet of columns from this that are a subtype of the given type C, optionally filtered by filter.

colsOfInternal

internal inline fun <C> ColumnsResolver<*>.colsOfInternal(type: KType, crossinline filter: ColumnFilter<C>): TransformableColumnSet<C>

If this ColumnsResolver is a SingleColumn, it returns a new ColumnSet containing the columns inside of this SingleColumn that match the given filter and are the given type.

column

fun <T> ColumnReference<DataRow<*>>.column(): ColumnDelegate<T>

fun <T> ColumnReference<DataRow<*>>.column(name: String): ColumnAccessor<T>

fun <T> ColumnReference<DataRow<*>>.~~column~~(property: KProperty<T>): ColumnAccessor<T>

fun <T> ColumnReference<DataRow<*>>.column(path: ColumnPath): ColumnAccessor<T>

columnGroup

fun ColumnReference<DataRow<*>>.columnGroup(): ColumnDelegate<DataRow<*>>

fun ColumnReference<DataRow<*>>.columnGroup(name: String): ColumnAccessor<DataRow<*>>

fun <T> ColumnReference<DataRow<*>>.~~columnGroup~~(property: KProperty<T>): ColumnAccessor<DataRow<T>>

@JvmName(name = "columnGroupDataRowKProperty")

fun <T> ColumnReference<DataRow<*>>.~~columnGroup~~(property: KProperty<DataRow<T>>): ColumnAccessor<DataRow<T>>

fun ColumnReference<DataRow<*>>.columnGroup(path: ColumnPath): ColumnAccessor<DataRow<*>>

columnGroupsInternal

internal inline fun ColumnsResolver<*>.columnGroupsInternal(crossinline filter: (ColumnGroup<*>) -> Boolean): ColumnSet<DataRow<*>>

Returns a ColumnSet containing the column groups that satisfy the given filter.

columnsOfKindInternal

internal inline fun ColumnsResolver<*>.columnsOfKindInternal(kinds: Set<ColumnKind>, crossinline filter: ColumnFilter<*>): TransformableColumnSet<*>

Returns a TransformableColumnSet containing the columns of given kind(s) that satisfy the given filter.

div

operator fun ColumnReference<Int>.div(value: Int): ColumnReference<Int>

Returns a ColumnReference containing the results of dividing each element of this ColumnReference by value.

ensureIsColumnGroup

@PublishedApi

internal fun <C> SingleColumn<DataRow<C>>.ensureIsColumnGroup(): SingleColumn<DataRow<C>>

Checks the validity of this SingleColumn, by adding a check to see it's a ColumnGroup (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

ensureIsFrameColumn

internal fun <C> SingleColumn<DataFrame<C>>.ensureIsFrameColumn(): SingleColumn<DataFrame<C>>

Checks the validity of this SingleColumn, by adding a check to see it's a FrameColumn (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

ensureIsValueColumn

internal fun <C> SingleColumn<C>.ensureIsValueColumn(): SingleColumn<C>

Checks the validity of this SingleColumn, by adding a check to see it's a ValueColumn (so, a SingleColumn<*>) and throwing an IllegalArgumentException if it's not.

infix fun <C> ColumnReference<C>.eq(value: C): ColumnReference<Boolean>

exceptInternal

@JvmName(name = "exceptInternalSingleColumn")

internal fun <C> SingleColumn<DataRow<C>>.exceptInternal(other: ColumnsResolver<*>): SingleColumn<DataRow<C>>

Returns a new SingleColumn> that has the same structure as the receiver, but excludes columns specified in the "other" ColumnsResolver.

extractJoinColumns

internal fun <C> ColumnsResolver<C>.extractJoinColumns(): List<ColumnMatch<C>>

flattenRecursively

internal fun ColumnsResolver<*>.flattenRecursively(includeGroups: Boolean = true, includeTopLevel: Boolean = true): ColumnsResolver<*>

Flattens a ColumnsResolver recursively.

frameColumn

fun ColumnReference<DataRow<*>>.frameColumn(): ColumnDelegate<DataFrame<*>>

fun ColumnReference<DataRow<*>>.frameColumn(name: String): ColumnAccessor<DataFrame<*>>

fun <T> ColumnReference<DataRow<*>>.~~frameColumn~~(property: KProperty<List<T>>): ColumnAccessor<DataFrame<T>>

@JvmName(name = "frameColumnDataFrameKProperty")

fun <T> ColumnReference<DataRow<*>>.~~frameColumn~~(property: KProperty<DataFrame<T>>): ColumnAccessor<DataFrame<T>>

fun ColumnReference<DataRow<*>>.frameColumn(path: ColumnPath): ColumnAccessor<DataFrame<*>>

frameColumnsInternal

internal inline fun ColumnsResolver<*>.frameColumnsInternal(crossinline filter: (FrameColumn<*>) -> Boolean): TransformableColumnSet<AnyFrame>

Returns a TransformableColumnSet containing the frame columns that satisfy the given filter.

getAt

internal fun <T> ColumnsResolver<T>.getAt(index: Int): SingleColumn<T>

getValue

open fun getValue(row: AnyRow): C

open operator fun getValue(thisRef: Any?, property: KProperty<*>): ColumnReference<C>

getValueOrNull

open fun getValueOrNull(row: AnyRow): C?

infix fun <C : Comparable<C>> ColumnReference<C>.gt(value: C): ColumnReference<Boolean>

length

fun ColumnReference<String?>.~~length~~(): ColumnReference<Int>

lowercase

fun ColumnReference<String?>.~~lowercase~~(): ColumnReference<String?>

infix fun <C : Comparable<C>> ColumnReference<C>.lt(value: C): ColumnReference<Boolean>

map

internal inline fun <C, reified R> ColumnReference<C>.~~map~~(infer: Infer = Infer.Nulls, noinline transform: (C) -> R): ColumnReference<R>

minus

operator fun ColumnReference<Int>.minus(value: Int): ColumnReference<Int>

Returns a ColumnReference where each element is the result of subtracting value from the corresponding element of this ColumnReference.

name

abstract fun name(): String

neq

infix fun <C> ColumnReference<C>.~~neq~~(value: C): ColumnReference<Boolean>

not

@JvmName(name = "notBooleanNullable")

operator fun ColumnReference<Boolean?>.not(): ColumnReference<Boolean?>

Returns a ColumnReference containing the inverse Boolean values of this ColumnReference. Each null value in the original ColumnReference is preserved.

operator fun ColumnReference<Boolean>.not(): ColumnReference<Boolean>

Returns a ColumnReference containing the inverse Boolean values of this ColumnReference.

onResolve

internal fun <A> SingleColumn<A>.onResolve(check: (ColumnWithPath<A>?) -> Unit): SingleColumn<A>

Helper function to perform runtime checks on a SingleColumn.

path

open override fun path(): ColumnPath

plus

operator fun ColumnReference<Any?>.plus(str: String): ColumnReference<String>

Returns a ColumnReference of String values obtained by converting each element of this ColumnReference to a String and concatenating it with str.

operator fun ColumnReference<Int>.plus(value: Int): ColumnReference<Int>

Returns a ColumnReference where each element is the result of adding value to the corresponding element of this ColumnReference.

rename

abstract fun rename(newName: String): ColumnReference<C>

renamedColumn

internal fun <C> SingleColumn<C>.renamedColumn(newName: String): SingleColumn<C>

renamedReference

internal fun <C> ColumnReference<C>.renamedReference(newName: String): ColumnReference<C>

resolve

open override fun resolve(context: ColumnResolutionContext): List<ColumnWithPath<C>>

Resolves this ColumnsResolver as a List<ColumnWithPath<C>>. In many cases this function transforms a parent ColumnsResolver to reach the current ColumnsResolver result.

resolve

internal fun <C> ColumnsResolver<C>.resolve(df: DataFrame<*>, unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail): List<ColumnWithPath<C>>

resolveFor

internal fun <C> ColumnReference<C>.resolveFor(df: AnyFrame): ColumnWithPath<C>?

resolveSingle

open override fun resolveSingle(context: ColumnResolutionContext): ColumnWithPath<C>?

resolveSingle

internal fun <C> SingleColumn<C>.resolveSingle(df: DataFrame<*>, unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail): ColumnWithPath<C>?

selectInternal

internal fun <C, R> SingleColumn<DataRow<C>>.selectInternal(selector: ColumnsSelector<C, R>): ColumnSet<R>

shortPath

internal fun ColumnReference<*>.shortPath(): ColumnPath

simplifyInternal

internal fun ColumnsResolver<*>.simplifyInternal(): ColumnSet<*>

Simplifies structure by removing columns that are already present in column groups in this.

singleImpl

internal fun <T> ColumnsResolver<T>.singleImpl(): SingleColumn<T>

Converts this ColumnsResolver to a SingleColumn. resolveSingle will return the single column of this if there is only one, else it will throw an exception: In case of an empty ColumnsResolver, a NoSuchElementException will be thrown. In case of more than one column, an IllegalArgumentException will be thrown. If the result is used as a ColumnSet, null will be converted to an empty list.

singleInternal

internal fun <C> ColumnsResolver<C>.singleInternal(condition: ColumnFilter<C> = { true }): TransformableSingleColumn<C>

singleOrNullImpl

internal fun <T> ColumnsResolver<T>.singleOrNullImpl(): SingleColumn<T>

Converts this ColumnsResolver to a SingleColumn. resolveSingle will return the single column of this if there is only one, else it will return null. If the result used as a ColumnSet, null will be converted to an empty list.

times

operator fun ColumnReference<Int>.times(value: Int): ColumnReference<Int>

Returns a ColumnReference containing the results of multiplying each element of this ColumnReference by value.

toColumnAccessor

fun <T> ColumnReference<T>.toColumnAccessor(): ColumnAccessor<T>

transform

@PublishedApi

internal inline fun <A, B> ColumnsResolver<A>.transform(crossinline converter: (List<ColumnWithPath<A>>) -> List<ColumnWithPath>): TransformableColumnSet

Applies a transformation on this by converting its List<ColumnWithPath<A>] to List<ColumnWithPath<B>] using converter.

transformSingle

internal fun <A, B> SingleColumn<A>.transformSingle(converter: (ColumnWithPath<A>) -> List<ColumnWithPath>): ColumnSet

Applies a transformation on this SingleColumn by converting its single ColumnWithPath<A> to List<ColumnWithPath<B>] using converter. Since converter allows you to return multiple columns, the result is turned into a ColumnSet<B>.

transformSingleWithContext

internal fun <A, B> SingleColumn<A>.transformSingleWithContext(converter: ColumnResolutionContext.(ColumnWithPath<A>) -> List<ColumnWithPath>): ColumnSet

Applies a transformation on this SingleColumn by converting its single ColumnWithPath<A> to List<ColumnWithPath<B>] using converter but also providing the ColumnResolutionContext to the converter.

transformWithContext

internal fun <A, B> ColumnsResolver<A>.transformWithContext(converter: ColumnResolutionContext.(List<ColumnWithPath<A>>) -> List<ColumnWithPath>): TransformableColumnSet

Applies a transformation on this by converting its List<ColumnWithPath<A>] to List<ColumnWithPath<B>] using converter, but also providing the ColumnResolutionContext to the converter.

unaryMinus

operator fun ColumnReference<Int>.unaryMinus(): ColumnReference<Int>

Returns a ColumnReference containing negatives of the corresponding elements of this ColumnReference.

uppercase

fun ColumnReference<String?>.~~uppercase~~(): ColumnReference<String?>

valueColumn

fun ColumnReference<DataRow<*>>.valueColumn(): ColumnDelegate<Any?>

fun ColumnReference<DataRow<*>>.valueColumn(name: String): ColumnAccessor<Any?>

fun <T> ColumnReference<DataRow<*>>.~~valueColumn~~(property: KProperty<T>): ColumnAccessor<T>

fun ColumnReference<DataRow<*>>.valueColumn(path: ColumnPath): ColumnAccessor<Any?>

valueColumnsInternal

internal inline fun ColumnsResolver<*>.valueColumnsInternal(crossinline filter: (ValueColumn<*>) -> Boolean): TransformableColumnSet<*>

Returns a TransformableColumnSet containing the value columns that satisfy the given filter.

withValues

inline fun <reified T> ColumnReference<T>.~~withValues~~(values: Iterable<T>): ValueColumn<T>

inline fun <reified T> ColumnReference<T>.~~withValues~~(vararg values: T): ValueColumn<T>