api/org.jetbrains.kotlinx.jupyter.util

Package-level declarations

Types

AcceptanceRule

fun interface AcceptanceRule<T>

Acceptance rule either says it accepts an object or delegates it to some other rule returning null

ClassLoadingDelegatingStrategy

fun interface ClassLoadingDelegatingStrategy

An interface for strategies that delegate the class loading process.

CodeExecutionSerializer

object CodeExecutionSerializer : PrimitiveStringPropertySerializer<CodeExecution>

DefaultPromptOptions

object DefaultPromptOptions

Defaults for org.jetbrains.kotlinx.jupyter.api.Notebook.prompt

DelegatingClassLoader

class DelegatingClassLoader(parent: ClassLoader, strategy: ClassLoadingDelegatingStrategy) : ClassLoader

Delegates class loading to another class loader depending on the given strategy receives parent of this class loader as an argument Usually, strategies should delegate to one of the parents or return null meaning that the given class shouldn't be loaded

FlagAcceptanceRule

interface FlagAcceptanceRule<T> : AcceptanceRule<T>

Acceptance rule that has only two answers: yes/no (depending on the acceptsFlag) and "don't know"

KernelRepositorySerializer

object KernelRepositorySerializer : KSerializer<KernelRepository>

KotlinKernelVersionSerializer

object KotlinKernelVersionSerializer : StringValueSerializer<KotlinKernelVersion>

ListToMapSerializer

abstract class ListToMapSerializer<T, K, V>(utilSerializer: KSerializer<Map<K, V>>, mapper: (K, V) -> T, reverseMapper: (T) -> Pair<K, V>) : KSerializer<List<T>>

ModifiableParentsClassLoader

abstract class ModifiableParentsClassLoader : ClassLoader

A ClassLoader that supports dynamic addition of parent classloaders at runtime.

NameAcceptanceRule

class NameAcceptanceRule(val acceptsFlag: Boolean, appliesPredicate: (TypeName) -> Boolean) : FlagAcceptanceRule<TypeName>

Acceptance rule for type names

PatternNameAcceptanceRule

@Serializable(with = PatternNameAcceptanceRuleSerializer::class)

class PatternNameAcceptanceRule(val acceptsFlag: Boolean, val pattern: String) : FlagAcceptanceRule<TypeName> , VariablesSubstitutionAware<PatternNameAcceptanceRule>

Acceptance rule for type names based on pattern. Pattern may consist of any characters and of 3 special combinations:

PatternNameAcceptanceRuleSerializer

object PatternNameAcceptanceRuleSerializer : KSerializer<PatternNameAcceptanceRule>

PrimitiveStringPropertySerializer

abstract class PrimitiveStringPropertySerializer<T : Any>(kClass: KClass<T>, prop: KProperty1<T, String>, ctr: (String) -> T) : KSerializer<T>

RenderersSerializer

object RenderersSerializer : ListToMapSerializer<ExactRendererTypeHandler, String, ResultHandlerCodeExecution>

ResourceBunchSerializer

object ResourceBunchSerializer : KSerializer<ResourceFallbacksBundle>

StringValueSerializer

abstract class StringValueSerializer<T : Any>(kClass: KClass<T>, serializer: (T) -> String = { it.toString() }, deserializer: (String) -> T) : KSerializer<T>

TypeHandlerCodeExecutionSerializer

object TypeHandlerCodeExecutionSerializer : PrimitiveStringPropertySerializer<ResultHandlerCodeExecution>

Properties

EMPTY

val Json.EMPTY: JsonObject

kernelFqnPrefixes

val kernelFqnPrefixes: <Error class: unknown class>

Functions

accepts

fun <T> Iterable<AcceptanceRule<T>>.accepts(obj: T): Boolean?

List of acceptance rules:

compareByProperties

fun <T : Comparable<T>, P : Comparable<P>> T.compareByProperties(other: T, vararg properties: KProperty1<T, P?>): Int

compareNullable

fun <T : Comparable<T>> compareNullable(s1: T?, s2: T?): Int

compareProperty

fun <T : Comparable<T>, P : Comparable<P>> T.compareProperty(other: T, property: KProperty1<T, P?>): Int

createDefaultDelegatingClassLoader

fun createDefaultDelegatingClassLoader(parent: ClassLoader): ClassLoader

escapeForIframe

fun String.escapeForIframe(): String

isSubclassOfCatching

fun KClass<*>.isSubclassOfCatching(superType: KClass<*>): Boolean

replaceVariables

fun replaceVariables(str: String, mapping: Map<String, String>): <Error class: unknown class>

Replace all $ substrings in str with corresponding mapping values

replaceVariables

@JvmName(name = "replaceVariables")

fun <T : VariablesSubstitutionAware<T>> Iterable<T>.replaceVariables(mapping: Map<String, String>): <Error class: unknown class>

@JvmName(name = "replaceVariablesString")

fun Iterable<String>.replaceVariables(mapping: Map<String, String>): <Error class: unknown class>

@JvmName(name = "replaceVariablesExecution")

fun Iterable<CodeExecution>.replaceVariables(mapping: Map<String, String>): <Error class: unknown class>

unionAcceptance

fun unionAcceptance(vararg result: Boolean?): Boolean?

fun unionAcceptance(results: Iterable<Boolean?>): Boolean?