clikt/com.github.ajalt.clikt.parameters.arguments/ProcessedArgument

ProcessedArgument

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

An Argument delegate implementation that transforms its values .

Inheritors

ProcessedArgumentImpl

Properties

completionCandidates

open val completionCandidates: CompletionCandidates

Optional set of strings to use when the user invokes shell autocomplete on a value for this argument.

explicitCompletionCandidates

abstract val explicitCompletionCandidates: CompletionCandidates?

The completion candidates set on this argument, or null if no candidates have been set

helpGetter

abstract val helpGetter: HelpTransformContext.() -> String?

A block that will return the help text for this argument, or null if no getter has been specified

helpTags

abstract val helpTags: Map<String, String>

Extra information about this argument to pass to the help formatter.

name

abstract val name: String

The metavar for this argument.

nvalues

abstract val nvalues: Int

The number of values that this argument takes.

required

abstract val required: Boolean

If true, an error will be thrown if this argument is not given on the command line.

transformAll

abstract val transformAll: ArgCallsTransformer<AllT, ValueT>

Called in finalize to transform the list of values to the final type.

transformValidator

abstract val transformValidator: ArgValidator<AllT>

Called after all parameters have been finalized to validate the result of transformAll

transformValue

abstract val transformValue: ArgValueTransformer<ValueT>

Called in finalize to transform each value provided to the argument.

value

abstract val value: AllT

The value for this argument.

Functions

boolean

fun RawArgument.boolean(): ProcessedArgument<Boolean, Boolean>

Convert the argument values to Boolean.

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.

choice

fun <T : Any> RawArgument.choice(vararg choices: Pair<String, T>, ignoreCase: Boolean = false): ProcessedArgument<T, T>

fun <T : Any> RawArgument.choice(choices: Map<String, T>, ignoreCase: Boolean = false): ProcessedArgument<T, T>

Convert the argument based on a fixed set of values.

fun RawArgument.choice(vararg choices: String, ignoreCase: Boolean = false): ProcessedArgument<String, String>

Restrict the argument to a fixed set of values.

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.

copy

abstract fun copy(validator: ArgValidator<AllT> = this.transformValidator, name: String = this.name, nvalues: Int = this.nvalues, required: Boolean = this.required, helpGetter: HelpTransformContext.() -> String? = this.helpGetter, helpTags: Map<String, String> = this.helpTags, completionCandidates: CompletionCandidates? = explicitCompletionCandidates): ProcessedArgument<AllT, ValueT>

Create a new argument that is a copy of this one with the same transforms.

abstract fun <AllT, ValueT> copy(transformValue: ArgValueTransformer<ValueT>, transformAll: ArgCallsTransformer<AllT, ValueT>, validator: ArgValidator<AllT>, name: String = this.name, nvalues: Int = this.nvalues, required: Boolean = this.required, helpGetter: HelpTransformContext.() -> String? = this.helpGetter, helpTags: Map<String, String> = this.helpTags, completionCandidates: CompletionCandidates? = explicitCompletionCandidates): ProcessedArgument<AllT, ValueT>

Create a new argument that is a copy of this one with different transforms.

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.

defaultStdin

fun ProcessedArgument<InputStream, InputStream>.defaultStdin(): ArgumentDelegate<InputStream>

Use - as the default value for an inputStream argument.

defaultStdout

fun ProcessedArgument<OutputStream, OutputStream>.defaultStdout(): ArgumentDelegate<OutputStream>

Use - as the default value for an outputStream argument.

double

fun RawArgument.double(): ProcessedArgument<Double, Double>

Convert the argument values to a Double

enum

inline fun <T : Enum<T>> RawArgument.enum(ignoreCase: Boolean = true, key: (T) -> String = { it.name }): ProcessedArgument<T, T>

Convert the argument to the values of an enum.

file

fun RawArgument.file(mustExist: Boolean = false, canBeFile: Boolean = true, canBeDir: Boolean = true, mustBeWritable: Boolean = false, mustBeReadable: Boolean = false, canBeSymlink: Boolean = true): ProcessedArgument<File, File>

Convert the argument to a File.

finalize

abstract fun finalize(context: Context, values: List<String>)

Called after this command's argv is parsed to transform and store the argument's value.

float

fun RawArgument.float(): ProcessedArgument<Float, Float>

Convert the argument values to a Float

getArgumentHelp

abstract fun getArgumentHelp(context: Context): String

The description of this argument.

getValue

open operator override fun getValue(thisRef: CliktCommand, property: KProperty<*>): AllT

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.

inputStream

fun RawArgument.inputStream(fileSystem: FileSystem = FileSystems.getDefault()): ProcessedArgument<InputStream, InputStream>

Convert the argument to an InputStream.

int

fun RawArgument.int(): ProcessedArgument<Int, Int>

Convert the argument values to an Int

long

fun RawArgument.long(): ProcessedArgument<Long, Long>

Convert the argument values to a Long

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.

outputStream

fun RawArgument.outputStream(createIfNotExist: Boolean = true, truncateExisting: Boolean = false, fileSystem: FileSystem = FileSystems.getDefault()): ProcessedArgument<OutputStream, OutputStream>

Convert the argument to an OutputStream.

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.

parameterHelp

abstract fun parameterHelp(context: Context): HelpFormatter.ParameterHelp.Argument?

Information about this argument for the help output.

path

fun RawArgument.path(mustExist: Boolean = false, canBeFile: Boolean = true, canBeDir: Boolean = true, mustBeWritable: Boolean = false, mustBeReadable: Boolean = false, canBeSymlink: Boolean = true, fileSystem: FileSystem = FileSystems.getDefault()): ProcessedArgument<Path, Path>

Convert the argument to a Path.

postValidate