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

Package-level declarations

Types

internal class AggregatedPivot<T>(df: DataFrame<T>, val inward: Boolean?, var aggregator: GroupByReceiverImpl<T>) : DataFrame<T>

ColumnGroupByResult

internal typealias ColumnGroupByResult = Array<AnyCol>

ColumnSetWithSortFlag

internal class ColumnSetWithSortFlag<C>(val column: ColumnsResolver<C>, val flag: SortFlag) : ColumnSet<C>

ColumnToInsert

internal data class ColumnToInsert(val insertionPath: ColumnPath, val column: AnyBaseCol, val referenceNode: ReadonlyTreeNode<ReferenceData>? = null)

ConvertSchemaDslInternal

internal interface ConvertSchemaDslInternal<T> : ConvertSchemaDsl<T>

CreateDataFrameDslImpl

internal class CreateDataFrameDslImpl<T>(val source: Iterable<T>, type: KType, prefix: ColumnPath = emptyPath(), configuration: CreateDataFrameDslImpl.TraverseConfiguration = TraverseConfiguration()) : CreateDataFrameDsl<T>

GroupedDataRowImpl

internal class GroupedDataRowImpl<T, G>(row: DataRow<T>, frameCol: FrameColumn<G>) : GroupedDataRow<T, G> , DataRow<T>

JoinedDataRowImpl

internal class JoinedDataRowImpl<A, B>(leftOwner: DataFrame<A>, val index: Int, rightOwner: DataFrame<B>, index1: Int) : DataRowImpl<A> , JoinedDataRow<A, B>

MergedAttributes

internal class MergedAttributes(attributes: List<CellAttributes>) : CellAttributes

ParserFunction

internal typealias ParserFunction<T> = (String) -> T?

Parsers

internal object Parsers : GlobalParserOptions

Central implementation for GlobalParserOptions.

PivotChain

internal class PivotChain<C>(val columns: List<PivotChainElement>, lastColumn: ColumnWithPath<C>) : ColumnWithPath<C>

PivotChainColumnSet

internal class PivotChainColumnSet<C>(val first: ColumnsResolver<C>, val second: ColumnsResolver<C>) : ColumnSet<C>

PivotChainElement

internal data class PivotChainElement(val column: ColumnWithPath<Any?>, val includeColumnName: Boolean)

RemoveResult

internal data class RemoveResult<T>(val df: DataFrame<T>, val removedColumns: List<TreeNode<ColumnPosition>>)

SingleAttribute

internal class SingleAttribute(val key: String, val value: String) : CellAttributes

SortColumnDescriptor

internal class SortColumnDescriptor<C>(val column: ValueColumn<C>, val direction: SortDirection = SortDirection.Asc, val nullsLast: Boolean = false) : ValueColumnInternal<C>

SortDirection

internal enum class SortDirection : Enum<SortDirection>

SortFlag

internal enum class SortFlag : Enum<SortFlag>

StringParser

internal interface StringParser<out T>

StringParserImpl

internal class StringParserImpl<T>(val type: KType, val name: String? = null, val parser: ParserFunction<T>) : StringParser<T>

StringParserImplWithOptions

internal class StringParserImplWithOptions<T>(val type: KType, val name: String? = null, val getParserForConverter: (ParserOptions?) -> ParserFunction<T>, val getParser: (ParserOptions?, List<KType>) -> ParserFunction<T>) : StringParser<T>

TypeConverter

internal typealias TypeConverter = (Any) -> Any?

WrongNumberOfValuesException

internal class WrongNumberOfValuesException(size: Int, ncol: Int) : IllegalArgumentException, DataFrameError

Properties

canBeUnfolded

@PublishedApi

internal val KClass<*>.canBeUnfolded: Boolean

Determines whether a class can be unfolded into its properties.

convertersCache

internal val convertersCache: MutableMap<Triple<KType, KType, ParserOptions?>, TypeConverter?>

defaultTimeZone

internal val defaultTimeZone: TimeZone

hasProperties

@PublishedApi

internal val KClass<*>.hasProperties: Boolean

Checks if KClass has public properties / getter functions (for pojo-like classes).

isValueType

@PublishedApi

internal val KClass<*>.isValueType: Boolean

Checks if KClass is a value type (number, datetime, string, etc.) Should be aligned with ConeKotlinType.isValueType() in plugins/kotlin-dataframe/src/org/jetbrains/kotlinx/dataframe/plugin/impl/api/toDataFrame.kt

SKIP_PARSER

internal val SKIP_PARSER: ParserFunction<Nothing?>

ParserFunction that always returns null. Useful if a parser needs to be skipped based on the provided ParserOptions.

Functions

addFlag

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

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

afterImpl

internal fun <T> InsertClause<T>.afterImpl(columnPath: ColumnPath): DataFrame<T>

afterOrBefore

internal fun <T, C> MoveClause<T, C>.afterOrBefore(column: ColumnSelector<T, *>, isAfter: Boolean): DataFrame<T>

aggregatePivot

internal fun <T, R> aggregatePivot(aggregator: AggregateInternalDsl<T>, columns: PivotColumnsSelector<T, *>, separate: Boolean, inward: Boolean? = null, globalDefault: Any? = null, body: Selector<AggregateDsl<T>, R>)

asFrameImpl

internal fun <T, C, R> Update<T, DataRow<C>>.asFrameImpl(expression: DataFrameExpression<C, DataFrame<R>>): DataFrame<T>

Implementation for Update As Frame: Replaces selected column groups with the result of the expression only where the filter is true.

beforeImpl

internal fun <T> InsertClause<T>.beforeImpl(columnPath: ColumnPath): DataFrame<T>

chunkedImpl

internal fun <T> DataFrame<T>.chunkedImpl(startIndices: Iterable<Int>, name: String = "groups"): FrameColumn<T>

Creates a FrameColumn from this by splitting the dataframe into smaller ones, based on the given startIndices.

compileTimeSchemaImpl

@PublishedApi

internal fun compileTimeSchemaImpl(runtimeSchema: DataFrameSchema?, klass: KClass<*>): DataFrameSchema

componentWise

internal fun componentWise(color1: RgbColor, color2: RgbColor, f: (Short, Short) -> Short): RgbColor

concatImpl

internal fun <T> concatImpl(dataFrames: List<DataFrame<T>>): DataFrame<T>

internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>>): DataColumn<T>

internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>?>, columnSizes: List<Int>): DataColumn<T>

convert

internal inline fun <T> convert(crossinline converter: (T) -> Any?): TypeConverter

convertRowColumnImpl

@PublishedApi

internal fun <T, C, R> Convert<T, C>.convertRowColumnImpl(type: KType, infer: Infer, rowConverter: RowColumnExpression<T, C, R>): DataFrame<T>

convertTo

internal fun Any.convertTo(type: KType): Any?

convertToDataFrame

@PublishedApi

internal fun convertToDataFrame(data: Iterable<*>, type: KType, roots: List<KCallable<*>>, excludes: Set<KCallable<*>>, preserveClasses: Set<KClass<*>>, preserveProperties: Set<KCallable<*>>, excludeClasses: Set<KClass<*>>, maxDepth: Int): AnyFrame

convertToImpl

@PublishedApi

internal fun AnyFrame.convertToImpl(type: KType, allowConversion: Boolean, excessiveColumns: ExcessiveColumns, body: ConvertSchemaDsl<Any>.() -> Unit = {}): AnyFrame

convertToTypeImpl

internal fun AnyCol.convertToTypeImpl(to: KType, parserOptions: ParserOptions?): AnyCol

corrImpl

internal fun <T, C, R> Corr<T, C>.corrImpl(otherColumns: ColumnsSelector<T, R>): DataFrame<T>

createComparator

internal fun AnyCol.createComparator(nullsLast: Boolean): Comparator<Int>

createConverter

internal fun createConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter?

createDataFrameImpl

internal fun <T> Iterable<T>.~~createDataFrameImpl~~(clazz: KClass<*>, body: CreateDataFrameDslImpl<T>.() -> Unit): DataFrame<T>

@PublishedApi

internal fun <T> Iterable<T>.createDataFrameImpl(type: KType, body: CreateDataFrameDslImpl<T>.() -> Unit): DataFrame<T>

dataFrameOf

internal fun dataFrameOf(columns: List<ColumnToInsert>): DataFrame<Unit>

defaultJoinColumns

internal fun <T> defaultJoinColumns(dataFrames: Iterable<DataFrame<T>>): JoinColumnsSelector<T, T>

describeImpl

internal fun describeImpl(cols: List<AnyCol>): DataFrame<ColumnDescription>

duplicateImpl

internal fun <T> DataFrame<T>.duplicateImpl(n: Int): FrameColumn<T>

internal fun <T> DataRow<T>.duplicateImpl(n: Int): DataFrame<T>

duplicateRowsImpl

internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int): DataFrame<T>

@PublishedApi

internal fun <T> DataFrame<T>.duplicateRowsImpl(n: Int, indicesSorted: Iterable<Int>): DataFrame<T>

duplicateValuesImpl

internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int): DataColumn<T>

internal fun <T> DataColumn<T>.duplicateValuesImpl(n: Int, indicesSorted: Iterable<Int>): DataColumn<T>

encHex

internal fun encHex(v: Short): String

encode

internal fun RgbColor.encode(): String

encRgb

internal fun encRgb(r: Short, g: Short, b: Short): String

explodeImpl

internal fun AnyCol.explodeImpl(): AnyCol

internal fun <T> DataFrame<T>.explodeImpl(dropEmpty: Boolean = true, columns: ColumnsSelector<T, *>): DataFrame<T>

extractJoinColumns

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

flattenImpl

internal fun <T, C> DataFrame<T>.flattenImpl(columns: ColumnsSelector<T, C>, keepParentNameForColumns: Boolean = false, separator: String = "_"): DataFrame<T>

formatHeaderImpl

internal fun <T, C> HeaderFormatClause<T, C>.formatHeaderImpl(formatter: HeaderColFormatter<C>): FormattedFrame<T>

formatImpl

internal inline fun <T, C> FormatClause<T, C>.formatImpl(crossinline formatter: RowColFormatter<T, C>): FormattedFrame<T>

fromPattern

@FormatStringsInDatetimeFormats

internal fun DateTimeFormat.Companion.fromPattern(pattern: String, formatType: KType): DateTimeFormat<out Any>

gatherImpl

internal fun <T, C, K, R> Gather<T, C, K, R>.gatherImpl(namesTo: String? = null, valuesTo: String? = null): DataFrame<T>

generateUnusedName

internal fun generateUnusedName(df: DataFrame<*>, preferredName: String?, insertPath: ColumnPath, columnsToBeInserted: List<ColumnToInsert>): String

getConverter

internal fun getConverter(from: KType, to: KType, options: ParserOptions? = null): TypeConverter?

getPivotColumnPaths

internal fun <T> DataFrame<T>.getPivotColumnPaths(columns: PivotColumnsSelector<T, *>): List<ColumnPath>

getPivotSequences

internal fun <T, C> DataFrame<T>.getPivotSequences(columns: PivotColumnsSelector<T, C>): List<List<PivotChainElement>>

getSortColumns

internal fun <T, C> DataFrame<T>.getSortColumns(columns: SortColumnsSelector<T, C>, unresolvedColumnsPolicy: UnresolvedColumnsPolicy): List<SortColumnDescriptor<*>>

groupByImpl

@PublishedApi

internal fun <T> DataFrame<T>.groupByImpl(moveToTop: Boolean, columns: ColumnsSelector<T, *>): GroupBy<T, T>

implodeImpl

internal fun <T, C> DataFrame<T>.implodeImpl(dropNA: Boolean = false, columns: ColumnsSelector<T, C>): DataFrame<T>

insertImpl

internal fun <T> insertImpl(df: DataFrame<T>?, columns: List<ColumnToInsert>): DataFrame<T>

internal fun <T> insertImpl(df: DataFrame<T>?, columns: List<ColumnToInsert>, treeNode: ReadonlyTreeNode<ReferenceData>?, depth: Int): DataFrame<T>

insertImpl

@JvmName(name = "insertImplT")

internal fun <T> DataFrame<T>.insertImpl(columns: List<ColumnToInsert>): DataFrame<T>

@PublishedApi

internal fun <T> DataFrame<T>.insertImpl(path: ColumnPath, column: AnyCol): DataFrame<T>

joinImpl

internal fun <A, B> DataFrame<A>.joinImpl(other: DataFrame<B>, joinType: JoinType = JoinType.Inner, addNewColumns: Boolean = true, selector: JoinColumnsSelector<A, B>?): DataFrame<A>

joinWithImpl

internal fun <A, B> DataFrame<A>.joinWithImpl(right: DataFrame<B>, type: JoinType = JoinType.Inner, addNewColumns: Boolean, joinExpression: JoinExpression<A, B>): DataFrame<A>

linearGradient

internal fun linearGradient(x: Double, minValue: Double, minColor: RgbColor, maxValue: Double, maxColor: RgbColor): RgbColor

mapNotNullValues

@PublishedApi

internal fun <T, R> DataColumn<T?>.mapNotNullValues(transform: (T) -> R): DataColumn<R?>

moveImpl

internal fun <T, C> MoveClause<T, C>.moveImpl(under: Boolean = false, newPathExpression: ColumnsSelectionDsl<T>.(ColumnWithPath<C>) -> AnyColumnReference): DataFrame<T>

moveTo

internal fun <T, C> MoveClause<T, C>.moveTo(columnIndex: Int): DataFrame<T>

moveToImpl

internal fun <T, C> MoveClause<T, C>.moveToImpl(columnIndex: Int, insideGroup: Boolean): DataFrame<T>

parse

internal fun <T> DataColumn<String?>.parse(parser: StringParser<T>, options: ParserOptions?): DataColumn<T?>

parseBy

internal fun <T> parseBy(body: ParserFunction<T>): ParserFunction<T>

Tiny helper function to create a correctly typed ParserFunction<T>, aka (String) -> T?.

parseImpl

internal fun <T> DataFrame<T>.parseImpl(options: ParserOptions?, columns: ColumnsSelector<T, Any?>): DataFrame<T>

putColumnsOrder

internal fun MutableMap<ColumnPath, Int>.putColumnsOrder(schema: DataFrameSchema, path: ColumnPath)

removeImpl

internal fun <T> DataFrame<T>.removeImpl(allowMissingColumns: Boolean = false, columns: ColumnsSelector<T, *>): RemoveResult<T>

renameImpl

internal fun <T, C> RenameClause<T, C>.renameImpl(newNames: Array<out String>): DataFrame<T>

internal fun <T, C> RenameClause<T, C>.renameImpl(transform: (ColumnWithPath<C>) -> String): DataFrame<T>

reorderImpl

internal fun <T, C, V : Comparable<V>> Reorder<T, C>.reorderImpl(desc: Boolean, expression: ColumnExpression<C, V>, unwrapSingleColumnGroup: Boolean = true): DataFrame<T>

requireImpl

@PublishedApi

internal fun <T, C> DataFrame<T>.requireImpl(column: ColumnSelector<T, C>, type: KType): DataFrame<T>

reversed

internal fun SortDirection.reversed(): SortDirection

sortByImpl

internal fun <T, G> GroupBy<T, G>.sortByImpl(columns: SortColumnsSelector<G, *>): GroupBy<T, G>

internal fun <T, C> DataFrame<T>.sortByImpl(unresolvedColumnsPolicy: UnresolvedColumnsPolicy = UnresolvedColumnsPolicy.Fail, columns: SortColumnsSelector<T, C>): DataFrame<T>

sortedBy

internal fun DataFrameSchema.sortedBy(order: Map<ColumnPath, Int>, path: ColumnPath): DataFrameSchema

splitDefault

internal fun String.splitDefault(): List<String>

splitImpl

internal fun <T, C, R> splitImpl(clause: SplitWithTransform<T, C, R>, columnNamesGenerator: ColumnWithPath<C>.(Int) -> List<String>): DataFrame<T>

toBigDecimal

internal fun Number.toBigDecimal(): BigDecimal

toBigInteger

internal fun Number.toBigInteger(): BigInteger

toLocalDate

internal fun Long.toLocalDate(zone: TimeZone = defaultTimeZone): LocalDate

internal fun Instant.toLocalDate(zone: TimeZone = defaultTimeZone): LocalDate

toLocalDateTime

internal fun Long.toLocalDateTime(zone: TimeZone = defaultTimeZone): LocalDateTime

toLocalTime

internal fun Long.toLocalTime(zone: TimeZone = defaultTimeZone): LocalTime

internal fun Instant.toLocalTime(zone: TimeZone = defaultTimeZone): LocalTime

toSequenceImpl

@PublishedApi

internal fun AnyFrame.toSequenceImpl(type: KType): Sequence<Any>

tryParseImpl

internal fun DataColumn<String?>.tryParseImpl(options: ParserOptions?): DataColumn<*>

Tries to parse a column of strings into a column of a different type. Each parser in Parsers is run in order until a valid parser is found, a.k.a. that parser was able to parse all values in the column successfully. If a parser fails to parse any value, the next parser is tried. If all the others fail, the final parser simply returns the original string, leaving the column unchanged.

typeParametersSubstitution

internal fun KType.typeParametersSubstitution(): Map<KTypeParameter, KType>

unfoldImpl

@PublishedApi

internal fun <T> DataColumn<T>.unfoldImpl(type: KType, body: CreateDataFrameDsl<T>.() -> Unit): AnyCol

updateImpl

@PublishedApi

internal fun <T, C> Update<T, C>.updateImpl(expression: (AddDataRow<T>, DataColumn<C>, C) -> C?): DataFrame<T>

internal fun <T, C> DataColumn<C>.updateImpl(df: DataFrame<T>, filter: RowValueFilter<T, C>?, expression: (AddDataRow<T>, DataColumn<C>, C) -> C?): DataColumn<C>

updateWith

internal fun <T> DataColumn<T>.updateWith(values: List<T>): DataColumn<T>

Replaces all values in the column asserting that new values are compatible with the current column kind.

updateWithValuePerColumnImpl

internal fun <T, C> Update<T, C>.updateWithValuePerColumnImpl(selector: ColumnExpression<C, C>): DataFrame<T>

valueToList

internal fun valueToList(value: Any?, splitStrings: Boolean = true): List<Any?>

withFallback

internal fun <T> ParserFunction<T>.withFallback(fallbackFunction: ParserFunction<T>): ParserFunction<T>

withRowCellImpl

@PublishedApi

internal fun <T, C, R> Convert<T, C>.withRowCellImpl(type: KType, infer: Infer, rowConverter: RowValueExpression<T, C, R>): DataFrame<T>

withValuesImpl

fun <T> Pair<List<String>, List<T>>.withValuesImpl(): List<Pair<String, List<T>>>

Public API to be re-used in compiler plugin implementation

xsImpl

internal fun <T, G, C> GroupBy<T, G>.xsImpl(vararg keyValues: C, keyColumns: ColumnsSelector<T, C>): GroupBy<T, G>

internal fun <T, C> DataFrame<T>.xsImpl(keyColumns: ColumnsSelector<T, C>, allowMissingColumns: Boolean, vararg keyValues: C): DataFrame<T>