data class QueryDescriptor(val input: Int, val output: Int, val sharedSteps: List<Int> = emptyList(), val isFluxOutput: Boolean = false, val queryId: Long)

QueryDeserializationContext

class QueryDeserializationContext(val graphDescriptor: QueryGraphDescriptor)

QueryEvaluationContext

data class QueryEvaluationContext

QueryGraphDescriptor

@Serializable

data class QueryGraphDescriptor(val queries: List<QueryDescriptor>, val steps: Map<Int, StepDescriptor>, val connections: List<PortConnection>)

QueryGraphDescriptorBuilder

class QueryGraphDescriptorBuilder

QueryId

typealias QueryId = Long

QueryInput

class QueryInput<E> : ProducingStep<E> , IMonoStep<E>

QueryReference

class QueryReference<Q : IUnboundQuery<*, *, *>>(initiallyProvidedQuery: Q?, queryId: Long?, queryInitializer: () -> Q?) : IQueryReference<Q>

RecursiveQuerySerializer

class RecursiveQuerySerializer<Out>(val query: IUnboundQuery<*, *, Out>, val owner: QueryCallStep<*, Out>, val serializationContext: SerializationContext) : KSerializer<IStepOutput<Out>>

RegexPredicate

class RegexPredicate(val regex: Regex) : SimpleMonoTransformingStep<String?, Boolean>

SerializationContext

class SerializationContext(val serializersModule: SerializersModule, val queryInputSerializers: Map<QueryInput<*>, KSerializer<IStepOutput<*>>> = emptyMap())

The output serializer of a query is context dependent when used by multiple QueryCallSteps. This class carries the correct serializer for the input of a query depending on from where it is called.

SetCollectorStep

class SetCollectorStep<E> : CollectorStep<E, Set<E>>

SetCollectorStepOutputSerializer

class SetCollectorStepOutputSerializer<E>(inputElementSerializer: KSerializer<IStepOutput<E>>) : CollectorStepOutputSerializer<E, List<IStepOutput<E>>, Set<E>>

SharedStep

class SharedStep<E> : MonoTransformingStep<E, E>

SimpleMonoTransformingStep

abstract class SimpleMonoTransformingStep<In, Out> : MonoTransformingStep<In, Out>

SimpleQueryExecutor

class SimpleQueryExecutor<E>(val input: E) : IQueryExecutor<E>

SimpleStepOutput

class SimpleStepOutput<out E>(val value: E, val owner: IProducingStep<E>?) : IStepOutput<E>

SimpleStepOutputSerializer

class SimpleStepOutputSerializer<E>(val valueSerializer: KSerializer<E>, val owner: IProducingStep<E>?) : KSerializer<SimpleStepOutput<E>>

SinglePathFlowInstantiationContext

class SinglePathFlowInstantiationContext(val evaluationContext: QueryEvaluationContext, val queryInput: QueryInput<*>, val inputFlow: StepFlow<*>) : IFlowInstantiationContext

SingleStep

class SingleStep<E> : AggregationStep<E, E>

StepDescriptor

@Serializable

abstract class StepDescriptor

StepFlow

typealias StepFlow<E> = Flow<IStepOutput<E>>

StringContainsPredicate

class StringContainsPredicate(val substring: String) : SimpleMonoTransformingStep<String?, Boolean>

StringToBooleanStep

class StringToBooleanStep : SimpleMonoTransformingStep<String?, Boolean>

StringToIntStep

class StringToIntStep : SimpleMonoTransformingStep<String?, Int>

TakeStep

class TakeStep<E>(val count: Int) : TransformingStep<E, E> , IMonoStep<E> , IFluxStep<E>

ToStringStep

class ToStringStep : SimpleMonoTransformingStep<Any?, String?>

TransformingStep

abstract class TransformingStep<In, Out> : ProducingStep<Out> , IProcessingStep<In, Out>

TransformingStepWithParameter

abstract class TransformingStepWithParameter<In : CommonIn, ParameterT : CommonIn, CommonIn, Out> : MonoTransformingStep<CommonIn, Out>

UnboundQuery

abstract class UnboundQuery<In, AggregationOut, ElementOut>(val inputStep: QueryInput<In>, outputStep_: IProducingStep<ElementOut>, val reference: QueryReference<UnboundQuery<In, AggregationOut, ElementOut>>, val sharedSteps: List<SharedStep<*>>) : IUnboundQuery<In, AggregationOut, ElementOut>

VersionAndData

@Serializable

class VersionAndData<E>(val data: E, val version: String?)

WhenStep

class WhenStep<In, Out>(val cases: List<Pair<IMonoUnboundQuery<In, Boolean?>, IMonoUnboundQuery<In, Out>>>, val elseCase: IMonoUnboundQuery<In, Out>?) : MonoTransformingStep<In, Out>

WhenStepBuilder

class WhenStepBuilder<In, Out>(input: IMonoStep<In>)

WithIndexStep

class WithIndexStep<E> : MonoTransformingStep<E, IZip2Output<Any?, E, Int>>

ZipBuilder

class ZipBuilder

ZipElementAccessStep

class ZipElementAccessStep<Out>(val index: Int) : MonoTransformingStep<IZipOutput<Any?>, Out>

ZipNOutput

typealias ZipNOutput = ZipOutput<Any?, Any?, Any?, Any?, Any?, Any?, Any?, Any?, Any?, Any?>

ZipNOutputC

typealias ZipNOutputC<Common> = ZipOutput<Common, Any?, Any?, Any?, Any?, Any?, Any?, Any?, Any?, Any?>

ZipOutput

@Serializable

@SerialName(value = "modelix.modelql.zip.output")

data class ZipOutput<out Common, out E1, out E2, out E3, out E4, out E5, out E6, out E7, out E8, out E9>(val values: List<Common>) : IZip9Output<Common, E1, E2, E3, E4, E5, E6, E7, E8, E9>

ZipOutputSerializer

class ZipOutputSerializer<CommonT, Out : IZipOutput<CommonT>>(val elementSerializers: Array<KSerializer<IStepOutput<CommonT>>>) : KSerializer<ZipStepOutput<Out, CommonT>>

ZipStep

open class ZipStep<CommonIn, Out : ZipNOutputC<CommonIn>> : ProducingStep<Out> , IConsumingStep<CommonIn> , IMonoStep<Out> , IFluxStep<Out>

ZipStepOutput

class ZipStepOutput<E : IZipOutput<Common>, Common>(val values: List<IStepOutput<Common>>) : IStepOutput<E>

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>

MODELIX_VERSION

const val MODELIX_VERSION: String

modelqlVersion

const val ~~modelqlVersion~~: String

ninth

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

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>

value

val <T> Flow<IStepOutput<T>>.value: Flow<T>

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

Functions

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>

asMono

fun Boolean.asMono(): IMonoStep<Boolean>