kraftlin-command-core/io.github.kraftlin.command/ArgumentNode

ArgumentNode

class ArgumentNode<S, T> : LiteralNode<S>

Scope for building a required argument node. Extends LiteralNode with suggests.

Properties

argBuilder

val argBuilder: RequiredArgumentBuilder<S, T>

builder

val builder: ArgumentBuilder<S, *>

Functions

argument

fun <S, T> LiteralNode<S>.argument(name: String, type: ArgumentType<T>, block: ArgumentNode<S, T>.() -> Unit)

Adds a required argument of the given Brigadier type. Prefer the typed helpers (e.g. string, integer).

boolean

fun <S> LiteralNode<S>.boolean(name: String, block: ArgumentNode<S, Boolean>.() -> Unit)

Adds a boolean argument.

double

fun <S> LiteralNode<S>.double(name: String, block: ArgumentNode<S, Double>.() -> Unit)

Adds a double argument.

fun <S> LiteralNode<S>.double(name: String, min: Double, block: ArgumentNode<S, Double>.() -> Unit)

Adds a double argument with minimum min.

fun <S> LiteralNode<S>.double(name: String, min: Double, max: Double, block: ArgumentNode<S, Double>.() -> Unit)

Adds a double argument bounded to min..max.

executes

fun <S> LiteralNode<S>.executes(block: ExecuteScope<S>.(KContext<S>) -> Unit)

Registers the execution handler for this node. Returns Command.SINGLE_SUCCESS automatically.

fun <S, Sender> LiteralNode<S>.executes(platform: PlatformAdapter<S, Sender>, block: ExecuteScope<S>.(Sender, KContext<S>) -> Unit)

Execution handler that extracts the platform Sender before invoking block.

executesResult

fun <S> LiteralNode<S>.executesResult(block: ExecuteScope<S>.(KContext<S>) -> Int)

Registers an execution handler that returns a custom Brigadier result code.

fun <S, Sender> LiteralNode<S>.executesResult(platform: PlatformAdapter<S, Sender>, block: ExecuteScope<S>.(Sender, KContext<S>) -> Int)

Execution handler with custom result code that extracts the platform Sender before invoking block.

float

fun <S> LiteralNode<S>.float(name: String, block: ArgumentNode<S, Float>.() -> Unit)

Adds a float argument.

fun <S> LiteralNode<S>.float(name: String, min: Float, block: ArgumentNode<S, Float>.() -> Unit)

Adds a float argument with minimum min.

fun <S> LiteralNode<S>.float(name: String, min: Float, max: Float, block: ArgumentNode<S, Float>.() -> Unit)

Adds a float argument bounded to min..max.

greedyString

fun <S> LiteralNode<S>.greedyString(name: String, block: ArgumentNode<S, String>.() -> Unit)

Adds a greedy string argument that consumes all remaining input. @see KContext.greedyString

integer

fun <S> LiteralNode<S>.integer(name: String, block: ArgumentNode<S, Int>.() -> Unit)

Adds an integer argument.

fun <S> LiteralNode<S>.integer(name: String, min: Int, block: ArgumentNode<S, Int>.() -> Unit)

Adds an integer argument with minimum min.

fun <S> LiteralNode<S>.integer(name: String, min: Int, max: Int, block: ArgumentNode<S, Int>.() -> Unit)

Adds an integer argument bounded to min..max.

literal

fun <S> LiteralNode<S>.literal(name: String, vararg aliases: String, block: LiteralNode<S>.() -> Unit)

Adds a literal sub-command named name with optional aliases that redirect to it.

long

fun <S> LiteralNode<S>.long(name: String, block: ArgumentNode<S, Long>.() -> Unit)

Adds a long argument.

fun <S> LiteralNode<S>.long(name: String, min: Long, block: ArgumentNode<S, Long>.() -> Unit)

Adds a long argument with minimum min.

fun <S> LiteralNode<S>.long(name: String, min: Long, max: Long, block: ArgumentNode<S, Long>.() -> Unit)

Adds a long argument bounded to min..max.

requires

fun <S> LiteralNode<S>.requires(predicate: (S) -> Boolean)

Adds a requirement that must be true for this node to be visible and executable. Stacks with previous requirements.

requiresPermission

fun <S, Sender> LiteralNode<S>.requiresPermission(platform: PlatformAdapter<S, Sender>, permission: String)

Requires the source to have the given permission, checked via platform.

requiresSender

fun <S, Sender> LiteralNode<S>.requiresSender(platform: PlatformAdapter<S, Sender>, predicate: (Sender) -> Boolean)

Requires the platform sender to match a predicate (e.g. to check sender type).

string

fun <S> LiteralNode<S>.string(name: String, block: ArgumentNode<S, String>.() -> Unit)

Adds a quoted or single-word string argument.

suggests

fun <S, T> ArgumentNode<S, T>.suggests(provider: (KContext<S>, SuggestionsBuilder) -> CompletableFuture<Suggestions>)

Registers a dynamic suggestion provider for this argument.

suggestsStatic

fun <S, T> ArgumentNode<S, T>.suggestsStatic(vararg values: String)

fun <S, T> ArgumentNode<S, T>.suggestsStatic(values: Iterable<String>)

Registers a fixed set of suggestion values for this argument.

word

fun <S> LiteralNode<S>.word(name: String, block: ArgumentNode<S, String>.() -> Unit)

Adds a single-word string argument. @see KContext.word