modelql-core/org.modelix.modelql.core/LocalMappingStep

LocalMappingStep

open class LocalMappingStep<In, Out>(val transformation: (In) -> Out) : MonoTransformingStep<In, Out>

Inheritors

ExecuteLocalStep

Constructors

LocalMappingStep

constructor(transformation: (In) -> Out)

Properties

eighth

val <T> IMonoStep<IZip8Output<*, *, *, *, *, *, *, *, T>>.eighth: IMonoStep<T>

fifth

val <T> IMonoStep<IZip5Output<*, *, *, *, *, T>>.fifth: IMonoStep<T>

first

val <T> IMonoStep<IZip1Output<*, T>>.first: IMonoStep<T>

forth

val <T> IMonoStep<IZip4Output<*, *, *, *, T>>.~~forth~~: IMonoStep<T>

fourth

val <T> IMonoStep<IZip4Output<*, *, *, *, T>>.fourth: IMonoStep<T>

index

val IMonoStep<IWithIndex<*>>.index: IMonoStep<Int>

ninth

val <T> IMonoStep<IZip9Output<*, *, *, *, *, *, *, *, *, T>>.ninth: IMonoStep<T>

owner

abstract val owner: QueryReference<*>

second

val <T> IMonoStep<IZip2Output<*, *, T>>.second: IMonoStep<T>

seventh

val <T> IMonoStep<IZip7Output<*, *, *, *, *, *, *, T>>.seventh: IMonoStep<T>

sixth

val <T> IMonoStep<IZip6Output<*, *, *, *, *, *, T>>.sixth: IMonoStep<T>

third

val <T> IMonoStep<IZip3Output<*, *, *, T>>.third: IMonoStep<T>

transformation

val transformation: (In) -> Out

value

val <T> IMonoStep<IWithIndex<T>>.value: IMonoStep<T>

Functions

addConsumer

abstract fun addConsumer(consumer: IConsumingStep<Out>)

addProducer

open override fun addProducer(producer: IProducingStep<In>)

allowEmpty

fun <T> IFluxStep<T>.allowEmpty(): IFluxStep<T>

fun <T> IMonoStep<T>.allowEmpty(): IMonoStep<T>

and

infix fun IMonoStep<Boolean>.and(other: IMonoStep<Boolean>): IMonoStep<Boolean>

asFlux

fun <T> IMonoStep<T>.asFlux(): IFluxStep<T>

assertNotEmpty

fun <T> IFluxStep<T>.assertNotEmpty(): IFluxStep<T>

fun <T> IMonoStep<T>.assertNotEmpty(): IMonoStep<T>

associate

fun <In, K, V> IFluxStep<In>.associate(keySelector: (IMonoStep<In>) -> IMonoStep<K>, valueSelector: (IMonoStep<In>) -> IMonoStep<V>): IMonoStep<Map<K, V>>

associateBy

fun <K, V> IFluxStep<V>.associateBy(keySelector: (IMonoStep<V>) -> IMonoStep<K>): IMonoStep<Map<K, V>>

associateWith

fun <K, V> IFluxStep<K>.associateWith(valueSelector: (IMonoStep<K>) -> IMonoStep<V>): IMonoStep<Map<K, V>>

asString

@JvmName(name = "asStringNullable")

fun IFluxStep<Any?>.asString(): IFluxStep<String?>

fun IFluxStep<Any>.asString(): IFluxStep<String>

@JvmName(name = "asStringNullable")

fun IMonoStep<Any?>.asString(): IMonoStep<String?>

fun IMonoStep<Any>.asString(): IMonoStep<String>

bindFragment

fun <TIn, TContext> IFluxStep<TIn>.bindFragment(body: IRecursiveFragmentBuilder<TIn, TContext>.() -> Unit): IMonoStep<IBoundFragment<TContext>>

fun <TIn, TContext> IFluxStep<TIn>.bindFragment(fragment: IUnboundFragment<TIn, TContext>): IMonoStep<IBoundFragment<TContext>>

fun <TIn, TContext> IMonoStep<TIn>.bindFragment(body: IRecursiveFragmentBuilder<TIn, TContext>.() -> Unit): IMonoStep<IBoundFragment<TContext>>

fun <TIn, TContext> IMonoStep<TIn>.bindFragment(fragment: IUnboundFragment<TIn, TContext>): IMonoStep<IBoundFragment<TContext>>

buildLocalMapping

fun <In, Out> IFluxStep<In>.buildLocalMapping(body: ILocalMappingBuilder<In, Out>.(IMonoStep<In>) -> Unit): IFluxStep<Out>

fun <In, Out> IMonoStep<In>.buildLocalMapping(body: ILocalMappingBuilder<In, Out>.(IMonoStep<In>) -> Unit): IMonoStep<Out>

callFluxQuery

fun <In, Out> IMonoStep<In>.callFluxQuery(query: () -> IFluxUnboundQuery<In, Out>): IFluxStep<Out>

fun <In, Out> IMonoStep<In>.callFluxQuery(ref: QueryReference<IFluxUnboundQuery<In, Out>>): IFluxStep<Out>

callQuery

fun <In, Out> IMonoStep<In>.callQuery(query: () -> IMonoUnboundQuery<In, Out>): IMonoStep<Out>

fun <In, Out> IMonoStep<In>.callQuery(ref: QueryReference<IMonoUnboundQuery<In, Out>>): IMonoStep<Out>

canBeEmpty

open override fun canBeEmpty(): Boolean

canBeMultiple

open override fun canBeMultiple(): Boolean

canEvaluateStatically

open fun canEvaluateStatically(): Boolean

component1

operator fun <T> IMonoStep<IZip1Output<*, T>>.component1(): IMonoStep<T>

component2

operator fun <T> IMonoStep<IZip2Output<*, *, T>>.component2(): IMonoStep<T>

component3

operator fun <T> IMonoStep<IZip3Output<*, *, *, T>>.component3(): IMonoStep<T>

component4

operator fun <T> IMonoStep<IZip4Output<*, *, *, *, T>>.component4(): IMonoStep<T>

component5

operator fun <T> IMonoStep<IZip5Output<*, *, *, *, *, T>>.component5(): IMonoStep<T>

component6

operator fun <T> IMonoStep<IZip6Output<*, *, *, *, *, *, T>>.component6(): IMonoStep<T>

component7

operator fun <T> IMonoStep<IZip7Output<*, *, *, *, *, *, *, T>>.component7(): IMonoStep<T>

component8

operator fun <T> IMonoStep<IZip8Output<*, *, *, *, *, *, *, *, T>>.component8(): IMonoStep<T>

component9

operator fun <T> IMonoStep<IZip9Output<*, *, *, *, *, *, *, *, *, T>>.component9(): IMonoStep<T>

connect

fun <T> IConsumingStep<T>.connect(producer: IProducingStep<T>)

fun <T> IProducingStep<T>.connect(consumer: IConsumingStep<T>)

connectAndDowncast

fun connectAndDowncast(producer: IFluxStep<In>): IFluxStep<Out>

fun connectAndDowncast(producer: IMonoStep<In>): IMonoStep<Out>

contains

fun IMonoStep<String?>.contains(substring: String): IMonoStep<Boolean>

count

fun IFluxStep<*>.count(): IMonoStep<Int>

createDescriptor

open override fun createDescriptor(context: QueryGraphDescriptorBuilder): StepDescriptor

createFlow

open override fun createFlow(context: IFlowInstantiationContext): StepFlow<Out>

drop

fun <T> IFluxStep<T>.drop(count: Int): IFluxStep<T>

emptyStringIfNull

fun IFluxStep<String?>.emptyStringIfNull(): IFluxStep<String>

fun IMonoStep<String?>.emptyStringIfNull(): IMonoStep<String>

equalTo

fun <T> IMonoStep<T>.equalTo(operand: IMonoStep<T>): IMonoStep<Boolean>

fun IMonoStep<Boolean?>.equalTo(operand: Boolean?): IMonoStep<Boolean>

fun IMonoStep<Byte?>.equalTo(operand: Byte?): IMonoStep<Boolean>

fun IMonoStep<Char?>.equalTo(operand: Char?): IMonoStep<Boolean>

fun IMonoStep<Double?>.equalTo(operand: Double?): IMonoStep<Boolean>

fun IMonoStep<Float?>.equalTo(operand: Float?): IMonoStep<Boolean>

fun IMonoStep<Int?>.equalTo(operand: Int?): IMonoStep<Boolean>

fun IMonoStep<Long?>.equalTo(operand: Long?): IMonoStep<Boolean>

fun IMonoStep<Short?>.equalTo(operand: Short?): IMonoStep<Boolean>

fun IMonoStep<String?>.equalTo(operand: String): IMonoStep<Boolean>

evaluateStatically

open fun evaluateStatically(): Out

executeLocal

fun <In, Out> IFluxStep<In>.executeLocal(body: (In) -> Out): IFluxStep<Out>

fun <In, Out> IMonoStep<In>.executeLocal(body: (In) -> Out): IMonoStep<Out>

filter

fun <T> IFluxStep<T>.filter(condition: IQueryBuilderContext<T, Boolean>.(IMonoStep<T>) -> IMonoStep<Boolean>): IFluxStep<T>

fun <T> IMonoStep<T>.filter(condition: IQueryBuilderContext<T, Boolean>.(IMonoStep<T>) -> IMonoStep<Boolean>): IMonoStep<T>

filterNotNull

fun <T : Any> IFluxStep<T?>.filterNotNull(): IFluxStep<T>

fun <T : Any> IMonoStep<T?>.filterNotNull(): IMonoStep<T>

first

fun <Out> IProducingStep<Out>.first(): IMonoStep<Out>

firstOrNull

fun <E> IProducingStep<E>.firstOrNull(): IMonoStep<E?>

flatMap

fun <In, Out> IProducingStep<In>.flatMap(body: (IMonoStep<In>) -> IFluxStep<Out>): IFluxStep<Out>

fun <In, Out> IProducingStep<In>.flatMap(query: IFluxUnboundQuery<In, Out>): IFluxStep<Out>

get

operator fun <K, V> IMonoStep<Map<K, V>>.get(operand: IMonoStep<K>): IMonoStep<V?>

getConsumers

abstract fun getConsumers(): List<IConsumingStep<*>>

getOutputSerializer

open override fun getOutputSerializer(serializationContext: SerializationContext): KSerializer<out IStepOutput<Out>>

getProducer

fun getProducer(): IProducingStep<In>

getProducers

open override fun getProducers(): List<IProducingStep<In>>

getRootInputSteps

open fun getRootInputSteps(): Set<IStep>

hasSideEffect

open fun hasSideEffect(): Boolean

identity

fun <T> IFluxStep<T>.identity(): IFluxStep<T>

fun <T> IMonoStep<T>.identity(): IMonoStep<T>

ifEmpty

@JvmName(name = "ifEmpty_flux_mono")

fun <In : Out, Out> IFluxStep<In>.ifEmpty(alternative: () -> IMonoStep<Out>): IFluxStep<Out>

@JvmName(name = "ifEmpty_mono_mono")

fun <In : Out, Out> IMonoStep<In>.ifEmpty(alternative: () -> IMonoStep<Out>): IMonoStep<Out>

ifEmptyFlux

@JvmName(name = "ifEmpty_flux_flux")

fun <In : Out, Out> IFluxStep<In>.ifEmptyFlux(alternative: () -> IFluxStep<Out>): IFluxStep<Out>

@JvmName(name = "ifEmpty_mono_flux")

fun <In : Out, Out> IMonoStep<In>.ifEmptyFlux(alternative: () -> IFluxStep<Out>): IFluxStep<Out>

inputIsConsumedMultipleTimes

open override fun inputIsConsumedMultipleTimes(): Boolean

inSet

fun <T> IFluxStep<T>.inSet(values: IMonoStep<Set<T>>): IFluxStep<Boolean>

fun IFluxStep<String?>.inSet(values: Set<String>): IFluxStep<Boolean>

fun <T> IMonoStep<T>.inSet(values: IMonoStep<Set<T>>): IMonoStep<Boolean>

fun IMonoStep<String?>.inSet(values: Set<String>): IMonoStep<Boolean>

isEmpty

fun IProducingStep<Any?>.isEmpty(): IMonoStep<Boolean>

isNotEmpty

fun IProducingStep<Any?>.isNotEmpty(): IMonoStep<Boolean>

isNull

fun <T> IMonoStep<T>.isNull(): IMonoStep<Boolean>

isSingle

fun IProducingStep<*>.isSingle(): Boolean

map

fun <In, Out> IFluxStep<In>.map(body: IStepSharingContext.(IMonoStep<In>) -> IMonoStep<Out>): IFluxStep<Out>

fun <In, Out> IFluxStep<In>.map(query: IMonoUnboundQuery<In, Out>): IFluxStep<Out>

fun <In, Out> IMonoStep<In>.map(body: IStepSharingContext.(IMonoStep<In>) -> IMonoStep<Out>): IMonoStep<Out>

fun <In, Out> IMonoStep<In>.map(query: IMonoUnboundQuery<In, Out>): IMonoStep<Out>

mapIfNotNull

fun <In : Any, Out> IFluxStep<In?>.mapIfNotNull(body: IQueryBuilderContext<In, Out>.(IMonoStep<In>) -> IMonoStep<Out>): IFluxStep<Out?>

fun <In : Any, Out> IMonoStep<In?>.mapIfNotNull(body: IQueryBuilderContext<In, Out>.(IMonoStep<In>) -> IMonoStep<Out>): IMonoStep<Out?>

mapLocal

fun <In, Out> IFluxStep<In>.mapLocal(body: (In) -> Out): IFluxStep<Out>

fun <In, Out> IMonoStep<In>.mapLocal(body: (In) -> Out): IMonoStep<Out>

mapLocal2

fun <In, Out> IFluxStep<In>.~~mapLocal2~~(body: ILocalMappingBuilder<In, Out>.(IMonoStep<In>) -> Unit): IFluxStep<Out>

fun <In, Out> IMonoStep<In>.~~mapLocal2~~(body: ILocalMappingBuilder<In, Out>.(IMonoStep<In>) -> Unit): IMonoStep<Out>

matches

fun IMonoStep<String?>.matches(regex: Regex): IMonoStep<Boolean>

needsCoroutineScope

open fun needsCoroutineScope(): Boolean

not

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

notEqualTo

fun <T> IMonoStep<T>.notEqualTo(operand: IMonoStep<T>): IMonoStep<Boolean>

fun IMonoStep<Boolean?>.notEqualTo(operand: Boolean?): IMonoStep<Boolean>

fun IMonoStep<Byte?>.notEqualTo(operand: Byte?): IMonoStep<Boolean>

fun IMonoStep<Char?>.notEqualTo(operand: Char?): IMonoStep<Boolean>

fun IMonoStep<Double?>.notEqualTo(operand: Double?): IMonoStep<Boolean>

fun IMonoStep<Float?>.notEqualTo(operand: Float?): IMonoStep<Boolean>

fun IMonoStep<Int?>.notEqualTo(operand: Int?): IMonoStep<Boolean>

fun IMonoStep<Long?>.notEqualTo(operand: Long?): IMonoStep<Boolean>

fun IMonoStep<Short?>.notEqualTo(operand: Short?): IMonoStep<Boolean>

fun IMonoStep<String?>.notEqualTo(operand: String): IMonoStep<Boolean>

nullIfEmpty

fun <Out> IFluxStep<Out>.nullIfEmpty(): IFluxStep<Out?>

fun <Out> IMonoStep<Out>.nullIfEmpty(): IMonoStep<Out?>

infix fun IMonoStep<Boolean>.or(other: IMonoStep<Boolean>): IMonoStep<Boolean>

orNull

fun <Out> IFluxStep<Out>.orNull(): IFluxStep<Out?>

fun <Out> IMonoStep<Out>.orNull(): IMonoStep<Out?>

outputIsConsumedMultipleTimes

open fun outputIsConsumedMultipleTimes(): Boolean

plus

operator fun IFluxStep<Int>.plus(other: Int): IFluxStep<Int>

operator fun IMonoStep<Int>.plus(other: Int): IMonoStep<Int>

operator fun <Common> IProducingStep<Common>.plus(other: IProducingStep<Common>): IFluxStep<Common>

fun <T> IFluxStep<T>.print(prefix: String = ""): IFluxStep<T>

fun <T> IMonoStep<T>.print(prefix: String = ""): IMonoStep<T>

requiresSingularQueryInput

abstract fun requiresSingularQueryInput(): Boolean

requiresWriteAccess

open fun requiresWriteAccess(): Boolean

single

fun <E> IFluxStep<E>.single(): IMonoStep<E>

size

fun IMonoStep<Collection<*>>.size(): IMonoStep<Int>

take

fun <T> IFluxStep<T>.take(count: Int): IFluxStep<T>

toBoolean

fun IFluxStep<String?>.toBoolean(): IFluxStep<Boolean>

fun IMonoStep<String?>.toBoolean(): IMonoStep<Boolean>

toInt

fun IFluxStep<String?>.toInt(): IFluxStep<Int>

fun IMonoStep<String?>.toInt(): IMonoStep<Int>

toList

fun <T> IFluxStep<T>.toList(): IMonoStep<List<T>>

toMap

fun <K, V> IFluxStep<IZip2Output<*, K, V>>.toMap(): IMonoStep<Map<K, V>>

toSet

fun <T> IFluxStep<T>.toSet(): IMonoStep<Set<T>>

toSingletonList

fun <T> IMonoStep<T>.toSingletonList(): IMonoStep<List<T>>

Sometimes you need an additional wrapper list, but to avoid this being done accidentally it has a different name.

toSingletonSet

fun <T> IMonoStep<T>.toSingletonSet(): IMonoStep<Set<T>>

toString

open override fun toString(): String

validate

open override fun validate()

when

fun <In, Out> IMonoStep<In>.when(): WhenStepBuilder<In, Out>

withIndex

fun <T> IFluxStep<T>.withIndex(): IFluxStep<IWithIndex<T>>

zip

fun <Common, T1 : Common, T2 : Common> IMonoStep<T1>.zip(other2: IMonoStep<T2>): IMonoStep<IZip2Output<Common, T1, T2>>

fun <T> IMonoStep<T>.zip(vararg others: IMonoStep<T>): IMonoStep<IZipOutput<T>>

fun <Common, T1 : Common, T2 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>): IFluxStep<IZip2Output<Common, T1, T2>>

fun <T> IProducingStep<T>.zip(vararg others: IProducingStep<T>): IFluxStep<IZipOutput<T>>

fun <Common, T1 : Common, T2 : Common, T3 : Common> IMonoStep<T1>.zip(other2: IMonoStep<T2>, other3: IMonoStep<T3>): IMonoStep<IZip3Output<Common, T1, T2, T3>>

fun <Common, T1 : Common, T2 : Common, T3 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>, other3: IProducingStep<T3>): IFluxStep<IZip3Output<Common, T1, T2, T3>>

fun <Common, T1 : Common, T2 : Common, T3 : Common, T4 : Common> IMonoStep<T1>.zip(other2: IMonoStep<T2>, other3: IMonoStep<T3>, other4: IMonoStep<T4>): IMonoStep<IZip4Output<Common, T1, T2, T3, T4>>

fun <Common, T1 : Common, T2 : Common, T3 : Common, T4 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>, other3: IProducingStep<T3>, other4: IProducingStep<T4>): IFluxStep<IZip4Output<Common, T1, T2, T3, T4>>

fun <Common, T1 : Common, T2 : Common, T3 : Common, T4 : Common, T5 : Common> IMonoStep<T1>.zip(other2: IMonoStep<T2>, other3: IMonoStep<T3>, other4: IMonoStep<T4>, other5: IMonoStep<T5>): IMonoStep<IZip5Output<Common, T1, T2, T3, T4, T5>>

fun <Common, T1 : Common, T2 : Common, T3 : Common, T4 : Common, T5 : Common> IProducingStep<T1>.zip(other2: IProducingStep<T2>, other3: IProducingStep<T3>, other4: IProducingStep<T4>, other5: IProducingStep<T5>): IFluxStep<IZip5Output<Common, T1, T2, T3, T4, T5>>

zipN

fun <T> IMonoStep<T>.zipN(vararg others: IMonoStep<T>): IMonoStep<IZipOutput<T>>

fun <T> IProducingStep<T>.zipN(vararg others: IProducingStep<T>): IFluxStep<IZipOutput<T>>