All Classes and Interfaces

Class
Description
 
 
 
 
An example of creating a CLI with abbreviation enabled
 
 
Abstract base class for builders
A builder that is a child of another builder
 
Abstract command group usage generator
Abstract implementation of a parser for commands that can cope with both CLI and Single Command parsing
Abstract command usage generator
 
 
Abstract global usage generator
An abstract string restriction that needs a locale and case sensitivity flag
 
Abstract option parser for options that are specified in --name=value style while the separator character (in this example =) can be configured as desired.
 
Abstract option parser that provides some useful helper methods to derived classes
 
 
Abstract base class for parsers providing some utility methods
A resource locator that supports placeholders of the form ${name} which when found calls the AbstractPlaceholderLocator.resolvePlaceholder(String) method to try and resolve the encountered placeholders.
Abstract command group usage generator for generators that use a UsagePrinter to generate the documentation
Abstract command usage generator for generators that use a UsagePrinter to generate the documentation
Abstract global usage generator for generators that use a UsagePrinter to generate the documentation
A restriction that options/arguments are required unless some other criteria is met
Abstract restrictions on string values for options and arguments
 
 
Used to mark a field of a command class as representing a module of command functionality.
 
Specifies a command alias
 
Builds a command alias
An example of creating a CLI that takes advantage of the aliases feature.
 
Metadata about command aliases
Resolves aliases
Annotation that marks that the option/arguments are restricted to a given set of raw string values as defined by a given enum type
 
Annotation that marks that the option/arguments are restricted to a given set of raw string values
 
Annotation that marks that the option/arguments are restricted to a given set of values
 
 
 
A colorized output stream supporting the ANSI 256 colour palette
A colorized writer supporting the ANSI 256 colour palette
An ANSI colour source for background colours
A colorized output stream supporting the basic ANSI colours
A colorized writer supporting the basic ANSI colors
Interface that may be implemented by colour providers
 
Constants
Interface for classes that provide ANSI decorations
 
An ANSI colour source for background colours
An output stream that supports customized output via ANSI control codes
A colorized output stream supporting ANSI true colour (24 bit i.e.
A colorized writer supporting ANSI true colour (24 bit i.e.
A writer that supports customizing the output with ANSI control codes
 
 
Represents restrictions on arguments
Interface for arguments restriction factories
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.
 
Annotates a field with Bash completion information
 
 
 
The 8 basic ANSI Colours
Support for the basic ANSI decorations
 
 
A type converter that supports binary numbers
 
 
Annotation that marks values as being restricted to a given byte range
Factory for various channels used by airline.
Channels provides methods for the cli output, error and input channels.
 
 
 
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.
A resource locator that finds resources on the classpath
Class annotation used to declaratively specify a CLI
Class for encapsulating and parsing CLIs
 
Builder for CLIs
 
 
 
 
 
 
Error handler which collects all the errors for later inspection
An option parser where the name and value are colon separated i.e.
256 colour i.e.
 
An output stream that supports colorization and some basic text decorations
An writer stream that supports colorization and basic text decorations
 
 
 
Marks a class as a command
Interface for command factories
 
Represents meta-data about a command group
Interface implemented by classes that can generate usage documentation for a command group
 
Marks that a CLI requires that a command be specified.
 
 
 
Interface implemented by classes that can generate usage documentation for a command
Constants related to common help sections
A help section factory that implements the common sections built into Airline
Possible completion behaviour for options/arguments
An example of creating a CLI using command groups
Abstract numeric type converter that supports numerics given in the form 1234suffix where suffix denotes some multiplier.
A prompt that is backed by System.console()
 
Interface for classes that provide control codes
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
Helper class used to represent the result of an attempted conversion.
Annotation that provides a copyright statement in a commands help
 
 
 
 
An example of creating a CLI that includes a default command that is run if no command is specified
 
Default external help parser
Default prompt option matcher
 
Annotation to mark a field as the default option
The default type converter
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
Annotation that marks that an options value must be a valid path to a directory
 
Annotation that provides a discussion section for a commands help
 
 
Annotation that marks values as being restricted to a given double range
Annotation that marks that an options value must end with a given string
A restriction that requires raw values to end with one of a set of suffixes
A resource locator that supports ${NAME} style placeholders to refer to environment variables to locate resources referred to by those environment variables
 
Annotation that marks that an options value is restricted to being an exact length
 
Helper class that launches and runs the actual example commands and CLIs
 
Annotation that provides an examples section for a commands help
 
Annotation that indicates the exit codes section for a commands help
 
An example of an extended type converter that adds support for converting from types that provide an parse(String) method
Defines a discussion section where the discussion content is provided in a text file on the classpath
Annotation that provides an examples section for a commands help via two external resources in textual format
Annotation that indicates the exit codes section for a commands help
 
Help section factory that enables the additional annotations provided by this module
Defines a prose section where the prose content is provided in a text file on the classpath
Annotation that provides an examples section for a commands help via a single external resource in tabular format
An error handler which collects all errors during parsing and then fails at the end of parsing
An error handler which fails as soon as a parser error is encountered
Annotation that marks that an options value must be a valid path to a file
 
A resource locator that does no resolution other than removing any leading file:// prefix i.e.
 
Annotation that marks values as being restricted to a given float range
 
 
Represents metadata about a CLI
Interface for restrictions
Interface for option restriction factories
 
Interface implemented by classes that can generate usage documentation for a command line interface
When inheriting from existing classes it is possible to override previously defined options but only if you are explicit about it.
Greedy variant of the ClassicGetOptParser that allows consuming values that could otherwise be treated as options in their own right.
A variation on the MaybeListValueOptionParser that is greedy
Marks a class as providing command group metadata
 
 
An example of creating a CLI using command groups
 
Marks a class as providing multiple command group metadata
 
 
 
Enumeration of help formats, a HelpSection or HelpHint may provide this but help generators are not obliged to follow this
Interface for classes that provide additional help information
An option that provides a simple way for the user to request help with a command
Interface for classes that represents additional help sections
 
Interface for factories that convert annotations into HelpSection instances
Registry which maps annotations to help sections
A type converter that supports hexadecimal numbers
Annotation used to specify that a section that would otherwise be inherited from a parent class should be hidden
A resource locator that allows the ~/ or ~\ alias (depending on your platforms file separator) to be used to refer to the users home directory
A usage generator that generates HTML documentation
An option matcher that ignores case
An option matcher that matches options based on the numeric index of the option using 1 based indexes
 
Annotation that marks values as being restricted to a given integer range
 
 
A restriction that options/arguments are required
Option parser that parses options given in JDBC connection URL style e.g.
A resource locator that finds resources using ClassGraph that works in JPMS runtime contexts where the standard ClasspathLocator does not.
A resource locator that allows references to JVM system properties using ${property} references to locate resources referred to in those properties
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
A numeric type converter that supports suffixes used to denote base 2 kilo units
Annotation that marks values as being restricted to a given length range i.e.
A restriction that requires string values meet length constraints
 
Annotation that marks values as being restricted to a given lexical range
Annotation that provides a license statement in a commands help
A prompt formatter that presents a list of options
A builder that helps building list formats
An options parser that requires the values to be a non-whitespace separated list
 
 
 
 
An options parser that supports the GNU Get Opt long style i.e.
Annotation that marks values as being restricted to a given long integer range
A command usage generator which generates help in man page (Troff) format
A global usage generator which generates Man pages in Troff format
 
Standard man page section numbers
 
 
 
 
 
 
 
Option matcher utility functions
 
 
 
 
Annotation that marks that an options value is restricted to a maximum length (which is inclusive)
Annotation that marks an option as being restricted to occurring some maximum number of times (inclusive)
An options parser that expects the name and value(s) to be white space separated e.g.
An options parser that expects the name and values to be white space separated e.g.
 
Helper for loading meta-data
 
Annotation that marks that an options value is restricted to a minimum length (which is inclusive)
Annotation that marks an option as being required to occur some minimum number of times (inclusive)
 
Here we have another command which reuses module classes we've defined and also adds locally defined options, we can
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
 
 
 
 
 
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.
 
 
 
Annotation that marks values as being restricted to being a negative value
Specifies that a CLI does not permit options to be specified without their values
 
A restriction which doesn't actually impose any restrictions
An annotation that marks that values provided for options/arguments MUST NOT look like possible options.
A restriction that enforces that values CANNOT look like options
An annotation that marks that an options values must not be blank i.e.
 
An annotation that marks an options value must not be empty
 
Marks that a CLI does not permit any command line arguments that aren't recognised as either options or arguments.
 
 
Interfaces for numeric type converters
 
An annotation used to mark that an option must occur at most once
A type converter that supports octal numbers
An annotation that marks that an option may occur at most once
Annotation to mark a field as an option
 
 
 
Interface for option parsers
Represents restrictions on options
Interface for option restriction factories
 
 
 
Parser that translates input into a series of paragraphs
We can use standard Java inheritance with commands and the child commands will inherit options defined on their parents
Exception that occurs when alias chaining is enabled and a circular reference is encountered
Exception thrown when the value for an option is not in a specific set of allowed values
Exception thrown when required arguments are missing
Exception that is thrown when a command receives unexpected arguments
Exception that is thrown when no command is specified
Exception that is thrown when an unrecognized command is supplied
 
Super class of all command line parsing exceptions
Parser exception that indicates that a declared restriction was invalid
Exception that is thrown when the argument supplied as the value for an option cannot be converted to the options Java type
A parser exception that relates to a restriction violated where the violation pertains to some group of options
Exception thrown when the value for an option is not in a specific set of allowed values
Exception that is thrown when a required option is missing
Exception that is thrown when an option expects one/more values and no values are supplied
Error that indicates that an options value was outside of an acceptable range
Exception thrown if an option is encountered in an unexpected location e.g.
Class annotation used to declaratively specify a parser configuration
Builder for parser configurations
Interface for parser error handlers
Exception class that indicates that some restriction was violated
Represents parsing results
Represents meta-data about the parser configuration
 
 
Error that is thrown if too many arguments are provided
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
 
Annotation which is used to provide multiple Partial annotations to a Option or Arguments annotated field
Annotation that marks that an options value must be a valid path to a file/directory
Enumeration of path kinds
Implements restriction on options and arguments that expect to receive a path to a file and/or directory
 
 
 
An annotation that indicates that an options raw values must match a given regular expression
A restriction which requires the raw values to match a given regular expression
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.
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.
Interface for port ranges, useful if you want to use the PortRestriction with a custom port range implementation
Concrete implementation of a port range
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.
 
 
Port types
An example of creating a CLI that takes advantage of the aliases feature.
Annotation that marks values as being restricted to being a positive value
Restriction that enforces that values must be either positive/negative with zero optionally included
Represents a UK postal address
Grades of postal service
 
 
Represents a prompt
A prompt builder is used to define a prompt in a Fluent API style
 
A prompt format builder is a child builder of a PromptBuilder used to define the prompt format in a fluent style
Interface for prompt formatters
Interfaces for option matchers that controls how options are matched to the prompt response when using Prompt.promptForOption(boolean)
A provider of prompting
Provides builds for some common
 
 
Annotation that provides a prose section for a commands help
 
Prompt format for simple questions with either a free-form response or with a limited number of options
A restriction that requires the value (after type conversion) to be within a given range
Factory which generates range restrictions from a variety of different range annotations
 
 
 
An annotation that indicates that an option/arguments is required
A command that has some required options
An example command that has required arguments
 
An annotation that indicates that an option/arguments is required only if some other option/options are present
 
 
 
 
 
An annotation that indicates that an option/arguments is required UNLESS a specific environment variable is set.
A restriction that requires an option/argument be set UNLESS a suitable environment variable is specified.
 
 
 
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.
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.
Interface for making resource search locations extensible e.g.
Central registry for restrictions
A wrapper around an InputStream originating from a ScanResult to ensure that it is closed when the stream is closed
Annotation that provides a see also section in help
 
 
 
 
 
Annotation that marks values as being restricted to a given short integer range
A simple example that demonstrates most of the basic concepts
A simple example of creating a CLI
 
Class for encapsulating and parsing single commands
 
 
An options parser that expects the name and value(s) to be white space separated e.g.
Annotation that marks that an options value must start with a given string
A restriction that requires raw values to start with one of a set of prefixes
A prompt backed by System.out and System.in
Creates a new prompt backed by arbitrary streams
 
 
 
 
 
 
 
Default implementation of ChannelFactory which uses System.out, System.err and System.in for the channels.
An external helper parser that parses tabular resources in Tab Delimited format
 
 
Printer class for generating Troff output
Supported bullet style
 
True (24 bit) colours i.e.
Interface for type converters
Interface for type converter providers
An annotation that indicates that no restrictions should apply
 
Helper for printing out usage information
An example of creating a CLI that takes advantage of the aliases feature.
Represents the source of user defined aliases
User alias source builder
An option matcher that matches based on actual value rather than strings
 
 
 
 
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