All Classes and Interfaces
Class
Description
Abstract base class implementing common methods for command registries.
Base implementation for terminals on POSIX-compliant systems.
Base implementation of the Pty interface.
Base implementation of the Terminal interface.
Base class for writing to Windows console.
Base implementation for terminals on Windows systems.
Completer which contains multiple completers and aggregates them together.
Provides a fluent API for generating
ANSI escape sequences.
Display attributes, also know as
SGR
(Select Graphic Rendition) parameters.
ANSI 8 colors for fluent API
ED (Erase in Display) / EL (Erase in Line) parameter (see
CSI sequence J and K)
Colors support.
Provides consistent access to an ANSI aware console PrintStream or an ANSI codes stripping PrintStream
if not on a terminal (see
Jansi native
CLibrary isatty(int)).
Main class for the library, providing executable jar to diagnose Jansi setup.
Ansi mode.
A ANSI print stream extracts ANSI escape codes written to
an output stream and calls corresponding
AnsiProcessor.process*
methods.Simple PrintStream holding an AnsiOutputStream.
ANSI processor providing
process*
corresponding to ANSI escape codes.Renders ANSI color escape-codes in strings by parsing out some special syntax to pick up the correct fluff to use.
Processor type.
A writer that processes ANSI escape sequences.
Represents a command argument description used for generating command help and documentation.
A
Completer
implementation that invokes a child completer using the appropriate separator argument.A simple implementation of ParsedLine for argument completion.
A character sequence with ANSI style attributes.
Enum defining color mode forcing options for ANSI rendering.
An immutable character sequence with ANSI style attributes.
A mutable builder for creating styled text strings with ANSI attributes.
Text styling for terminal output with support for colors, fonts, and other attributes.
Encapsulates terminal attributes and settings that control terminal behavior.
Control characters used for special terminal functions.
Control flags that manage hardware aspects of the terminal.
Input flags that control how terminal input is processed.
Local flags that control various terminal behaviors.
Output flags that control how terminal output is processed.
Creates and manages widgets that intelligently handle matching delimiters in the console.
Creates and manages widgets for as-you-type command line suggestions based on command history.
Marker interface for objects that can be bound to key sequences in a KeyMap.
The BindingReader transforms incoming characters into key bindings.
Represents the editable text buffer in the LineReader.
Default implementation of the
Buffer
interface.Implementation of CommandRegistry that provides built-in commands for JLine.
Enumeration of built-in commands provided by this class.
Represents a completion candidate for tab completion.
Utility class for working with classpath resources.
Interface to access some low level POSIX functions,.
termios structure for termios functions, describing a general terminal interface that is
provided to control asynchronous communications ports
Window sizes.
Exception thrown when attempting to use a closed resource.
Represents a command description used for generating command help and documentation.
Represents a command line with its parsed components.
Enumeration specifying the type of description that should be displayed for the command.
Color palette for terminal color management and conversion.
Helper class for dealing with color rounding.
Utility class for color-related operations and definitions.
Ansi processor to process color conversion if needed.
Encapsulates the input and output streams for a command execution.
Class that encapsulates the execution and completion methods for a command.
Interface for registering, describing, and executing commands in a console application.
Class representing a command execution session.
Provides built-in commands for JLine applications.
A completer is the mechanism by which tab-completion candidates will be resolved.
Provides a collection of completion-related classes and utilities for JLine applications.
A completer that accepts any input.
A completer implementation that provides command and argument completion.
Holds data for command completion.
Interface defining the environment for command completion.
A completer for directory names.
A file name completer takes the buffer and issues a list of
potential completions.
A completer for file names.
Describes a command-line option for completion.
A completer for command options and arguments.
A completer that uses regular expressions to match command patterns.
A simple implementation of ParsedLine for argument completion.
A completer that supports hierarchical command structures.
Represents a node in the completion tree.
An extension of
ParsedLine
that, being aware of the quoting and escaping rules
of the Parser
that produced it, knows if and how a completion candidate
should be escaped/quoted.Interface for matching and filtering completion candidates.
Default implementation of the
CompletionMatcher
interface.Manages configuration file paths for JLine applications.
Class that implements a connection with this telnet daemon.
An utility class that is used to store and allow retrieval
of all data associated with a connection.
Class implementing a ConnectionEvent.
These events are used to communicate things that are supposed to be handled within the application context.
These events are used to communicate things that are supposed to be handled within the application context.
Interface defining a generic IP level connection
filter.
Due to the fact that this task depends heavily on application context, I chose a very generic way of applying IP level connection filtering.
Due to the fact that this task depends heavily on application context, I chose a very generic way of applying IP level connection filtering.
Interface to be implemented if a class wants to
qualify as a ConnectionListener.
Note that a Shell is per contract also forced to implement this interface.
Note that a Shell is per contract also forced to implement this interface.
Class that takes care for active and queued connection.
Interface for managing console variables, commands, and script execution in a console application.
Class representing the result of executing a command.
Class for creating widgets from console functions.
Manage console variables, commands and script execution.
Interface for retrieving console options.
Utility class for terminal cursor and screen manipulation using ANSI escape sequences.
Represents the position of the cursor within a terminal.
Utility class for cursor position detection in terminals.
Default implementation of the
Expander
interface.Default implementation of the
Highlighter
interface.Default implementation of
History
with file-based persistent storage.Default implementation of the
History.Entry
interface.Default implementation of the
Parser
interface.Class representing block comment delimiters.
Enumeration of bracket types that can be used for EOF detection on unclosed brackets.
Default implementation of the Printer interface that provides syntax highlighting and formatting.
Diagnostic utility for JLine terminals.
Utility class for computing differences between strings with ANSI attribute awareness.
Class representing one diff operation.
The data structure representing a diff is a Linked list of Diff objects:
{Diff(Operation.DELETE, "Hello"), Diff(Operation.INSERT, "Goodbye"),
Diff(Operation.EQUAL, " world.")}
which means: delete "Hello", add "Goodbye" and keep " world."
Manages terminal display and efficient screen updates with cursor positioning.
A minimal terminal implementation with limited capabilities.
Terminal provider implementation for dumb terminals.
Interface for launching external editors from within a JLine application.
This exception is thrown by
LineReader.readLine()
when
user the user types ctrl-D).Exception thrown when parsing is incomplete due to unexpected end of input.
Utility class for executing external commands and capturing their output.
A pseudoterminal implementation that uses external commands to interact with the terminal.
A terminal provider implementation that uses external commands to interact with the terminal.
The Expander interface provides functionality for expanding special syntax in command lines.
Terminal implementation designed for external connections with embedded line discipline.
A simple buffering output stream with no synchronization.
A simple, non-synchronized buffered output stream for improved performance.
Deprecated.
The Highlighter interface provides syntax highlighting functionality for the LineReader.
Console command history management interface.
Represents a single history entry containing a command line and its metadata.
Utility class for terminal capability handling and terminfo database access.
Utility class for configuring a LineReader from an inputrc file.
Handles inputrc configuration files for JLine.
A specialized InputStreamReader that reads the minimal number of bytes needed.
Interpolation.
CommandRegistry common methods for JLine commands that are using HelpException.
Native interface for JLine's low-level system operations.
Manages the loading of JLine's native libraries (*.dll, *.jnilib, *.so) according to the current
operating system (Windows, Linux, macOS) and architecture.
Terminal provider implementation that uses JNI (Java Native Interface) to access
native terminal functionality.
Interface to access Win32 base APIs.
see: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682013(v=vs.85).aspx
http://msdn.microsoft.com/en-us/library/ms682093%28VS.85%29.aspx
see: http://msdn.microsoft.com/en-us/library/ms683149(v=VS.85).aspx
see: http://msdn.microsoft.com/en-us/library/ms683499(v=VS.85).aspx
see: http://msdn.microsoft.com/en-us/library/ms684166(v=VS.85).aspx
see: http://msdn.microsoft.com/en-us/library/ms684213(v=VS.85).aspx
see: http://msdn.microsoft.com/en-us/library/ms684239(v=VS.85).aspx
http://msdn.microsoft.com/en-us/library/ms686311%28VS.85%29.aspx
see: http://msdn.microsoft.com/en-us/library/ms687093(v=VS.85).aspx
The KeyMap class maps keyboard input sequences to operations or actions.
The kill ring class keeps killed text in a fixed size ring.
A terminal pager similar to the 'less' Unix command.
Utility class for computing string similarity using the Damerau-Levenshtein algorithm.
Abstract terminal with support for line discipline.
Read lines from the console, with input editing.
A builder for creating and configuring
LineReader
instances.The default implementation of the
LineReader
interface.Possible states in which the current readline operation may be in.
Internal logging utility for JLine components.
A macro that executes a sequence of keystrokes when invoked.
Callback used to mask parts of the line for sensitive input like passwords.
In-memory implementation of
StyleSource
.Represents a mouse event in a terminal that supports mouse tracking.
Defines the mouse buttons that can be involved in a mouse event.
Defines the modifier keys that can be pressed during a mouse event.
Defines the types of mouse events that can occur.
Utility class for mouse support in terminals.
A terminal text editor similar to the 'nano' Unix command.
Interface representing a diagnostic message for code in the editor.
Implementation of SignalHandler for native signal handling.
Non-deterministic Finite Automaton (NFA) implementation for pattern matching.
Factory class for creating non-blocking I/O components.
An input stream that supports non-blocking read operations with timeouts.
This class wraps a regular input stream and allows it to appear as if it
is non-blocking; that is, reads can be performed against it that timeout
if no data is seen for a period of time.
A reader that provides non-blocking read operations.
This class wraps a regular reader and allows it to appear as if it
is non-blocking; that is, reads can be performed against it that timeout
if no data is seen for a period of time.
A no-operation implementation of
StyleSource
that always returns null
.Null completer.
A GNU-style long options parser that is configured by parsing its usage string.
Exception thrown when using the
--help
option on a built-in command.Provides OS name and architecture name.
Utility class for operating system detection and OS-specific operations.
ParsedLine
objects are returned by the Parser
during completion or when accepting the line.The Parser interface is responsible for parsing command lines into tokens.
Class that implements a
If available, it accepts incoming connections and passes them to an associated
PortListener
.If available, it accepts incoming connections and passes them to an associated
ConnectionManager
.Terminal implementation for POSIX systems using a pseudoterminal (PTY).
Terminal implementation for POSIX systems using system streams.
Redirects a
Writer
to a LineReader
's LineReader.printAbove(String)
method,
which draws output above the current prompt / input line.Interface for printing objects to the console with various formatting options.
Enumeration specifying which rows in a table should be highlighted.
Represents a pseudoterminal (PTY) that provides terminal emulation.
A reader implementation with an associated writer for buffered character transfer.
Utility methods for LineReader implementations.
A reference to a
Widget
by name.A virtual terminal screen implementation.
Interface for managing script engine variables, statements, and script execution.
Manages the JLine shutdown-hook thread and tasks to execute on shutdown.
Essentially a
Runnable
which allows running to throw an exception.Signal handling utilities for terminal applications.
Simple
MaskingCallback
that will replace all the characters in the line with the given mask.Simple SystemRegistry which stores variables in the LineReader.
Represents the dimensions of a terminal in terms of rows and columns.
Interface representing a source of data that can be read.
A Source implementation that reads from an InputStream.
A Source implementation that reads from a file system path.
A Source implementation that reads from a classpath resource.
A Source implementation that reads from standard input.
A Source implementation that reads from a URL.
Manages a status bar at the bottom of the terminal.
Completer for a set of strings.
Marker interface for proxy-based style bundles.
Annotation that provides a default style specification for a method in a StyleBundle interface.
Annotation that specifies the style group name for a StyleBundle interface.
Annotation that allows overriding the style name for a method in a StyleBundle interface.
Deprecated.
use
Colors.rgbColor(String)
insteadA
PrintWriter
extension that understands and evaluates StyleExpression
syntax.Provides evaluation of style expressions in the format
@{style value}
.Factory for creating styled strings using a specific style group.
Style facade that provides static utility methods for working with styles.
Resolves named (or source-referenced)
AttributedStyle
for a specific style group.Resolves named styles and style expressions into AttributedStyle objects.
Provides styling utilities for JLine applications.
Interface for sources of style configuration.
Exception thrown when a syntax error is encountered during parsing.
Java implementation of a syntax highlighter based on nanorc format.
Completer which contains multiple completers and aggregates them together.
Highlighter implementation that provides syntax highlighting for commands and languages.
Interface for aggregating command registries and dispatching command executions in a console application.
Class for managing the system registry store.
Aggregate command registries.
Represents the standard system streams available in a terminal environment.
Creates and manages widgets for as-you-type command line suggestions.
Enumeration specifying the type of suggestions to display.
Class that represents the TelnetIO implementation.
A terminal representing a virtual terminal on the computer.
Types of signals that can be handled by terminal applications.
Interface for handling terminal signals.
Builder class to create
Terminal
instances with flexible configuration options.Extended Terminal interface that provides access to internal implementation details.
Service provider interface for terminal implementations.
Helper class for managing timeouts during I/O operations.
A terminal multiplexer similar to the 'tmux' Unix command.
A terminal-based thread monitoring tool similar to the 'top' Unix command.
Provides undo/redo functionality for the LineReader.
This exception is thrown by
LineReader.readLine()
when
user interrupt handling is enabled and the user types the
interrupt character (ctrl-C).Utility class for determining the display width of Unicode characters.
A Widget represents an action that can be bound to a key sequence in the LineReader.
Base class for creating custom widgets for JLine's LineReader.
A Windows ANSI escape processor, that uses JNA to access native platform
API's to change the console attributes (see
Jansi native Kernel32).
A Windows ANSI escape processor, that uses JNA to access native platform
API's to change the console attributes.
A Windows ANSI escape processor, uses JNA to access native platform
API's to change the console attributes.
A Windows ANSI escape processor, that uses JNA to access native platform
API's to change the console attributes.
Deprecated.
An OutputStream implementation that writes to a Writer, bridging byte and character streams.
org.jline.builtins.Completers$FileNameCompleter
instead