All Classes and Interfaces
Class
Description
Base implementation of
Command that stores name and aliases.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 flattened POSIX system terminals that bypass the PTY abstraction.
Base class for writing to Windows console.
Base implementation for terminals on Windows systems.
Completer which contains multiple completers and aggregates them together.
Built-in alias commands:
alias and unalias.Manages command aliases for the shell.
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.
Deprecated.
A
Completer implementation that invokes a child completer using the appropriate separator argument.A simple implementation of ParsedLine for argument completion.
Describes a command argument with a name and optional description.
A character sequence with ANSI style attributes.
Controls how indexed (palette) colors are rendered in ANSI output.
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.
Provides intelligent auto-pairing of matching delimiters in the command line.
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.
Deprecated.
Deprecated.
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.
Parses OSC 10/11 color query responses from the terminal.
Represents a single executable command in the shell.
Describes a command for help display and widget integration.
Builder for
CommandDescription instances.Central dispatcher that aggregates
CommandGroups and handles
command resolution, execution, and completion.A named group of
Commands for organization and discovery.Adapts an old
CommandRegistry to the new CommandGroup interface.Command-aware syntax highlighter for the shell.
Deprecated.
Represents a parsed command line with its components.
The type of description that should be displayed.
Deprecated.
Deprecated.
Class representing a command execution session.
Adapts a new
CommandGroup to the old CommandRegistry interface.Provides built-in commands for JLine applications.
Encapsulates the execution context for a command, including the terminal,
I/O streams, session variables, working directory, and job state.
Provides real-time command-line suggestions as the user types, using
CommandDescription for positional argument hints and option help.The type of suggestions to display.
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.
Factory that creates a
CommandDispatcher backed by the legacy console
infrastructure (SystemRegistryImpl, Builtins, and optionally
ConsoleEngineImpl).Deprecated.
Class representing the result of executing a command.
Class for creating widgets from console functions.
Manage console variables, commands and script execution.
A
LineExpander backed by a ConsoleEngine's parameter expansion.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 in-memory implementation of
AliasManager with optional file persistence.Default implementation of
CommandDispatcher that supports pipeline execution.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
Job.Default implementation of
JobManager.Default implementation of
LineExpander that provides sane defaults
for variable expansion.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
Pipeline.Default implementation of
Pipeline.Stage.Default implementation of the Printer interface that provides syntax highlighting and formatting.
Default implementation of
ScriptRunner that reads a script file
line by line and executes each line through the dispatcher.Converts between old console description types and new shell description types.
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.")}
Manages terminal display and efficient screen updates with cursor positioning.
Utility class for handling double-size characters in terminals.
Enumeration of double-size character modes.
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.
FFM-based POSIX system terminal that calls
CLibrary directly.FreeBSD-specific termios flag constants and control character indices.
Built-in help command group.
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.
Built-in history command group.
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.
Implementation of iTerm2's Inline Images Protocol.
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.
JNI-based POSIX system terminal that calls
CLibrary directly.Represents a job in the shell's job control system.
Job lifecycle status.
Built-in job control commands:
jobs, fg, and bg.Listener for job status changes.
Manages jobs in the shell's job control system.
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
Represents a keyboard event in a terminal.
Defines arrow key directions.
Defines modifier keys that can be held during a key event.
Defines special keys.
Defines the types of key events that can occur.
The KeyMap class maps keyboard input sequences to operations or actions.
Utility class for parsing raw terminal input sequences into KeyEvent objects.
The kill ring class keeps killed text in a fixed size ring.
Implementation of Kitty's Graphics Protocol.
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.
Expands variables and other expressions in a command line before parsing.
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.
Linux-specific termios flag constants and control character indices.
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.
Wrapper that prevents closing the underlying input stream.
Wrapper that prevents closing the underlying output stream.
A no-operation implementation of
StyleSource that always returns null.Null completer.
Built-in option management commands:
setopt, unsetopt, and setvar.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.
macOS (Darwin) specific termios flag constants and control character indices.
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.
Represents a pipeline of commands connected by operators such as pipes,
redirections, and conditional connectors.
Operators that connect commands in a pipeline.
A single stage in a pipeline, consisting of a command line and the
operator that follows it.
Fluent builder for constructing
Pipeline instances programmatically.Parses a command line string into a
Pipeline.A token from tokenization -- either text or an operator.
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.POSIX-like command implementations for JLine applications.
Interface for executing shell commands in watch.
Context for command execution, providing I/O streams and current directory.
Comparator for sorting strings with various options.
Registry for POSIX commands that provides a convenient way to register and execute
POSIX commands in JLine applications.
Functional interface for command implementations that can throw exceptions.
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.
An OutputStream that decodes bytes and writes them to a
ScreenTerminal,
feeding any VT100 responses back as terminal input.A placeholder OutputStream whose delegate can be set after construction.
Built-in commands for script execution.
Interface for managing script engine variables, statements, and script execution.
Executes a script file line by line through a
CommandDispatcher.An interactive shell that runs a read-eval-print loop (REPL)
using a
CommandDispatcher for command execution.Builder for creating
Shell instances.SSHD
Command factory which provides access to
Shell.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.
Default implementation of
CommandGroup backed by a list of commands.Simple
MaskingCallback that will replace all the characters in the line with the given mask.Simple SystemRegistry which stores variables in the LineReader.
Implementation of the Sixel Graphics Protocol.
Represents the dimensions of a terminal in terms of rows and columns.
Represents an object (e.g. a terminal) which has a size in character cells.
Solaris (SunOS) specific termios flag constants and control character indices.
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.
A
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.
A Swing-based terminal implementation that extends LineDisciplineTerminal.
JComponent that renders the terminal display.
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.
Deprecated.
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.
Common interface for terminal graphics protocols.
Image display options for controlling how images are rendered.
Graphics protocol types supported by terminals.
Manager for terminal graphics protocols.
Service provider interface for terminal implementations.
Platform-independent holder for POSIX termios fields.
Converts between JLine
Attributes and platform-native TermiosData.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 an
CommandDispatcher
when it failed to find a requested command.This exception is thrown by
LineReader.readLine() when
user interrupt handling is enabled and the user types the
interrupt character (ctrl-C).Built-in commands for managing session variables:
set, unset, and export.Utility class for determining the display width of Unicode characters.
A web-based terminal implementation that extends LineDisciplineTerminal.
The inner WebTerminalComponent that contains the original ScreenTerminal-based implementation.
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.
An OutputStream implementation that writes to a Writer, bridging byte and character streams.