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

Package-level declarations

Types

internal class AddDataRowImpl<T>(index: Int, owner: DataFrame<T>, container: List<*>) : DataRowImpl<T> , AddDataRow<T>

internal class ColumnAccessorImpl<T>(val path: ColumnPath) : ColumnAccessor<T>

internal open class ColumnGroupImpl<T>(name: String, df: DataFrame<T>) : DataFrameImpl<T> , DataColumnInternal<DataRow<T>> , DataColumnGroup<T>

ColumnGroupWithParent

internal class ColumnGroupWithParent<T>(val parent: ColumnGroupReference?, val source: ColumnGroup<T>) : ColumnGroupImpl<T> , ColumnWithParent<DataRow<T>>

ColumnGroupWithPathImpl

internal class ColumnGroupWithPathImpl<T>(val column: ColumnGroup<T>, val path: ColumnPath) : ColumnGroupImpl<T> , ColumnWithPath<DataRow<T>>

ColumnListImpl

internal class ColumnListImpl<C>(val columns: List<ColumnsResolver<C>>) : ColumnSet<C> , ColumnsList<C>

ColumnsList

interface ColumnsList<C> : ColumnSet<C>

ColumnsResolverTransformer

@PublishedApi

internal interface ColumnsResolverTransformer

This contains implementations for both transform and transformSingle and can be passed around.

ColumnWithParent

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

ComputedColumnReference

internal class ComputedColumnReference<R>(val name: String, val type: KType, val infer: Infer, val compute: RowExpression<Any?, R>) : ColumnReference<R>

DataColumnGroup

internal interface DataColumnGroup<out T> : ColumnGroup<T> , DataColumn<DataRow<T>>

DataColumnImpl

internal abstract class DataColumnImpl<T>(val values: List<T>, val name: String, val type: KType, distinct: Lazy<Set<T>>? = null) : DataColumn<T> , DataColumnInternal<T>

DataColumnInternal

internal interface DataColumnInternal<T> : DataColumn<T>

DistinctColumnSet

internal class DistinctColumnSet<T>(val src: ColumnsResolver<T>) : ColumnSet<T>

ForceResolvedColumn

internal interface ForceResolvedColumn<T> : DataColumn<T>

FrameColumnImpl

internal open class FrameColumnImpl<T>(name: String, values: List<DataFrame<T>>, columnSchema: Lazy<DataFrameSchema>? = null, distinct: Lazy<Set<DataFrame<T>>>? = null) : DataColumnImpl<DataFrame<T>> , FrameColumn<T>

FrameColumnWithParent

internal class FrameColumnWithParent<T>(val parent: ColumnGroup<*>, val source: FrameColumn<T>) : ColumnWithParent<DataFrame<T>> , FrameColumn<T> , DataColumnInternal<DataFrame<T>>

FrameColumnWithPathImpl

internal class FrameColumnWithPathImpl<T>(val data: FrameColumn<T>, val path: ColumnPath) : ColumnWithPath<DataFrame<T>> , FrameColumn<T>

RenamedColumnReference

internal class RenamedColumnReference<C>(val source: ColumnReference<C>, val name: String) : ColumnReference<C>

RenamedSingleColumn

internal class RenamedSingleColumn<C>(val source: SingleColumn<C>, val name: String) : SingleColumn<C>

ResolvingColumnGroup

internal class ResolvingColumnGroup<T>(val source: ColumnGroupImpl<T>) : DataColumnGroup<T> , ForceResolvedColumn<DataRow<T>>

ResolvingFrameColumn

internal class ResolvingFrameColumn<T>(val source: FrameColumn<T>) : FrameColumn<T> , ForceResolvedColumn<DataFrame<T>>

ResolvingValueColumn

internal class ResolvingValueColumn<T>(val source: ValueColumn<T>) : ValueColumnInternal<T> , ForceResolvedColumn<T>

StatisticResult

@JvmInline

internal value class StatisticResult(val value: Any?)

TransformableColumnSet

@PublishedApi

internal interface TransformableColumnSet<out C> : ColumnSet<C>

This type of ColumnsResolver can be transformed before being resolved.

TransformableSingleColumn

internal interface TransformableSingleColumn<out C> : SingleColumn<C>

This type of SingleColumn can be transformed before being resolved.

ValueColumnImpl

internal open class ValueColumnImpl<T>(values: List<T>, name: String, type: KType, val defaultValue: T? = null, distinct: Lazy<Set<T>>? = null, statisticsCache: MutableMap<String, MutableMap<Map<String, Any>, StatisticResult>> = mutableMapOf()) : DataColumnImpl<T> , ValueColumn<T> , ValueColumnInternal<T>

ValueColumnInternal

internal interface ValueColumnInternal<T> : ValueColumn<T>

ValueColumnWithParent

internal class ValueColumnWithParent<T>(val parent: ColumnGroup<*>, val source: ValueColumn<T>) : ColumnWithParent<T> , ValueColumnInternal<T> , DataColumnInternal<T>

ValueColumnWithPathImpl

internal class ValueColumnWithPathImpl<T>(val data: ValueColumn<T>, val path: ColumnPath) : ColumnWithPath<T> , ValueColumnInternal<T>

Properties

anyRowType

internal val anyRowType: KType

Functions

addParent

internal fun <T> BaseColumn<T>.addParent(parent: ColumnGroup<*>): DataColumn<T>

addParentPath

internal fun <T> BaseColumn<T>.addParentPath(path: ColumnPath): ColumnWithPath<T>

addPath

internal fun <T> BaseColumn<T>.addPath(): ColumnWithPath<T>

internal fun <T> BaseColumn<T>.addPath(path: ColumnPath): ColumnWithPath<T>

allColumnsExceptAndUnpack

internal fun List<ColumnWithPath<*>>.allColumnsExceptAndUnpack(columns: Iterable<ColumnWithPath<*>>): List<ColumnWithPath<*>>

Returns a new list of column paths, except the ones inside columns. NOTE: The structure is not kept the same; if a column is removed, its parent will be removed as well, and all its siblings will be lifted out of the group. This also happens if a column is "removed" that does not exist in this.

allColumnsExceptKeepingStructure

internal fun List<ColumnWithPath<*>>.allColumnsExceptKeepingStructure(columns: Set<ColumnWithPath<*>>, removeEmptyGroups: Boolean = true): List<ColumnWithPath<*>>

Returns a new list of column paths, except the ones inside columns. NOTE: ColumnGroups are adapted to keep their structure. If a column inside a column group is excepted, it will be removed from the group. Empty groups will be removed if removeEmptyGroups== true

asAnyFrameColumn

@PublishedApi

internal fun AnyCol.asAnyFrameColumn(): FrameColumn<*>

assertIsComparable

internal fun <T> DataColumn<T>.assertIsComparable(): DataColumn<T>

asValueColumn

internal fun <T> DataColumn<T>.asValueColumn(): ValueColumn<T>

asValues

internal fun <T> AnyCol.asValues(): ValueColumn<T>

atAnyDepthImpl

internal fun <C> TransformableColumnSet<C>.atAnyDepthImpl(includeGroups: Boolean = true, includeTopLevel: Boolean = true): ColumnSet<C>

AtAnyDepth implementation for TransformableColumnSet. This converts a TransformableColumnSet into a ColumnSet by redirecting ColumnSet.resolve to TransformableColumnSet.transformResolve with a correctly configured AtAnyDepthTransformer.

internal fun <C> TransformableSingleColumn<C>.atAnyDepthImpl(includeGroups: Boolean = true, includeTopLevel: Boolean = true): SingleColumn<C>

AtAnyDepth implementation for TransformableSingleColumn. This converts a TransformableSingleColumn into a SingleColumn by redirecting SingleColumn.resolveSingle to TransformableSingleColumn.transformResolveSingle with a correctly configured AtAnyDepthTransformer.

changePath

internal fun <T> ColumnWithPath<T>.changePath(path: ColumnPath): ColumnWithPath<T>

checkEquals

internal fun <T> BaseColumn<T>.checkEquals(other: Any?): Boolean

computeValues

internal fun <T, R> computeValues(df: DataFrame<T>, expression: AddExpression<T, R>): Pair<Boolean, List<R>>

createColumnGuessingType

@PublishedApi

internal fun <T> createColumnGuessingType(values: Iterable<T>, suggestedType: TypeSuggestion = TypeSuggestion.Infer, defaultValue: T? = null, nullable: Boolean? = null, listifyValues: Boolean = false, allColsMakesColGroup: Boolean = false, unifyNumbers: Boolean = false): DataColumn<T>

@PublishedApi

internal fun <T> createColumnGuessingType(name: String, values: Iterable<T>, suggestedType: TypeSuggestion = TypeSuggestion.Infer, defaultValue: T? = null, nullable: Boolean? = null, listifyValues: Boolean = false, allColsMakesColGroup: Boolean = false, unifyNumbers: Boolean = false): DataColumn<T>

Creates a new column by doing type inference on the given values and some conversions to unify the values if necessary.

createColumnSet

internal inline fun <C> createColumnSet(crossinline resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>): ColumnSet<C>

createComputedColumnReference

@PublishedApi

internal fun <R> createComputedColumnReference(name: String, type: KType, infer: Infer, compute: RowExpression<Any?, R>): ColumnReference<R>

createTransformableColumnSet

internal fun <C> createTransformableColumnSet(resolver: (context: ColumnResolutionContext) -> List<ColumnWithPath<C>>, transformResolve: (context: ColumnResolutionContext, transformer: ColumnsResolverTransformer) -> List<ColumnWithPath<C>>): TransformableColumnSet<C>

depth

internal fun ColumnPath.depth(): Int

extractDataFrame

internal fun <T> ColumnGroup<T>.extractDataFrame(): DataFrame<T>

flattenRecursively

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

Flattens a ColumnsResolver recursively.

forceResolve

@PublishedApi

internal fun <T : AnyCol> T.forceResolve(): T

getAt

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

getAtOrNull

internal fun <T> ColumnSet<T>.getAtOrNull(index: Int): SingleColumn<T>

getChildrenAt

internal fun ColumnSet<*>.getChildrenAt(index: Int): ColumnSet<*>

getColumn

internal fun <C> ColumnsContainer<*>.getColumn(name: String, policy: UnresolvedColumnsPolicy): DataColumn<C>?

internal fun <C> ColumnsContainer<*>.getColumn(path: ColumnPath, policy: UnresolvedColumnsPolicy): DataColumn<C>?

getHashCode

internal fun AnyCol.getHashCode(): Int

grouped

internal fun <T> AnyCol.grouped(): ColumnGroup<T>

internal

internal fun <T> DataColumn<T>.internal(): DataColumnInternal<T>

internalValueColumn

internal fun <T> ValueColumn<T>.internalValueColumn(): ValueColumnInternal<T>

isMissingColumn

internal fun AnyCol.isMissingColumn(): Boolean

newColumn

@PublishedApi

internal fun <T, R> ColumnsContainer<T>.newColumn(type: KType, name: String = "", infer: Infer = Infer.Nulls, expression: AddExpression<T, R>): DataColumn<R>

newColumnWithActualType

@PublishedApi

internal fun <T, R> ColumnsContainer<T>.newColumnWithActualType(name: String, expression: AddExpression<T, R>): DataColumn<R>

onResolve

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

Helper function to perform runtime checks on a ColumnAccessor.

internal fun <A> ColumnSet<A>.onResolve(check: (List<ColumnWithPath<A>>) -> Unit): ColumnSet<A>

internal fun <A> TransformableColumnSet<A>.onResolve(check: (List<ColumnWithPath<A>>) -> Unit): TransformableColumnSet<A>

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

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

Helper function to perform runtime checks on a SingleColumn.

renamedColumn

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

resolve

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

resolveSingle

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

simplify

internal fun <T> List<ColumnWithPath<T>>.simplify(): List<ColumnWithPath<T>>

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.

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.

singleOrNullWithTransformerImpl

internal fun <T> TransformableColumnSet<T>.singleOrNullWithTransformerImpl(): TransformableSingleColumn<T>

Same as singleOrNullImpl, however, it passes any ColumnsResolverTransformer back to this if it is supplied.

singleWithTransformerImpl

internal fun <T> TransformableColumnSet<T>.singleWithTransformerImpl(): TransformableSingleColumn<T>

Same as singleImpl, however, it passes any ColumnsResolverTransformer back to this if it is supplied.

toColumnKind

internal fun KType.toColumnKind(): ColumnKind

Retrieves the correct ColumnKind based on the type of the values in the column.

toColumnSet

internal fun <T, C> ColumnsSelector<T, C>.toColumnSet(): ColumnSet<C>

@JvmName(name = "toColumnSetForPivot")

internal fun <T, C> PivotColumnsSelector<T, C>.toColumnSet(): ColumnSet<C>

@JvmName(name = "toColumnSetForSort")

internal fun <T, C> SortColumnsSelector<T, C>.toColumnSet(): ColumnSet<C>

internal inline fun <TD, T : DataFrame<TD>, C> Selector<T, ColumnsResolver<C>>.toColumnSet(crossinline createReceiver: (ColumnResolutionContext) -> T): ColumnSet<C>

toColumnWithPath

internal fun <C> TreeNode<ColumnPosition>.toColumnWithPath(): ColumnWithPath<C>

toComparableColumn

internal fun String.toComparableColumn(): ColumnAccessor<Comparable<Any?>>

toComparableColumns

internal fun Array<out String>.toComparableColumns(): ColumnSet<Comparable<Any?>>

toNumberColumns

internal fun Array<out String>.toNumberColumns(): ColumnSet<Number>

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.

unbox

internal fun AnyBaseCol.unbox(): AnyCol

withDf

internal fun <T> ColumnGroup<*>.withDf(newDf: DataFrame<T>): ColumnGroup<T>