coko-core/de.fraunhofer.aisec.codyze.specificationLanguages.coko.core.dsl

Package-level declarations

Types

class Arguments(val op: Op)

A helper class that makes it possible to construct an ArgumentItem with an indexed access (e.g. op.argument1)

class Condition

This class exists to restrict where the functions can be called

data class ConditionalOp(val resultOp: Op, val conditionOp: Op, val ownerClassFqn: String = "") : Op

An Op that describes that the function calls found with resultOp depend on the function calls found with the conditionOp

class ConstructorOp : Op

Represents the constructor of a class.

class FunctionOp : Op

Represents a group of functions that serve the same purpose in the API.

data class GroupingOp(val ops: Set<Op>, val ownerClassFqn: String = "") : Op

An Op that contains other Ops

@Target(allowedTargets = [AnnotationTarget.FILE])

annotation class Import(val paths: String)

Import other coko script(s)

sealed interface Op : OrderFragment

class Order : OrderBuilder

OrderBuilder subclass to hide some implementation details of OrderBuilder to coko users.

data class ParamWithType(val param: Any, val type: Type)

enum Precision : Enum<Precision>

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

annotation class Rule(val description: String = "", val shortDescription: String = "", val severity: Severity = Severity.WARNING, val passMessage: String = "", val failMessage: String = "", val help: String = "", val tags: Array<String> = [], val precision: Precision = Precision.UNKNOWN)

Marks a function that should be evaluated as a rule by Codyze

enum Severity : Enum<Severity>

TransformationResult

sealed interface TransformationResult<E, T>

This class works similar to the Result class in the Kotlin standard library. The difference is that the TransformationFailure can store information other than Throwables to be able to describe the reasons for failure in more detail.

data class Type(val fqn: String)

Stores the fully qualified name of a class

object Wildcard

Matches any value.

typealias wildcard = Wildcard

Properties

val set: OrderSetGetOperator

Use this to create a set with the OrderSetGetOperator.get operator.

Functions

fun atLeast(min: Int, vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with the atLeast qualifier. See group.

inline fun atLeast(count: Int, block: OrderGroup.() -> Unit): OrderNode

Adds a group with the atLeast qualifier. See group

fun between(range: IntRange, vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with the between qualifier. See group.

inline fun between(range: IntRange, block: OrderGroup.() -> Unit): OrderNode

Adds a group with the between qualifier. See group

fun condition(block: Condition.() -> ConditionComponent): ConditionComponent

fun constructor(classFqn: String, block: ConstructorOp.() -> Unit): ConstructorOp

Create a ConstructorOp.

fun count(count: Int, vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with the count qualifier. See group.

inline fun count(count: Int, block: OrderGroup.() -> Unit): OrderNode

Adds a group with the count qualifier. See group

inline fun FunctionOp.definition(fqn: String, block: Definition.() -> Unit): Definition

Create a Definition which can be added to the FunctionOp.

inline fun group(block: OrderGroup.() -> Unit): <Error class: unknown class>

Add a group containing any valid OrderDsl provided as a lambda

fun Signature.group(vararg parameters: Parameter): ParameterGroup

inline fun Signature.group(block: ParameterGroup.() -> Unit): ParameterGroup

Create a ParameterGroup which can be added to the Signature.

fun OrderBuilder.group(vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with a function call. However, this minimalist group constructor only works with OrderTokens

fun maybe(vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with the maybe ('*') qualifier. See group.

inline fun maybe(block: OrderGroup.() -> Unit): OrderNode

Adds a group with the maybe ('*') qualifier. See group

fun op(block: FunctionOp.() -> Unit): FunctionOp

Create a FunctionOp.

fun opGroup(vararg ops: Op): GroupingOp

Create a GroupingOp containing the given ops.

fun option(vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with the option ('?') qualifier. See group.

inline fun option(block: OrderGroup.() -> Unit): OrderNode

Adds a group with the option ('?') qualifier. See group

infix fun OrderFragment.or(other: OrderFragment): OrderFragment

infix fun OrderFragment.or(other: OrderToken): OrderFragment

Adds an alternation token (|) between the current OrderFragment and other. All OrderToken are converted into OrderFragments.

infix fun OrderToken.or(other: OrderFragment): OrderFragment

infix fun OrderToken.or(other: OrderToken): OrderFragment

Adds an alternation token (|) between the current OrderToken and other. All OrderToken are converted into OrderFragments.

inline fun set(block: OrderSet.() -> Unit): OrderSet

Add a set to the Order containing any valid OrderDsl provided by a lambda (see group).

fun ConstructorOp.signature(vararg parameters: Parameter): Signature

Create a Signature which can be added to the ConstructorOp. The Parameters are passed through the vararg.

inline fun ConstructorOp.signature(block: Signature.() -> Unit): Signature

Create a Signature which can be added to the ConstructorOp. The Parameters are defined in the block.

fun Definition.signature(vararg parameters: Parameter): Signature

Create a Signature which can be added to the Definition. The Parameters are passed through the vararg.

inline fun Definition.signature(unordered: Array<out Parameter> = emptyArray(), block: Signature.() -> Unit): Signature

Create a Signature which can be added to the Definition. The Parameters are defined in the block.

fun some(vararg tokens: OrderToken): OrderNode

Minimalist way to create a group with the some ('+') qualifier. See group.

inline fun some(block: OrderGroup.() -> Unit): OrderNode

Adds a group with the some ('+') qualifier. See group

fun unordered(vararg unordered: Parameter): <Error class: unknown class>

Add unordered Parameters to the Signature.

infix fun Op.with(conditionOp: Op): ConditionalOp

Create a ConditionalOp with this as the ConditionalOp.resultOp and conditionOp as the ConditionalOp.conditionOp

infix fun Any.withType(fqn: String): ParamWithType