Package jline.console

Class ConsoleReader

java.lang.Object
jline.console.ConsoleReader
All Implemented Interfaces:
Closeable, AutoCloseable

public class ConsoleReader extends Object implements Closeable
A reader for console applications. It supports custom tab-completion, saveable command history, and command line editing. On some platforms, platform-specific commands will need to be issued before the reader will function properly. See Terminal.init() for convenience methods for issuing platform-specific setup commands.
  • Field Details

    • JLINE_NOBELL

      public static final String JLINE_NOBELL
      See Also:
    • JLINE_ESC_TIMEOUT

      public static final String JLINE_ESC_TIMEOUT
      See Also:
    • JLINE_INPUTRC

      public static final String JLINE_INPUTRC
      See Also:
    • INPUT_RC

      public static final String INPUT_RC
      See Also:
    • DEFAULT_INPUT_RC

      public static final String DEFAULT_INPUT_RC
      See Also:
    • JLINE_EXPAND_EVENTS

      public static final String JLINE_EXPAND_EVENTS
      See Also:
    • BACKSPACE

      public static final char BACKSPACE
      See Also:
    • RESET_LINE

      public static final char RESET_LINE
      See Also:
    • KEYBOARD_BELL

      public static final char KEYBOARD_BELL
      See Also:
    • NULL_MASK

      public static final char NULL_MASK
      See Also:
    • TAB_WIDTH

      public static final int TAB_WIDTH
      See Also:
    • resources

      private static final ResourceBundle resources
    • ESCAPE

      private static final int ESCAPE
      See Also:
    • READ_EXPIRED

      private static final int READ_EXPIRED
      See Also:
    • terminal

      private final Terminal2 terminal
    • out

      private final Writer out
    • buf

      private final CursorBuffer buf
    • cursorOk

      private boolean cursorOk
    • prompt

      private String prompt
    • promptLen

      private int promptLen
    • expandEvents

      private boolean expandEvents
    • bellEnabled

      private boolean bellEnabled
    • handleUserInterrupt

      private boolean handleUserInterrupt
    • handleLitteralNext

      private boolean handleLitteralNext
    • mask

      private Character mask
    • echoCharacter

      private Character echoCharacter
    • originalBuffer

      private CursorBuffer originalBuffer
    • searchTerm

      private StringBuffer searchTerm
    • previousSearchTerm

      private String previousSearchTerm
    • searchIndex

      private int searchIndex
    • parenBlinkTimeout

      private int parenBlinkTimeout
    • opBuffer

      private final StringBuilder opBuffer
    • pushBackChar

      private final Stack<Character> pushBackChar
    • in

    • escapeTimeout

      private long escapeTimeout
    • reader

      private Reader reader
    • charSearchChar

      private char charSearchChar
      Last character searched for with a vi character search
    • charSearchLastInvokeChar

      private char charSearchLastInvokeChar
    • charSearchFirstInvokeChar

      private char charSearchFirstInvokeChar
    • yankBuffer

      private String yankBuffer
      The vi yank buffer
    • killRing

      private KillRing killRing
    • encoding

      private String encoding
    • quotedInsert

      private boolean quotedInsert
    • recording

      private boolean recording
    • macro

      private String macro
    • appName

      private String appName
    • inputrcUrl

      private URL inputrcUrl
    • consoleKeys

      private ConsoleKeys consoleKeys
    • commentBegin

      private String commentBegin
    • skipLF

      private boolean skipLF
    • copyPasteDetection

      private boolean copyPasteDetection
      Set to true if the reader should attempt to detect copy-n-paste. The effect of this that an attempt is made to detect if tab is quickly followed by another character, then it is assumed that the tab was a literal tab as part of a copy-and-paste operation and is inserted as such.
    • state

      private ConsoleReader.State state
    • JLINE_COMPLETION_THRESHOLD

      public static final String JLINE_COMPLETION_THRESHOLD
      See Also:
    • completers

      private final List<Completer> completers
    • completionHandler

      private CompletionHandler completionHandler
    • autoprintThreshold

      private int autoprintThreshold
      The number of tab-completion candidates above which a warning will be prompted before showing all the candidates.
    • paginationEnabled

      private boolean paginationEnabled
    • history

      private History history
    • historyEnabled

      private boolean historyEnabled
    • LINE_SEPARATOR

      private static final String LINE_SEPARATOR
    • maskThread

      private Thread maskThread
  • Constructor Details

  • Method Details

    • setupSigCont

      private void setupSigCont()
    • getInputRc

      public static URL getInputRc() throws IOException
      Retrieve the URL for the inputrc configuration file in effect. Intended use is for instantiating ConsoleKeys, to read inputrc variables.
      Throws:
      IOException
    • getKeys

      public KeyMap getKeys()
    • setInput

      void setInput(InputStream in) throws IOException
      Throws:
      IOException
    • close

      public void close()
      Shuts the console reader down. This method should be called when you have completed using the reader as it shuts down and cleans up resources that would otherwise be "leaked".
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
    • shutdown

      @Deprecated public void shutdown()
      Deprecated.
      Use close() instead.
      Shuts the console reader down. The same as close().
    • finalize

      protected void finalize() throws Throwable
      Shuts down the ConsoleReader if the JVM attempts to clean it up.
      Overrides:
      finalize in class Object
      Throws:
      Throwable
    • getInput

      public InputStream getInput()
    • getOutput

      public Writer getOutput()
    • getTerminal

      public Terminal getTerminal()
    • getCursorBuffer

      public CursorBuffer getCursorBuffer()
    • setExpandEvents

      public void setExpandEvents(boolean expand)
    • getExpandEvents

      public boolean getExpandEvents()
    • setCopyPasteDetection

      public void setCopyPasteDetection(boolean onoff)
      Enables or disables copy and paste detection. The effect of enabling this this setting is that when a tab is received immediately followed by another character, the tab will not be treated as a completion, but as a tab literal.
      Parameters:
      onoff - true if detection is enabled
    • isCopyPasteDetectionEnabled

      public boolean isCopyPasteDetectionEnabled()
      Returns:
      true if copy and paste detection is enabled.
    • setBellEnabled

      public void setBellEnabled(boolean enabled)
      Set whether the console bell is enabled.
      Parameters:
      enabled - true if enabled; false otherwise
      Since:
      2.7
    • getBellEnabled

      public boolean getBellEnabled()
      Get whether the console bell is enabled
      Returns:
      true if enabled; false otherwise
      Since:
      2.7
    • setHandleUserInterrupt

      public void setHandleUserInterrupt(boolean enabled)
      Set whether user interrupts (ctrl-C) are handled by having JLine throw UserInterruptException from readLine(). Otherwise, the JVM will handle SIGINT as normal, which usually causes it to exit. The default is false.
      Since:
      2.10
    • getHandleUserInterrupt

      public boolean getHandleUserInterrupt()
      Get whether user interrupt handling is enabled
      Returns:
      true if enabled; false otherwise
      Since:
      2.10
    • setHandleLitteralNext

      public void setHandleLitteralNext(boolean handleLitteralNext)
      Set wether literal next are handled by JLine.
      Since:
      2.13
    • getHandleLitteralNext

      public boolean getHandleLitteralNext()
      Get wether literal next are handled by JLine.
      Since:
      2.13
    • setCommentBegin

      public void setCommentBegin(String commentBegin)
      Sets the string that will be used to start a comment when the insert-comment key is struck.
      Parameters:
      commentBegin - The begin comment string.
      Since:
      2.7
    • getCommentBegin

      public String getCommentBegin()
      Returns:
      the string that will be used to start a comment when the insert-comment key is struck.
      Since:
      2.7
    • setPrompt

      public void setPrompt(String prompt)
    • getPrompt

      public String getPrompt()
    • setEchoCharacter

      public void setEchoCharacter(Character c)
      Set the echo character. For example, to have "*" entered when a password is typed:
       myConsoleReader.setEchoCharacter(new Character('*'));
       
      Setting the character to null will restore normal character echoing.

      Setting the character to Character.valueOf(0) will cause nothing to be echoed.

      Parameters:
      c - the character to echo to the console in place of the typed character.
    • getEchoCharacter

      public Character getEchoCharacter()
      Returns the echo character.
    • resetLine

      protected final boolean resetLine() throws IOException
      Erase the current line.
      Returns:
      false if we failed (e.g., the buffer was empty)
      Throws:
      IOException
    • wcwidth

      int wcwidth(CharSequence str, int pos)
    • wcwidth

      int wcwidth(CharSequence str, int start, int end, int pos)
    • wcwidth

      int wcwidth(int ucs, int pos)
    • nextTabStop

      int nextTabStop(int pos)
    • getCursorPosition

      int getCursorPosition()
    • lastLine

      private static String lastLine(String str)
      Returns the text after the last '\n'. prompt is returned if no '\n' characters are present. null is returned if prompt is null.
    • setCursorPosition

      public boolean setCursorPosition(int position) throws IOException
      Move the cursor position to the specified absolute index.
      Throws:
      IOException
    • setBuffer

      private void setBuffer(String buffer) throws IOException
      Set the current buffer's content to the specified String. The visual console will be modified to show the current buffer.
      Parameters:
      buffer - the new contents of the buffer.
      Throws:
      IOException
    • setBuffer

      private void setBuffer(CharSequence buffer) throws IOException
      Throws:
      IOException
    • setBufferKeepPos

      private void setBufferKeepPos(String buffer) throws IOException
      Throws:
      IOException
    • setBufferKeepPos

      private void setBufferKeepPos(CharSequence buffer) throws IOException
      Throws:
      IOException
    • drawLine

      public void drawLine() throws IOException
      Output put the prompt + the current buffer
      Throws:
      IOException
    • redrawLine

      public void redrawLine() throws IOException
      Clear the line and redraw it.
      Throws:
      IOException
    • finishBuffer

      final String finishBuffer() throws IOException
      Clear the buffer and add its contents to the history.
      Returns:
      the former contents of the buffer.
      Throws:
      IOException
    • expandEvents

      protected String expandEvents(String str) throws IOException
      Expand event designator such as !!, !#, !3, etc... See http://www.gnu.org/software/bash/manual/html_node/Event-Designators.html
      Throws:
      IOException
    • putString

      public void putString(CharSequence str) throws IOException
      Write out the specified string to the buffer and the output stream.
      Throws:
      IOException
    • drawBuffer

      private void drawBuffer(int clear) throws IOException
      Redraw the rest of the buffer from the cursor onwards. This is necessary for inserting text into the buffer.
      Parameters:
      clear - the number of characters to clear after the end of the buffer
      Throws:
      IOException
    • drawBuffer

      private void drawBuffer() throws IOException
      Redraw the rest of the buffer from the cursor onwards. This is necessary for inserting text into the buffer.
      Throws:
      IOException
    • clearAhead

      private void clearAhead(int num, int pos) throws IOException
      Clear ahead the specified number of characters without moving the cursor.
      Parameters:
      num - the number of characters to clear
      pos - the current screen cursor position
      Throws:
      IOException
    • back

      protected void back(int num) throws IOException
      Move the visual cursor backward without modifying the buffer cursor.
      Throws:
      IOException
    • flush

      public void flush() throws IOException
      Flush the console output stream. This is important for printout out single characters (like a backspace or keyboard) that we want the console to handle immediately.
      Throws:
      IOException
    • backspaceAll

      private int backspaceAll() throws IOException
      Throws:
      IOException
    • backspace

      private int backspace(int num) throws IOException
      Issue num backspaces.
      Returns:
      the number of characters backed up
      Throws:
      IOException
    • backspace

      public boolean backspace() throws IOException
      Issue a backspace.
      Returns:
      true if successful
      Throws:
      IOException
    • moveToEnd

      protected boolean moveToEnd() throws IOException
      Throws:
      IOException
    • deleteCurrentCharacter

      private boolean deleteCurrentCharacter() throws IOException
      Delete the character at the current position and redraw the remainder of the buffer.
      Throws:
      IOException
    • viDeleteChangeYankToRemap

      private Operation viDeleteChangeYankToRemap(Operation op)
      This method is calling while doing a delete-to ("d"), change-to ("c"), or yank-to ("y") and it filters out only those movement operations that are allowable during those operations. Any operation that isn't allow drops you back into movement mode.
      Parameters:
      op - The incoming operation to remap
      Returns:
      The remaped operation
    • viRubout

      private boolean viRubout(int count) throws IOException
      Deletes the previous character from the cursor position
      Parameters:
      count - number of times to do it.
      Returns:
      true if it was done.
      Throws:
      IOException
    • viDelete

      private boolean viDelete(int count) throws IOException
      Deletes the character you are sitting on and sucks the rest of the line in from the right.
      Parameters:
      count - Number of times to perform the operation.
      Returns:
      true if its works, false if it didn't
      Throws:
      IOException
    • viChangeCase

      private boolean viChangeCase(int count) throws IOException
      Switches the case of the current character from upper to lower or lower to upper as necessary and advances the cursor one position to the right.
      Parameters:
      count - The number of times to repeat
      Returns:
      true if it completed successfully, false if not all case changes could be completed.
      Throws:
      IOException
    • viChangeChar

      private boolean viChangeChar(int count, int c) throws IOException
      Implements the vi change character command (in move-mode "r" followed by the character to change to).
      Parameters:
      count - Number of times to perform the action
      c - The character to change to
      Returns:
      Whether or not there were problems encountered
      Throws:
      IOException
    • viPreviousWord

      private boolean viPreviousWord(int count) throws IOException
      This is a close facsimile of the actual vi previous word logic. In actual vi words are determined by boundaries of identity characterse. This logic is a bit more simple and simply looks at white space or digits or characters. It should be revised at some point.
      Parameters:
      count - number of iterations
      Returns:
      true if the move was successful, false otherwise
      Throws:
      IOException
    • viDeleteTo

      private boolean viDeleteTo(int startPos, int endPos, boolean isChange) throws IOException
      Performs the vi "delete-to" action, deleting characters between a given span of the input line.
      Parameters:
      startPos - The start position
      endPos - The end position.
      isChange - If true, then the delete is part of a change operationg (e.g. "c$" is change-to-end-of line, so we first must delete to end of line to start the change
      Returns:
      true if it succeeded, false otherwise
      Throws:
      IOException
    • viYankTo

      private boolean viYankTo(int startPos, int endPos) throws IOException
      Implement the "vi" yank-to operation. This operation allows you to yank the contents of the current line based upon a move operation, for exaple "yw" yanks the current word, "3yw" yanks 3 words, etc.
      Parameters:
      startPos - The starting position from which to yank
      endPos - The ending position to which to yank
      Returns:
      true if the yank succeeded
      Throws:
      IOException
    • viPut

      private boolean viPut(int count) throws IOException
      Pasts the yank buffer to the right of the current cursor position and moves the cursor to the end of the pasted region.
      Parameters:
      count - Number of times to perform the operation.
      Returns:
      true if it worked, false otherwise
      Throws:
      IOException
    • viCharSearch

      private boolean viCharSearch(int count, int invokeChar, int ch) throws IOException
      Searches forward of the current position for a character and moves the cursor onto it.
      Parameters:
      count - Number of times to repeat the process.
      ch - The character to search for
      Returns:
      true if the char was found, false otherwise
      Throws:
      IOException
    • switchCase

      private static char switchCase(char ch)
    • isInViMoveOperationState

      private final boolean isInViMoveOperationState()
      Returns:
      true if line reader is in the middle of doing a change-to delete-to or yank-to.
    • viNextWord

      private boolean viNextWord(int count) throws IOException
      This is a close facsimile of the actual vi next word logic. As with viPreviousWord() this probably needs to be improved at some point.
      Parameters:
      count - number of iterations
      Returns:
      true if the move was successful, false otherwise
      Throws:
      IOException
    • viEndWord

      private boolean viEndWord(int count) throws IOException
      Implements a close facsimile of the vi end-of-word movement. If the character is on white space, it takes you to the end of the next word. If it is on the last character of a word it takes you to the next of the next word. Any other character of a word, takes you to the end of the current word.
      Parameters:
      count - Number of times to repeat the action
      Returns:
      true if it worked.
      Throws:
      IOException
    • previousWord

      private boolean previousWord() throws IOException
      Throws:
      IOException
    • nextWord

      private boolean nextWord() throws IOException
      Throws:
      IOException
    • unixWordRubout

      private boolean unixWordRubout(int count) throws IOException
      Deletes to the beginning of the word that the cursor is sitting on. If the cursor is on white-space, it deletes that and to the beginning of the word before it. If the user is not on a word or whitespace it deletes up to the end of the previous word.
      Parameters:
      count - Number of times to perform the operation
      Returns:
      true if it worked, false if you tried to delete too many words
      Throws:
      IOException
    • insertComment

      private String insertComment(boolean isViMode) throws IOException
      Throws:
      IOException
    • viSearch

      private int viSearch(char searchChar) throws IOException
      Implements vi search ("/" or "?").
      Throws:
      IOException
    • setParenBlinkTimeout

      public void setParenBlinkTimeout(int timeout)
    • insertClose

      private void insertClose(String s) throws IOException
      Throws:
      IOException
    • viMatch

      private boolean viMatch() throws IOException
      Implements vi style bracket matching ("%" command). The matching bracket for the current bracket type that you are sitting on is matched. The logic works like so:
      Returns:
      true if it worked, false if the cursor was not on a bracket character or if there was no matching bracket.
      Throws:
      IOException
    • getBracketType

      private static int getBracketType(char ch)
      Given a character determines what type of bracket it is (paren, square, curly, or none).
      Parameters:
      ch - The character to check
      Returns:
      1 is square, 2 curly, 3 parent, or zero for none. The value will be negated if it is the closing form of the bracket.
    • deletePreviousWord

      private boolean deletePreviousWord() throws IOException
      Throws:
      IOException
    • deleteNextWord

      private boolean deleteNextWord() throws IOException
      Throws:
      IOException
    • capitalizeWord

      private boolean capitalizeWord() throws IOException
      Throws:
      IOException
    • upCaseWord

      private boolean upCaseWord() throws IOException
      Throws:
      IOException
    • downCaseWord

      private boolean downCaseWord() throws IOException
      Throws:
      IOException
    • transposeChars

      private boolean transposeChars(int count) throws IOException
      Performs character transpose. The character prior to the cursor and the character under the cursor are swapped and the cursor is advanced one character unless you are already at the end of the line.
      Parameters:
      count - The number of times to perform the transpose
      Returns:
      true if the operation succeeded, false otherwise (e.g. transpose cannot happen at the beginning of the line).
      Throws:
      IOException
    • isKeyMap

      public boolean isKeyMap(String name)
    • accept

      public String accept() throws IOException
      The equivalent of hitting <RET>. The line is considered complete and is returned.
      Returns:
      The completed line of text.
      Throws:
      IOException
    • abort

      private void abort() throws IOException
      Throws:
      IOException
    • moveCursor

      public int moveCursor(int num) throws IOException
      Move the cursor where characters.
      Parameters:
      num - If less than 0, move abs(where) to the left, otherwise move where to the right.
      Returns:
      The number of spaces we moved
      Throws:
      IOException
    • moveInternal

      private void moveInternal(int where) throws IOException
      Move the cursor where characters, without checking the current buffer.
      Parameters:
      where - the number of characters to move to the right or left.
      Throws:
      IOException
    • moveCursorFromTo

      private void moveCursorFromTo(int i0, int i1) throws IOException
      Throws:
      IOException
    • readCharacter

      public int readCharacter() throws IOException
      Read a character from the console.
      Returns:
      the character, or -1 if an EOF is received.
      Throws:
      IOException
    • readCharacter

      public int readCharacter(boolean checkForAltKeyCombo) throws IOException
      Read a character from the console. If boolean parameter is "true", it will check whether the keystroke was an "alt-" key combination, and if so add 1000 to the value returned. Better way...?
      Returns:
      the character, or -1 if an EOF is received.
      Throws:
      IOException
    • clearEcho

      private int clearEcho(int c) throws IOException
      Clear the echoed characters for the specified character code.
      Throws:
      IOException
    • readCharacter

      public int readCharacter(char... allowed) throws IOException
      Throws:
      IOException
    • readCharacter

      public int readCharacter(boolean checkForAltKeyCombo, char... allowed) throws IOException
      Throws:
      IOException
    • readBinding

      public Object readBinding(KeyMap keys) throws IOException
      Read from the input stream and decode an operation from the key map. The input stream will be read character by character until a matching binding can be found. Characters that can't possibly be matched to any binding will be discarded.
      Parameters:
      keys - the KeyMap to use for decoding the input stream
      Returns:
      the decoded binding or null if the end of stream has been reached
      Throws:
      IOException
    • getLastBinding

      public String getLastBinding()
    • readLine

      public String readLine() throws IOException
      Read the next line and return the contents of the buffer.
      Throws:
      IOException
    • readLine

      public String readLine(Character mask) throws IOException
      Read the next line with the specified character mask. If null, then characters will be echoed. If 0, then no characters will be echoed.
      Throws:
      IOException
    • readLine

      public String readLine(String prompt) throws IOException
      Throws:
      IOException
    • readLine

      public String readLine(String prompt, Character mask) throws IOException
      Read a line from the in InputStream, and return the line (without any trailing newlines).
      Parameters:
      prompt - The prompt to issue to the console, may be null.
      Returns:
      A line that is read from the terminal, or null if there was null input (e.g., CTRL-D was pressed).
      Throws:
      IOException
    • setKeyMap

      public boolean setKeyMap(String name)
      Sets the current keymap by name. Supported keymaps are "emacs", "vi-insert", "vi-move".
      Parameters:
      name - The name of the keymap to switch to
      Returns:
      true if the keymap was set, or false if the keymap is not recognized.
    • getKeyMap

      public String getKeyMap()
      Returns the name of the current key mapping.
      Returns:
      the name of the key mapping. This will be the canonical name of the current mode of the key map and may not reflect the name that was used with setKeyMap(String).
    • readLine

      public String readLine(String prompt, Character mask, String buffer) throws IOException
      Read a line from the in InputStream, and return the line (without any trailing newlines).
      Parameters:
      prompt - The prompt to issue to the console, may be null.
      Returns:
      A line that is read from the terminal, or null if there was null input (e.g., CTRL-D was pressed).
      Throws:
      IOException
    • readLineSimple

      private String readLineSimple() throws IOException
      Read a line for unsupported terminals.
      Throws:
      IOException
    • addCompleter

      public boolean addCompleter(Completer completer)
      Add the specified Completer to the list of handlers for tab-completion.
      Parameters:
      completer - the Completer to add
      Returns:
      true if it was successfully added
    • removeCompleter

      public boolean removeCompleter(Completer completer)
      Remove the specified Completer from the list of handlers for tab-completion.
      Parameters:
      completer - The Completer to remove
      Returns:
      True if it was successfully removed
    • getCompleters

      public Collection<Completer> getCompleters()
      Returns an unmodifiable list of all the completers.
    • setCompletionHandler

      public void setCompletionHandler(CompletionHandler handler)
    • getCompletionHandler

      public CompletionHandler getCompletionHandler()
    • complete

      protected boolean complete() throws IOException
      Use the completers to modify the buffer with the appropriate completions.
      Returns:
      true if successful
      Throws:
      IOException
    • printCompletionCandidates

      protected void printCompletionCandidates() throws IOException
      Throws:
      IOException
    • setAutoprintThreshold

      public void setAutoprintThreshold(int threshold)
      Parameters:
      threshold - the number of candidates to print without issuing a warning.
    • getAutoprintThreshold

      public int getAutoprintThreshold()
      Returns:
      the number of candidates to print without issuing a warning.
    • setPaginationEnabled

      public void setPaginationEnabled(boolean enabled)
      Whether to use pagination when the number of rows of candidates exceeds the height of the terminal.
    • isPaginationEnabled

      public boolean isPaginationEnabled()
      Whether to use pagination when the number of rows of candidates exceeds the height of the terminal.
    • setHistory

      public void setHistory(History history)
    • getHistory

      public History getHistory()
    • setHistoryEnabled

      public void setHistoryEnabled(boolean enabled)
      Whether or not to add new commands to the history buffer.
    • isHistoryEnabled

      public boolean isHistoryEnabled()
      Whether or not to add new commands to the history buffer.
    • moveHistory

      private boolean moveHistory(boolean next, int count) throws IOException
      Used in "vi" mode for argumented history move, to move a specific number of history entries forward or back.
      Parameters:
      next - If true, move forward
      count - The number of entries to move
      Returns:
      true if the move was successful
      Throws:
      IOException
    • moveHistory

      private boolean moveHistory(boolean next) throws IOException
      Move up or down the history tree.
      Throws:
      IOException
    • fmtPrint

      private int fmtPrint(CharSequence buff, int cursorPos) throws IOException
      Output the specified characters to the output stream without manipulating the current buffer.
      Throws:
      IOException
    • fmtPrint

      private int fmtPrint(CharSequence buff, int start, int end) throws IOException
      Throws:
      IOException
    • fmtPrint

      private int fmtPrint(CharSequence buff, int start, int end, int cursorPos) throws IOException
      Throws:
      IOException
    • print

      public void print(CharSequence s) throws IOException
      Output the specified string to the output stream (but not the buffer).
      Throws:
      IOException
    • println

      public void println(CharSequence s) throws IOException
      Throws:
      IOException
    • println

      public void println() throws IOException
      Output a platform-dependant newline.
      Throws:
      IOException
    • rawPrint

      final void rawPrint(int c) throws IOException
      Raw output printing
      Throws:
      IOException
    • rawPrint

      final void rawPrint(String str) throws IOException
      Throws:
      IOException
    • rawPrint

      private void rawPrint(char c, int num) throws IOException
      Throws:
      IOException
    • rawPrintln

      private void rawPrintln(String s) throws IOException
      Throws:
      IOException
    • delete

      public boolean delete() throws IOException
      Issue a delete.
      Returns:
      true if successful
      Throws:
      IOException
    • killLine

      public boolean killLine() throws IOException
      Kill the buffer ahead of the current cursor position.
      Returns:
      true if successful
      Throws:
      IOException
    • yank

      public boolean yank() throws IOException
      Throws:
      IOException
    • yankPop

      public boolean yankPop() throws IOException
      Throws:
      IOException
    • clearScreen

      public boolean clearScreen() throws IOException
      Clear the screen by issuing the ANSI "clear screen" code.
      Throws:
      IOException
    • beep

      public void beep() throws IOException
      Issue an audible keyboard bell.
      Throws:
      IOException
    • paste

      public boolean paste() throws IOException
      Paste the contents of the clipboard into the console buffer
      Returns:
      true if clipboard contents pasted
      Throws:
      IOException
    • addTriggeredAction

      public void addTriggeredAction(char c, ActionListener listener)
      Adding a triggered Action allows to give another curse of action if a character passed the pre-processing.

      Say you want to close the application if the user enter q. addTriggerAction('q', new ActionListener(){ System.exit(0); }); would do the trick.

    • printColumns

      public void printColumns(Collection<? extends CharSequence> items) throws IOException
      Output the specified Collection in proper columns.
      Throws:
      IOException
    • beforeReadLine

      private void beforeReadLine(String prompt, Character mask)
    • afterReadLine

      private void afterReadLine()
    • resetPromptLine

      public void resetPromptLine(String prompt, String buffer, int cursorDest) throws IOException
      Erases the current line with the existing prompt, then redraws the line with the provided prompt and buffer
      Parameters:
      prompt - the new prompt
      buffer - the buffer to be drawn
      cursorDest - where you want the cursor set when the line has been drawn. -1 for end of line.
      Throws:
      IOException
    • printSearchStatus

      public void printSearchStatus(String searchTerm, String match) throws IOException
      Throws:
      IOException
    • printForwardSearchStatus

      public void printForwardSearchStatus(String searchTerm, String match) throws IOException
      Throws:
      IOException
    • printSearchStatus

      private void printSearchStatus(String searchTerm, String match, String searchLabel) throws IOException
      Throws:
      IOException
    • restoreLine

      public void restoreLine(String originalPrompt, int cursorDest) throws IOException
      Throws:
      IOException
    • searchBackwards

      public int searchBackwards(String searchTerm, int startIndex)
      Search backward in history from a given position.
      Parameters:
      searchTerm - substring to search for.
      startIndex - the index from which on to search
      Returns:
      index where this substring has been found, or -1 else.
    • searchBackwards

      public int searchBackwards(String searchTerm)
      Search backwards in history from the current position.
      Parameters:
      searchTerm - substring to search for.
      Returns:
      index where the substring has been found, or -1 else.
    • searchBackwards

      public int searchBackwards(String searchTerm, int startIndex, boolean startsWith)
    • searchForwards

      public int searchForwards(String searchTerm, int startIndex)
      Search forward in history from a given position.
      Parameters:
      searchTerm - substring to search for.
      startIndex - the index from which on to search
      Returns:
      index where this substring has been found, or -1 else.
    • searchForwards

      public int searchForwards(String searchTerm)
      Search forwards in history from the current position.
      Parameters:
      searchTerm - substring to search for.
      Returns:
      index where the substring has been found, or -1 else.
    • searchForwards

      public int searchForwards(String searchTerm, int startIndex, boolean startsWith)
    • isDelimiter

      private static boolean isDelimiter(char c)
      Checks to see if the specified character is a delimiter. We consider a character a delimiter if it is anything but a letter or digit.
      Parameters:
      c - The character to test
      Returns:
      True if it is a delimiter
    • isWhitespace

      private static boolean isWhitespace(char c)
      Checks to see if a character is a whitespace character. Currently this delegates to Character.isWhitespace(char), however eventually it should be hooked up so that the definition of whitespace can be configured, as readline does.
      Parameters:
      c - The character to check
      Returns:
      true if the character is a whitespace
    • tputs

      private boolean tputs(String cap, Object... params) throws IOException
      Throws:
      IOException