All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AbbreviatedCommandFinder |
|
| AbbreviatedGroupFinder |
|
| AbbreviatedNumericTypeConverter |
|
| AbbreviatedOptionFinder |
|
| AbbreviationCli |
An example of creating a CLI with abbreviation enabled
|
| AbstractAbbreviationFinder<T> |
|
| AbstractAllowedValuesRestriction |
|
| AbstractBuilder<T> |
Abstract base class for builders
|
| AbstractChildBuilder<T,TParent,TBuilder extends AbstractBuilder<TParent>> |
A builder that is a child of another builder
|
| AbstractCollectingHandler |
|
| AbstractCommandGroupUsageGenerator<T> |
Abstract command group usage generator
|
| AbstractCommandParser<T> |
Abstract implementation of a parser for commands that can cope with both CLI
and Single Command parsing
|
| AbstractCommandUsageGenerator |
Abstract command usage generator
|
| AbstractCommonRestriction |
|
| AbstractComparableComparator<T extends java.lang.Comparable<T>> |
|
| AbstractGlobalUsageGenerator<T> |
Abstract global usage generator
|
| AbstractLocaleAndCaseStringRestriction |
An abstract string restriction that needs a locale and case sensitivity flag
|
| AbstractLocaleSensitiveStringFinder |
|
| AbstractNameValueOptionParser<T> |
Abstract option parser for options that are specified in --name=value style while the separator character (in
this example =) can be configured as desired.
|
| AbstractObjectComparator<T> |
|
| AbstractOptionParser<T> |
Abstract option parser that provides some useful helper methods to derived classes
|
| AbstractOptionRestrictionBasedFinder |
|
| AbstractParsedOptionRestrictionBasedFinder |
|
| AbstractParser<T> |
Abstract base class for parsers providing some utility methods
|
| AbstractPlaceholderLocator |
|
| AbstractPrintedCommandGroupUsageGenerator<T> |
Abstract command group usage generator for generators that use a
UsagePrinter to generate the documentation |
| AbstractPrintedCommandUsageGenerator |
Abstract command usage generator for generators that use a
UsagePrinter to generate the documentation |
| AbstractPrintedGlobalUsageGenerator<T> |
Abstract global usage generator for generators that use a
UsagePrinter to generate the documentation |
| AbstractRequiredUnlessRestriction |
A restriction that options/arguments are required unless some other criteria is met
|
| AbstractStringRestriction |
Abstract restrictions on string values for options and arguments
|
| AbstractUsageGenerator |
|
| Accessor |
|
| AirlineModule |
Used to mark a field of a command class as representing a module of command functionality.
|
| AirlineUtils |
|
| Alias |
Specifies a command alias
|
| AliasArgumentsParser |
|
| AliasBuilder<C> |
Builds a command alias
|
| AliasedCli |
An example of creating a CLI that takes advantage of the aliases feature.
|
| AliasFinder |
|
| AliasMetadata |
Metadata about command aliases
|
| AliasResolver<T> |
Resolves aliases
|
| AllowedEnumValues |
Annotation that marks that the option/arguments are restricted to a given set
of raw string values as defined by a given enum type
|
| AllowedEnumValuesRestriction |
|
| AllowedRawValues |
Annotation that marks that the option/arguments are restricted to a given set
of raw string values
|
| AllowedRawValuesRestriction |
|
| AllowedValues |
Annotation that marks that the option/arguments are restricted to a given set
of values
|
| AllowedValuesOptionFinder |
|
| AllowedValuesRestriction |
|
| AllowedValuesRestrictionFactory |
|
| Ansi256ColorizedOutputStream |
A colorized output stream supporting the ANSI 256 colour palette
|
| Ansi256ColorizedWriter |
A colorized writer supporting the ANSI 256 colour palette
|
| AnsiBackgroundColorSource<T extends AnsiColorProvider> |
An ANSI colour source for background colours
|
| AnsiBasicColorizedOutputStream |
A colorized output stream supporting the basic ANSI colours
|
| AnsiBasicColorizedWriter |
A colorized writer supporting the basic ANSI colors
|
| AnsiColorProvider |
Interface that may be implemented by colour providers
|
| AnsiColorSource<T extends AnsiColorProvider> |
|
| AnsiControlCodes |
Constants
|
| AnsiDecorationProvider |
Interface for classes that provide ANSI decorations
|
| AnsiDecorationSource<T extends AnsiDecorationProvider> |
|
| AnsiForegroundColorSource<T extends AnsiColorProvider> |
An ANSI colour source for background colours
|
| AnsiOutputStream |
An output stream that supports customized output via ANSI control codes
|
| AnsiTrueColorizedOutputStream |
A colorized output stream supporting ANSI true colour (24 bit i.e.
|
| AnsiTrueColorizedWriter |
A colorized writer supporting ANSI true colour (24 bit i.e.
|
| AnsiWriter |
A writer that supports customizing the output with ANSI control codes
|
| Arguments |
|
| ArgumentsMetadata |
|
| ArgumentsRestriction |
Represents restrictions on arguments
|
| ArgumentsRestrictionFactory |
Interface for arguments restriction factories
|
| BadGrandchild |
When inheriting from existing classes the default behaviour is to prevent
overriding of options as Airline assumes the conflicting definitions are an
error on the part of the developer.
|
| BaseCommand |
|
| BashCompletion |
Annotates a field with Bash completion information
|
| BashCompletion |
|
| BashCompletionGenerator<T> |
|
| BasicCli |
|
| BasicColor |
The 8 basic ANSI Colours
|
| BasicDecoration |
Support for the basic ANSI decorations
|
| BasicHint |
|
| BasicSection |
|
| Binary |
A type converter that supports binary numbers
|
| ByteCalculator |
|
| ByteComparator |
|
| ByteRange |
Annotation that marks values as being restricted to a given byte range
|
| ChannelFactory |
Factory for various channels used by airline.
|
| Channels |
Channels provides methods for the cli output, error and input channels.
|
| CheckAddress |
|
| CheckPostcodes |
|
| Child |
|
| ClassicGetOptParser<T> |
An options parsing that parses options given in classic get-opt style where multiple options may be concatenated
together, potentially including a value for the last option in the concatenation.
|
| ClasspathLocator |
A resource locator that finds resources on the classpath
|
| Cli |
Class annotation used to declaratively specify a CLI
|
| Cli<C> |
Class for encapsulating and parsing CLIs
|
| Cli.NO_DEFAULT |
|
| CliBuilder<C> |
Builder for CLIs
|
| CliCommandGroupUsageGenerator<T> |
|
| CliCommandUsageGenerator |
|
| CliGlobalUsageGenerator<T> |
|
| CliGlobalUsageSummaryGenerator<T> |
|
| CliParser<T> |
|
| CliUsageHelper |
|
| CollectAll |
Error handler which collects all the errors for later inspection
|
| ColonSeparatedOptionParser<T> |
An option parser where the name and value are colon separated i.e.
|
| Color256 |
256 colour i.e.
|
| ColorDemo<T> |
|
| ColorizedOutputStream<T> |
An output stream that supports colorization and some basic text decorations
|
| ColorizedWriter<T> |
An writer stream that supports colorization and basic text decorations
|
| Colors256 |
|
| ColorsBasic |
|
| ColorsTrue |
|
| Command |
Marks a class as a command
|
| CommandFactory<T> |
Interface for command factories
|
| CommandFinder |
|
| CommandGroupMetadata |
Represents meta-data about a command group
|
| CommandGroupUsageGenerator<T> |
Interface implemented by classes that can generate usage documentation for a
command group
|
| CommandMetadata |
|
| CommandRequired |
Marks that a CLI requires that a command be specified.
|
| CommandRequiredRestriction |
|
| CommandSuggester |
|
| CommandTypeFinder |
|
| CommandUsageGenerator |
Interface implemented by classes that can generate usage documentation for a
command
|
| CommonSections |
Constants related to common help sections
|
| CommonSectionsFactory |
A help section factory that implements the common sections built into Airline
|
| CompletionBehaviour |
Possible completion behaviour for options/arguments
|
| CompletionCli |
An example of creating a CLI using command groups
|
| ComplexNumericTypeConverter |
Abstract numeric type converter that supports numerics given in the form
1234suffix where suffix denotes some multiplier.
|
| ConsolePrompt |
A prompt that is backed by System.console()
|
| Context |
|
| ControlCodeSource<T> |
Interface for classes that provide control codes
|
| ControlTracker<T> |
Class used to track the state of a control allowing it to be lazily written
to the output only if necessary and ensuring it can be appropriately reset
when necessary
|
| ConvertResult |
Helper class used to represent the result of an attempted conversion.
|
| Copyright |
Annotation that provides a copyright statement in a commands help
|
| CredentialsModule |
|
| CustomHelp |
|
| Debug |
|
| Decorations |
|
| DefaultCli |
An example of creating a CLI that includes a default command that is run if
no command is specified
|
| DefaultCommandFactory<T> |
|
| DefaultExternalHelpParser |
Default external help parser
|
| DefaultMatcher<TOption> |
Default prompt option matcher
|
| DefaultNumericConverter |
|
| DefaultOption |
Annotation to mark a field as the default option
|
| DefaultTypeConverter |
The default type converter
|
| DefaultTypeConverterProvider |
Default type converter provider which simply inspects the ParseState
given and returns the the type converter specified on the
ParserMetadata provided by the parse state |
| Directory |
Annotation that marks that an options value must be a valid path to a
directory
|
| Discussed |
|
| Discussion |
Annotation that provides a discussion section for a commands help
|
| DiscussionSection |
|
| DoubleComparator |
|
| DoubleRange |
Annotation that marks values as being restricted to a given double range
|
| EndsWith |
Annotation that marks that an options value must end with a given string
|
| EndsWithRestriction |
A restriction that requires raw values to end with one of a set of suffixes
|
| EnvVarLocator |
A resource locator that supports ${NAME} style placeholders to
refer to environment variables to locate resources referred to by those
environment variables
|
| ExactIgnoresCaseMatcher<TOption> |
|
| ExactLength |
Annotation that marks that an options value is restricted to being an exact
length
|
| ExactMatcher<TOption> |
|
| ExampleExecutor |
Helper class that launches and runs the actual example commands and CLIs
|
| ExampleRunnable |
|
| Examples |
Annotation that provides an examples section for a commands help
|
| ExamplesSection |
|
| ExitCodes |
Annotation that indicates the exit codes section for a commands help
|
| ExitCodesSection |
|
| ExtendedTypeConverter |
An example of an extended type converter that adds support for converting
from types that provide an parse(String) method
|
| ExternalDiscussion |
Defines a discussion section where the discussion content is provided in a text file on the classpath
|
| ExternalExamples |
Annotation that provides an examples section for a commands help via two external resources in textual format
|
| ExternalExitCodes |
Annotation that indicates the exit codes section for a commands help
|
| ExternalHelp |
|
| ExternalHelpFactory |
Help section factory that enables the additional annotations provided by this module
|
| ExternalProse |
Defines a prose section where the prose content is provided in a text file on the classpath
|
| ExternalTabularExamples |
Annotation that provides an examples section for a commands help via a single external resource in tabular format
|
| FailAll |
An error handler which collects all errors during parsing and then fails at
the end of parsing
|
| FailFast |
An error handler which fails as soon as a parser error is encountered
|
| File |
Annotation that marks that an options value must be a valid path to a
file
|
| FileInfo |
|
| FileLocator |
A resource locator that does no resolution other than removing any leading
file:// prefix i.e.
|
| FloatComparator |
|
| FloatRange |
Annotation that marks values as being restricted to a given float range
|
| GenerateHelp |
|
| GettingStarted |
|
| GlobalMetadata<T> |
Represents metadata about a CLI
|
| GlobalRestriction |
Interface for restrictions
|
| GlobalRestrictionFactory |
Interface for option restriction factories
|
| GlobalSuggester<T> |
|
| GlobalUsageGenerator<T> |
Interface implemented by classes that can generate usage documentation for a
command line interface
|
| GoodGrandchild |
When inheriting from existing classes it is possible to override previously
defined options but only if you are explicit about it.
|
| GreedyClassicGetOptParser<T> |
Greedy variant of the ClassicGetOptParser that allows consuming values that could otherwise be treated as
options in their own right. |
| GreedyMaybeListValueOptionParser<T> |
|
| Group |
Marks a class as providing command group metadata
|
| Group.NO_DEFAULT |
|
| GroupBuilder<C> |
|
| GroupCli |
An example of creating a CLI using command groups
|
| GroupFinder |
|
| Groups |
Marks a class as providing multiple command group metadata
|
| GroupSuggester |
|
| Help |
|
| Help<T> |
|
| HelpFormat |
Enumeration of help formats, a HelpSection or HelpHint may
provide this but help generators are not obliged to follow this |
| HelpHint |
Interface for classes that provide additional help information
|
| HelpOption<C> |
An option that provides a simple way for the user to request help with a
command
|
| HelpSection |
Interface for classes that represents additional help sections
|
| HelpSectionComparator |
|
| HelpSectionFactory |
Interface for factories that convert annotations into HelpSection
instances |
| HelpSectionRegistry |
Registry which maps annotations to help sections
|
| Hexadecimal |
A type converter that supports hexadecimal numbers
|
| HideSection |
Annotation used to specify that a section that would otherwise be inherited
from a parent class should be hidden
|
| HomeDirectoryLocator |
A resource locator that allows the ~/ or ~\ alias (depending
on your platforms file separator) to be used to refer to the users home
directory
|
| HtmlCommandUsageGenerator |
A usage generator that generates HTML documentation
|
| IgnoresCaseMatcher<TOption> |
An option matcher that ignores case
|
| IndexMatcher<TOption> |
An option matcher that matches options based on the numeric index of the option using 1 based indexes
|
| IntegerComparator |
|
| IntegerRange |
Annotation that marks values as being restricted to a given integer range
|
| IsRequiredArgumentFinder |
|
| IsRequiredOptionFinder |
|
| IsRequiredRestriction |
A restriction that options/arguments are required
|
| JdbcStyleOptionParser<T> |
Option parser that parses options given in JDBC connection URL style e.g.
|
| JpmsResourceLocator |
A resource locator that finds resources using ClassGraph that works in JPMS runtime contexts where the
standard ClasspathLocator does not. |
| JvmSystemPropertyLocator |
A resource locator that allows references to JVM system properties using
${property} references to locate resources referred to in those
properties
|
| KiloAs1000 |
A numeric type converter that supports standard using suffixes - k m b t - to abbreviate numbers expressed in
terms of thousands, millions, billions or trillions
|
| KiloAs1024 |
A numeric type converter that supports suffixes used to denote base 2 kilo units
|
| LengthRange |
Annotation that marks values as being restricted to a given length range i.e.
|
| LengthRestriction |
A restriction that requires string values meet length constraints
|
| LexicalComparator |
|
| LexicalRange |
Annotation that marks values as being restricted to a given lexical range
|
| License |
Annotation that provides a license statement in a commands help
|
| ListFormat<TOption> |
A prompt formatter that presents a list of options
|
| ListFormatBuilder<TOption> |
A builder that helps building list formats
|
| ListValueOptionParser<T> |
An options parser that requires the values to be a
non-whitespace separated list
|
| LocaleSensitiveStringFinder |
|
| Logs |
|
| Logs.Format |
|
| LongComparator |
|
| LongGetOptParser<T> |
An options parser that supports the GNU Get Opt long style i.e.
|
| LongRange |
Annotation that marks values as being restricted to a given long integer range
|
| ManCommandUsageGenerator |
A command usage generator which generates help in man page (Troff) format
|
| ManGlobalUsageGenerator<T> |
A global usage generator which generates Man pages in Troff format
|
| ManMultiPageGlobalUsageGenerator<T> |
|
| ManSections |
Standard man page section numbers
|
| Manuals |
|
| ManUsageHelper |
|
| MapAbbreviatedNumericTypeConverter |
|
| MarkdownCommandUsageGenerator |
|
| MarkdownGlobalUsageGenerator<T> |
|
| MarkdownMultiPageGlobalUsageGenerator<T> |
|
| MarkdownUsageHelper |
|
| MatcherUtils |
Option matcher utility functions
|
| MatcherUtils.Exact<TOption> |
|
| MatcherUtils.ExactIgnoresCase<TOption> |
|
| MatcherUtils.ExactOrStartsWith<TOption> |
|
| MatcherUtils.ExactOrStartsWithIgnoresCase<TOption> |
|
| MaxLength |
Annotation that marks that an options value is restricted to a maximum length
(which is inclusive)
|
| MaxOccurrences |
Annotation that marks an option as being restricted to occurring some maximum
number of times (inclusive)
|
| MaybeListValueOptionParser<T> |
An options parser that expects the name and value(s) to be white space separated e.g.
|
| MaybePairValueOptionParser<T> |
An options parser that expects the name and values to be white space
separated e.g.
|
| MaybeVerboseCommand |
|
| MetadataLoader |
Helper for loading meta-data
|
| MetadataLoader.InjectionMetadata |
|
| MinLength |
Annotation that marks that an options value is restricted to a minimum length
(which is inclusive)
|
| MinOccurrences |
Annotation that marks an option as being required to occur some minimum
number of times (inclusive)
|
| ModulePathLocator |
|
| ModuleReuse |
Here we have another command which reuses module classes we've defined and
also adds locally defined options, we can
|
| Modules |
If you have some set of options that make sense together you can modularize
them out as a class and inject them into your actual command class
|
| MultipleOf |
|
| MultipleOfRestriction |
|
| MultipleRestrictionFactory |
|
| MultiSequenceAbbreviatedNumericTypeConverter |
|
| MutuallyExclusiveRestriction |
|
| MutuallyExclusiveWith |
Annotation that indicates that you optionally permit one option from some set
of options to be present, the set of options are identified by a user defined
tag.
|
| MutuallyExclusiveWithFinder |
|
| MutuallyExclusiveWithOptionFinder |
|
| MutuallyExclusiveWithTagParsedOptionFinder |
|
| Negative |
Annotation that marks values as being restricted to being a negative value
|
| NoMissingOptionValues |
Specifies that a CLI does not permit options to be specified without their
values
|
| NoMissingOptionValuesRestriction |
|
| None |
A restriction which doesn't actually impose any restrictions
|
| NoOptionLikeValues |
An annotation that marks that values provided for options/arguments MUST NOT look like possible
options.
|
| NoOptionLikeValuesRestriction |
A restriction that enforces that values CANNOT look like options
|
| NotBlank |
An annotation that marks that an options values must not be blank i.e.
|
| NotBlankRestriction |
|
| NotEmpty |
An annotation that marks an options value must not be empty
|
| NotEmptyRestriction |
|
| NoUnexpectedArguments |
Marks that a CLI does not permit any command line arguments that aren't
recognised as either options or arguments.
|
| NoUnexpectedArgumentsRestriction |
|
| NumericCandidate |
|
| NumericTypeConverter |
Interfaces for numeric type converters
|
| OccurrencesRestriction |
|
| OccurrencesRestrictionFactory |
An annotation used to mark that an option must occur at most once
|
| Octal |
A type converter that supports octal numbers
|
| Once |
An annotation that marks that an option may occur at most once
|
| Option |
Annotation to mark a field as an option
|
| OptionalOption |
|
| OptionFinder |
|
| OptionMetadata |
|
| OptionParser<T> |
Interface for option parsers
|
| OptionRestriction |
Represents restrictions on options
|
| OptionRestrictionFactory |
Interface for option restriction factories
|
| OptionType |
|
| OutputStreamControlTracker<T> |
|
| Package |
|
| ParagraphsParser |
Parser that translates input into a series of paragraphs
|
| Parent |
We can use standard Java inheritance with commands and the child commands
will inherit options defined on their parents
|
| ParseAliasCircularReferenceException |
Exception that occurs when alias chaining is enabled and a circular reference
is encountered
|
| ParseArgumentsIllegalValueException |
Exception thrown when the value for an option is not in a specific set of
allowed values
|
| ParseArgumentsMissingException |
Exception thrown when required arguments are missing
|
| ParseArgumentsUnexpectedException |
Exception that is thrown when a command receives unexpected arguments
|
| ParseCommandMissingException |
Exception that is thrown when no command is specified
|
| ParseCommandUnrecognizedException |
Exception that is thrown when an unrecognized command is supplied
|
| ParsedOptionFinder |
|
| ParseException |
Super class of all command line parsing exceptions
|
| ParseInvalidRestrictionException |
Parser exception that indicates that a declared restriction was invalid
|
| ParseOptionConversionException |
Exception that is thrown when the argument supplied as the value for an
option cannot be converted to the options Java type
|
| ParseOptionGroupException |
A parser exception that relates to a restriction violated where the violation
pertains to some group of options
|
| ParseOptionIllegalValueException |
Exception thrown when the value for an option is not in a specific set of allowed values
|
| ParseOptionMissingException |
Exception that is thrown when a required option is missing
|
| ParseOptionMissingValueException |
Exception that is thrown when an option expects one/more values and no values
are supplied
|
| ParseOptionOutOfRangeException |
Error that indicates that an options value was outside of an acceptable range
|
| ParseOptionUnexpectedException |
Exception thrown if an option is encountered in an unexpected location e.g.
|
| Parser |
Class annotation used to declaratively specify a parser configuration
|
| ParserBuilder<C> |
Builder for parser configurations
|
| ParserErrorHandler |
Interface for parser error handlers
|
| ParseRestrictionViolatedException |
Exception class that indicates that some restriction was violated
|
| ParseResult<T> |
Represents parsing results
|
| ParserMetadata<T> |
Represents meta-data about the parser configuration
|
| ParserUtil |
|
| ParseState<T> |
|
| ParseTooManyArgumentsException |
Error that is thrown if too many arguments are provided
|
| Partial |
Annotation which is used as a modifier to indicate that a restriction
annotation (whose type is denoted by the Partial.restriction() field) does
not apply to all values passed to an Option or Arguments
annotated field but rather applies only to certain values |
| PartialRestriction |
|
| Partials |
|
| Path |
Annotation that marks that an options value must be a valid path to a
file/directory
|
| PathKind |
Enumeration of path kinds
|
| PathRestriction |
Implements restriction on options and arguments that expect to receive a path
to a file and/or directory
|
| PathRestrictionFactory |
|
| Paths |
|
| Paths.PathSource |
|
| Pattern |
An annotation that indicates that an options raw values must match a given
regular expression
|
| PatternRestriction |
A restriction which requires the raw values to match a given regular
expression
|
| Port |
Annotation that indicates that an option/argument denotes a port number and
its value should be restricted as such to a specific set of port classes as
defined by PortType. |
| PortRange |
Annotation that indicates that an option/argument denotes a port number and
its value should be restricted as such to a specific set of ports.
|
| PortRange |
Interface for port ranges, useful if you want to use the
PortRestriction with a custom port range implementation |
| PortRangeImpl |
Concrete implementation of a port range
|
| PortRanges |
Annotation that indicates that an option/argument denotes a port number and
its value should be restricted as such to a specific set of ports.
|
| PortRestriction |
|
| PortRestrictionFactory |
|
| PortType |
Port types
|
| PositionalAliasedCli |
An example of creating a CLI that takes advantage of the aliases feature.
|
| Positive |
Annotation that marks values as being restricted to being a positive value
|
| PositiveNegativeRestriction |
Restriction that enforces that values must be either positive/negative with
zero optionally included
|
| PostalAddress |
Represents a UK postal address
|
| PostalService |
Grades of postal service
|
| PrefixMatcher |
|
| Price |
|
| Prompt<TOption> |
Represents a prompt
|
| PromptBuilder<TOption> |
A prompt builder is used to define a prompt in a Fluent API style
|
| PromptException |
|
| PromptFormatBuilder<TOption> |
A prompt format builder is a child builder of a PromptBuilder used to define the prompt format in a fluent
style |
| PromptFormatter |
Interface for prompt formatters
|
| PromptOptionMatcher<TOption> |
|
| PromptProvider |
A provider of prompting
|
| Prompts |
Provides builds for some common
|
| PromptsDemo |
|
| PromptTimeoutException |
|
| ProseSection |
Annotation that provides a prose section for a commands help
|
| ProseSection |
|
| QuestionFormat<TOption> |
Prompt format for simple questions with either a free-form response or with a limited number of options
|
| RangeRestriction |
A restriction that requires the value (after type conversion) to be within a
given range
|
| RangeRestrictionFactory |
Factory which generates range restrictions from a variety of different range
annotations
|
| RelatedCommands |
|
| RelatedCommandsFactory |
|
| RelatedCommandsSection |
|
| Required |
An annotation that indicates that an option/arguments is required
|
| Required |
A command that has some required options
|
| RequiredArguments |
An example command that has required arguments
|
| RequiredFromFinder |
|
| RequiredOnlyIf |
An annotation that indicates that an option/arguments is required only if
some other option/options are present
|
| RequiredOnlyIfRestriction |
|
| RequiredOnlyIfRestrictionFactory |
|
| RequiredOption |
|
| RequiredTagOptionFinder |
|
| RequiredTagParsedOptionFinder |
|
| RequiredUnlessEnvironment |
An annotation that indicates that an option/arguments is required UNLESS a specific environment
variable is set.
|
| RequiredUnlessEnvironmentRestriction |
A restriction that requires an option/argument be set UNLESS a suitable environment variable is
specified.
|
| RequiredUnlessEnvironmentRestriction.IsEnvVarSet |
|
| RequireFromRestriction |
|
| RequireFromRestrictionFactory |
|
| RequireOnlyOne |
Annotation that indicates that you only permit one option from some set of
options to be present, the set of options are identified by a user defined
tag.
|
| RequireSome |
This annotation denotes that at least one of some set of options are
required, the set of options are identified by a user defined tag.
|
| ResourceLocator |
Interface for making resource search locations extensible e.g.
|
| RestrictionRegistry |
Central registry for restrictions
|
| ScanResultInputStream |
A wrapper around an InputStream originating from a ScanResult to ensure that it is closed when the stream is
closed
|
| SeeAlso |
Annotation that provides a see also section in help
|
| Send |
|
| SendIt |
|
| SendItCli |
|
| SequenceAbbreviatedNumericTypeConverter |
|
| ShortComparator |
|
| ShortRange |
Annotation that marks values as being restricted to a given short integer
range
|
| Simple |
A simple example that demonstrates most of the basic concepts
|
| SimpleCli |
A simple example of creating a CLI
|
| SimpleRestrictionsFactory |
|
| SingleCommand<C> |
Class for encapsulating and parsing single commands
|
| SingleCommandParser<T> |
|
| StandardGlobalRestrictionsFactory |
|
| StandardOptionParser<T> |
An options parser that expects the name and value(s) to be white space
separated e.g.
|
| StartsWith |
Annotation that marks that an options value must start with a given string
|
| StartsWithRestriction |
A restriction that requires raw values to start with one of a set of prefixes
|
| StdIOPrompt |
A prompt backed by System.out and System.in
|
| StreamPrompt |
Creates a new prompt backed by arbitrary streams
|
| StringHierarchyComparator |
|
| StringRestrictionFactory |
|
| SuffixMatcher |
|
| SuggestCommand<T> |
|
| Suggester |
|
| SuggesterMetadata |
|
| SuggestionParser<T> |
|
| SystemChannelFactory |
Default implementation of ChannelFactory which uses System.out, System.err and
System.in for the channels. |
| TabDelimitedHelpParser |
An external helper parser that parses tabular resources in Tab Delimited format
|
| TabularParser |
|
| Tool |
|
| TroffPrinter |
Printer class for generating Troff output
|
| TroffPrinter.BulletStyle |
Supported bullet style
|
| TroffPrinter.ListType |
|
| TrueColor |
True (24 bit) colours i.e.
|
| TypeConverter |
Interface for type converters
|
| TypeConverterProvider |
Interface for type converter providers
|
| Unrestricted |
An annotation that indicates that no restrictions should apply
|
| UsageHelper |
|
| UsagePrinter |
Helper for printing out usage information
|
| UserAliasedCli |
An example of creating a CLI that takes advantage of the aliases feature.
|
| UserAliasesSource<C> |
Represents the source of user defined aliases
|
| UserAliasSourceBuilder<C> |
User alias source builder
|
| ValueMatcher<TOption> |
An option matcher that matches based on actual value rather than strings
|
| VerbosityModule |
|
| Version |
|
| VersionSection |
|
| VersionSection.VersionInfo |
|
| WorkingDirectoryLocator |
A user alias locator that allows the ./ or .\ alias
(depending on your platforms file separator) to be used to refer to the
current working directory
|
| WriterControlTracker<T> |
|
| YourInterface |
|