clikt-core/com.github.ajalt.clikt.parameters.arguments

Package-level declarations

Types

ArgCallsTransformer

typealias ArgCallsTransformer<AllT, EachT> = ArgumentTransformContext.(List<EachT>) -> AllT

A callback that transforms all the values into the final argument type

Argument

interface Argument

A positional parameter to a command.

ArgumentDelegate

interface ArgumentDelegate<out T> : Argument, ReadOnlyProperty<BaseCliktCommand<*>, T> , PropertyDelegateProvider<BaseCliktCommand<*>, ReadOnlyProperty<BaseCliktCommand<*>, T>>

An argument that functions as a property delegate

ArgumentTransformContext

class ArgumentTransformContext(val argument: Argument, val context: Context) : Argument, TransformContext

A receiver for argument transformers.

ArgValidator

typealias ArgValidator<AllT> = ArgumentTransformContext.(AllT) -> Unit

A callback validates the final argument type

ArgValueConverter

typealias ArgValueConverter<InT, ValueT> = ArgumentTransformContext.(InT) -> ValueT

A callback that transforms a single value from one type to another

ArgValueTransformer

typealias ArgValueTransformer<T> = ArgValueConverter<String, T>

A callback that transforms a single value from a string to the value type

ProcessedArgument

interface ProcessedArgument<AllT, ValueT> : ArgumentDelegate<AllT>

An Argument delegate implementation that transforms its values .

ProcessedArgumentImpl

class ProcessedArgumentImpl<AllT, ValueT> : ProcessedArgument<AllT, ValueT>

RawArgument

typealias RawArgument = ProcessedArgument<String, String>

Functions

argument

fun BaseCliktCommand<*>.argument(name: String = "", help: String = "", helpTags: Map<String, String> = emptyMap(), completionCandidates: CompletionCandidates? = null): RawArgument

Create a property delegate argument.

check

inline fun <AllT, ValueT> ProcessedArgument<AllT, ValueT>.check(crossinline lazyMessage: (AllT & Any) -> String = { it.toString() }, crossinline validator: (AllT & Any) -> Boolean): ArgumentDelegate<AllT>

inline fun <AllT, ValueT> ProcessedArgument<AllT, ValueT>.check(message: String, crossinline validator: (AllT & Any) -> Boolean): ArgumentDelegate<AllT>

Check the final argument value and raise an error if it's not valid.

convert

inline fun <InT : Any, ValueT : Any> ProcessedArgument<InT, InT>.convert(completionCandidates: CompletionCandidates? = explicitCompletionCandidates, crossinline conversion: ArgValueConverter<InT, ValueT>): ProcessedArgument<ValueT, ValueT>

Convert the argument's values.

default

@JvmOverloads

fun <T : Any> ProcessedArgument<T, T>.default(value: T, defaultForHelp: String = value.toString()): ArgumentDelegate<T>

If the argument is not given, use value instead of throwing an error.

defaultLazy

inline fun <T : Any> ProcessedArgument<T, T>.defaultLazy(defaultForHelp: String = "", crossinline value: () -> T): ArgumentDelegate<T>

If the argument is not given, call value and use its return value instead of throwing an error.

help

fun <AllT, ValueT> ProcessedArgument<AllT, ValueT>.help(help: HelpTransformContext.() -> String): ProcessedArgument<AllT, ValueT>

Set the help for this argument lazily.

fun <AllT, ValueT> ProcessedArgument<AllT, ValueT>.help(help: String): ProcessedArgument<AllT, ValueT>

Set the help for this argument.

multiple

fun <T : Any> ProcessedArgument<T, T>.multiple(required: Boolean = false, default: List<T> = emptyList()): ProcessedArgument<List<T>, T>

Accept any number of values to this argument.

optional

fun <AllT : Any, ValueT> ProcessedArgument<AllT, ValueT>.optional(): ProcessedArgument<AllT?, ValueT>

Return null instead of throwing an error if no value is given.

pair

fun <T : Any> ProcessedArgument<T, T>.pair(): ProcessedArgument<Pair<T, T>, T>

Require exactly two values to this argument, and store them in a Pair.

transformAll

fun <AllInT, ValueT, AllOutT> ProcessedArgument<AllInT, ValueT>.transformAll(nvalues: Int? = null, required: Boolean? = null, defaultForHelp: String? = null, transform: ArgCallsTransformer<AllOutT, ValueT>): ProcessedArgument<AllOutT, ValueT>

Transform all values to the final argument type.

triple

fun <T : Any> ProcessedArgument<T, T>.triple(): ProcessedArgument<Triple<T, T, T>, T>

Require exactly three values to this argument, and store them in a Triple

unique

fun <T : Any> ProcessedArgument<List<T>, T>.unique(): ProcessedArgument<Set<T>, T>

Only store unique values for this argument

validate

fun <AllT, ValueT> ProcessedArgument<AllT, ValueT>.validate(validator: ArgValidator<AllT & Any>): ArgumentDelegate<AllT>

Check the final argument value and raise an error if it's not valid.