All Classes and Interfaces
Class
Description
CommandPostprocessor that does nothing besides indicating that the context
has been properly processedCommandPreprocessor that does nothing besides indicating that the context
has been properly processedAn argument parser that delegates to multiple inner
AggregateParser.components() and transforms the aggregate results into
an output using the AggregateParser.mapper().Context that stores the individual result of invoking the child parsers of a
AggregateParser.Mapper that maps the result of invoking the inner parsers of a
AggregateParser.Exception thrown when a
CommandContext
is being inserted into a CommandTree and an ambiguity
is detected.Accepts if every single permission is accepted.
Managed access for
Annotation instancesAnnotation accessor that cannot access any annotations
Parser that parses strings into values of a specific type
Utility interface extending
ArgumentParser to make it easier to implement
ArgumentParser.FutureArgumentParser.parseFuture(CommandContext, CommandInput).Result of the parsing done by a
ArgumentParserSpecialized variant of
SuggestionProvider that does work on the calling thread.Specialized variant of
BlockingSuggestionProvider that has String results
instead of Suggestion results.Boolean parse exception
This is a reference to a caption and does not contain any message itself.
Registry that allows for messages to be configurable per-sender.
Key-value pair used to replace variables in captions.
Char parse exception
Represents a capability that a cloud implementation may have.
Exception thrown when a
CloudCapability is missing, when a method that requires the presence of that
capability is invoked.Standard
capabilities.A typed, named key.
Represents any object that holds a
CloudKeyA command is a chain of
command components with an associated Command.commandExecutionHandler().Builder for
Command instances.Essentially a
UnaryOperator for Command.Builder,
but as a separate interface to avoid conflicts.An alternative way of registering commands, where each command lives in a separate class.
A single literal or argument component of a command
Command context used to assist in the parsing of commands
Factory for
CommandContext instancesException thrown when there is an exception during execution of a command handler
Handler that is invoked whenever a
Command is executed
by a command senderHandler that is invoked whenever a
Command is executed
by a command senderFactory producing command instances
A flag is an optional command component that may have an associated parser,
and is identified by its name.
Reasons for which flag parsing may fail
Flag parse exception
Tokenizer that splits command inputs into tokens.
The manager is responsible for command registration, parsing delegation, etc.
Object that is associated with a
Command.Very simple tree structure
Exception thrown when parsing user input into a command
Context for
command postprocessors.Command postprocessor that acts on commands before execution
Context for
command preprocessors.Command preprocessor that gets to act on command input
before it's sent to the command parser.
Defines properties used by
command beans to construct commands.Utility that registers commands natively for whatever
platform the library is used in.
The result of a command execution.
Utility that formats chains of
command components into syntax stringsTree containing all commands and command paths.
CompletableFuture extensions.Command completions, separated by "," or ", "
Something with configurable
settings.Default value used when an optional argument is omitted by the command sender.
Caption provider that delegates to another provider.
Command suggestion engine that delegates to a
CommandTreeSomething that has an associated
Description.A description for a command or a command component.
Parser for
Duration.Failure exception for
DurationParser.Dynamic sized tuple backed by a
Object[]A parser which attempts to use the
EitherParser.primary() parser and falls back on the EitherParser.fallback() parser if that fails.Exception thrown when both the primary and fallback parsers fail to parse the input.
The controller handles registrations of exception handlers, as well as the routing of incoming exceptions to the handlers.
Handles an exception thrown during command parsing & execution.
Used to register a
ExceptionHandler in the ExceptionController.The
execution coordinator is responsible for coordinating execution of command parsing,
handlers, suggestions, etc.Builder for
ExecutionCoordinator.Command suggestion processor filters suggestions based on the remaining unconsumed input in the
queue.
Filter function that tests (and potentially changes) each suggestion against the input and context.
Simple version of
FilteringSuggestionProcessor.Filter which doesn't modify suggestions.Flag value mappings
Indicates that the argument should stop parsing when encountering what
could potentially be a flag.
Annotation used to make
string parsers greedyInjection service that injects using a Guice InjectorThe result of a help query.
Annotation that generates immutables classes with builders.
Immutable implementation of
ConstantCaptionProvider.Builds instances of type
ImmutableConstantCaptionProvider.Annotation that generates immutable classes suffixed with "Impl".
A list of commands.
Exception thrown when an
InjectionService fails exceptionally.Service that can be registered to the
ParameterInjectorRegistry in order to provide
custom injection support.Exception thrown when an invalid command sender tries to execute a command
Exception sent when a command sender inputs invalid command syntax
Annotation used to set the parsing mode of a
boolean
parser to liberal.Configurable command related settings
An argument parser which wraps another argument parser, converting the output type.
A list of commands.
Thrown when a
CommandComponent
that is registered as a leaf node, does not contain an owning CommandException thrown when a command sender misses a permission required
to execute a
CommandException thrown when a command sender tries to execute
a command that doesn't exist
Accepts as long as at least one of the permissions is accepted
Immutable generic 2-tuple
Injector that injects parameters into Command annotated
methods
Contributes to the
ParserRegistry.Parser parameter used when retrieving parsers from the
ParserRegistryRegistry that allows
parsers to be referenced by the type of the values they produce, or by their names.A command permission representation.
The cached result of a permission check, representing whether a command may be executed.
A functional
Permission implementationImmutable generic 5-tuple
Immutable generic 5-tuple
Annotation used to set the parsing mode of a
string
parser to quoted.Used to specify min and max values of numerical
parsersAn inclusive range of numbers.
Command preprocessor that filters based on regular expressions
Exception thrown when input fails regex matching in
RegexPreprocessorThe point in the registration lifecycle for this commands manager
Mapper than can transform command senders from a base type to another type and back.
A holder of a
SenderMapper.Something that represents a setting that can be configured.
Immutable generic 6-tuple
A simple immutable string-string map containing command meta
Annotation that generates immutables classes with staged builders.
Caption instances for messages in cloud-coreProvides default captions for all
StandardCaptionKeys.CommandSyntaxFormatter implementation that uses the following rules:
static arguments are serialized as their name, without a bracket
required arguments are serialized as their name, surrounded by angle brackets
optional arguments are serialized as their name, surrounded by square brackets
does not render arguments the sender does not have access to (either due to permission or sender type requirements)
Instance that is used when building command syntax
Common parser parameters used when resolving types in the
ParserRegistryStandard implementation of
ParserRegistrySomething that represents a state in a state machine.
A simple state machine.
Parser that parses input into a string array
String utilities
Factory that produces command suggestions from user input.
Maps from
Suggestion to SuggestionMapper.Processor that operates on the
stream of suggestions before it is collected
for the suggestion result passed to platform implementations or other callers.Provider of suggestions
Immutable generic 3-tuple
Tuple type
Verbose information about a single command.