/** * The `StdIn` class provides static methods for reading strings * and numbers from standard input. * These functions fall into one of four categories: * *

* Generally, it is best not to mix functions from the different * categories in the same program. *

* Getting started. * To use this class, you must have `StdIn.class` in your * Java classpath. If you used our autoinstaller, you should be all set. * Otherwise, either download * stdlib.jar * and add to your Java classpath or download * StdIn.java * and put a copy in your working directory. *

* Reading tokens from standard input and converting to numbers and strings. * You can use the following methods to read numbers, strings, and booleans * from standard input one at a time: *

*

* The first method returns true if standard input has no more tokens. * Each other method skips over any input that is whitespace. Then, it reads * the next token and attempts to convert it into a value of the specified * type. If it succeeds, it returns that value; otherwise, it * throws an {@link InputMismatchException}. *

* Whitespace includes spaces, tabs, and newlines; the full definition * is inherited from {@link Character#isWhitespace(char)}. * A token is a maximal sequence of non-whitespace characters. * The precise rules for describing which tokens can be converted to * integers and floating-point numbers are inherited from * Scanner, * using the locale {@link Locale#US}; the rules * for floating-point numbers are slightly different * from those in {@link Double#valueOf(String)}, * but unlikely to be of concern to most programmers. *

* As an example, the following code fragment reads integers from standard input, * one at a time, and prints them one per line. * 

 * while (!StdIn.isEmpty()) {
 * double value = StdIn.readDouble();
 * StdOut.println(value);
 * }
 *
*

* Reading characters from standard input. * You can use the following two methods to read characters from standard input one at a time: *

*

* The first method returns true if standard input has more input (including whitespace). * The second method reads and returns the next character of input on standard * input (possibly a whitespace character). *

* As an example, the following code fragment reads characters from standard input, * one character at a time, and prints it to standard output. * 

 * while (StdIn.hasNextChar()) {
 * char c = StdIn.readChar();
 * StdOut.print(c);
 * }
 *
*

* Reading lines from standard input. * You can use the following two methods to read lines from standard input: *

*

* The first method returns true if standard input has more input (including whitespace). * The second method reads and returns the remaining portion of * the next line of input on standard input (possibly whitespace), * discarding the trailing line separator. *

* A line separator is defined to be one of the following strings: * `\n` (Linux), `\r` (old Macintosh), * `\r\n` (Windows), * `\}`u2028`, `\}`u2029`, or `\``u0085`. *

* As an example, the following code fragment reads text from standard input, * one line at a time, and prints it to standard output. * 

 * while (StdIn.hasNextLine()) {
 * String line = StdIn.readLine();
 * StdOut.println(line);
 * }
 *
*

* Reading a sequence of values of the same type from standard input. * You can use the following methods to read a sequence numbers, strings, * or booleans (all of the same type) from standard input: *

*

* The first three methods read of all of remaining token on standard input * and converts the tokens to values of * the specified type, as in the corresponding * `readDouble`, `readInt`, and `readString()` methods. * The `readAllLines()` method reads all remaining lines on standard * input and returns them as an array of strings. * The `readAll()` method reads all remaining input on standard * input and returns it as a string. *

* As an example, the following code fragment reads all of the remaining * tokens from standard input and returns them as an array of strings. * 

 * String[] words = StdIn.readAllStrings();
 *
*

* Differences with Scanner. * `StdIn` and {@link Scanner} are both designed to parse * tokens and convert them to primitive types and strings. * The main differences are summarized below: *

*

* Historical note: `StdIn` preceded `Scanner`; when * `Scanner` was introduced, this class was re-implemented to use `Scanner`. *

* Using standard input. * Standard input is a fundamental operating system abstraction on Mac OS X, * Windows, and Linux. * The methods in `StdIn` are blocking, which means that they * will wait until you enter input on standard input. * If your program has a loop that repeats until standard input is empty, * you must signal that the input is finished. * To do so, depending on your operating system and IDE, * use either `` or ``, on its own line. * If you are redirecting standard input from a file, you will not need * to do anything to signal that the input is finished. *

* Known bugs. * Java's UTF-8 encoding does not recognize the optional * byte-order mask. * If the input begins with the optional byte-order mask, `StdIn` * will have an extra character `\``uFEFF` at the beginning. *

* Reference. * For additional documentation, * see Section 1.5 of * Computer Science: An Interdisciplinary Approach * by Robert Sedgewick and Kevin Wayne. * */ export default class StdIn { private static rl; private static doesStreamEnd; private static inputLines; private static nextIndex; private static _initialize; static init(fileName?: string): void; /** * Returns true if standard input is empty (except possibly for whitespace). * Use this method to know whether the next call to {@link #readString()}, * {@link #readDouble()}, etc will succeed. * * @return `true` if standard input is empty (except possibly * for whitespace); `false` otherwise */ static isEmpty(): boolean; /** * Returns true if standard input has a next line. * Use this method to know whether the * next call to {@link #readLine()} will succeed. * This method is functionally equivalent to {@link #hasNextChar()}. * * @return `true` if standard input has more input (including whitespace); * `false` otherwise */ static hasNextLine(): boolean; /** * Returns true if standard input has more input (including whitespace). * Use this method to know whether the next call to {@link #readChar()} will succeed. * This method is functionally equivalent to {@link #hasNextLine()}. * * `false` otherwise */ static hasNextChar(): void; /** * Reads and returns the next line, excluding the line separator if present. * * @return the next line, excluding the line separator if present; * `null` if no such line */ static readLine(): Promise; /** * Reads and returns the next character. * @deprecated * * @return the next `char` * @throws Error if standard input is empty */ static readChar(): string; /** * Reads and returns the remainder of the input, as a string. * * @return the remainder of the input, as a string * @throws Error if standard input is empty */ static readAll(): Promise; /** * Reads the next token and returns the `String`. * @return the next `String` * @throws Error if standard input is empty */ static readString(): Promise; /** * Reads the next token from standard input, parses it as an integer, and returns the integer. * @return the next integer on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as an `int` */ static readInt(): Promise; /** * Reads the next token from standard input, parses it as a double, and returns the double. * @deprecated * @return the next double on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as a `double` */ static readDouble(): Promise; /** * Reads the next token from standard input, parses it as a float, and returns the float. * * @return the next float on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as a `float` */ static readFloat(): Promise; /** * Reads the next token from standard input, parses it as a long integer, and returns the long integer. * * @return the next long integer on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as a `long` */ static readLong(): Promise; /** * Reads the next token from standard input, parses it as a short integer, and returns the short integer. * * @return the next short integer on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as a `short` */ static readShort(): Promise; /** * Reads the next token from standard input, parses it as a byte, and returns the byte. * * @return the next byte on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as a `byte` */ static readByte(): Promise; /** * Reads the next token from standard input, parses it as a boolean, * and returns the boolean. * * @return the next boolean on standard input * @throws Error if standard input is empty * @throws InputMismatchException if the next token cannot be parsed as a `boolean`: * `true` or `1` for true, and `false` or `0` for false, * ignoring case */ static readBoolean(): boolean; /** * Reads all remaining tokens from standard input and returns them as an array of strings. * * @return all remaining tokens on standard input, as an array of strings */ static readAllStrings(): Promise; /** * Reads all remaining lines from standard input and returns them as an array of strings. * @return all remaining lines on standard input, as an array of strings */ static readAllLines(): Promise; /** * Reads all remaining tokens from standard input, parses them as integers, and returns * them as an array of integers. * @return all remaining integers on standard input, as an array * @throws InputMismatchException if any token cannot be parsed as an `int` */ static readAllInts(): Promise; /** * Reads all remaining tokens from standard input, parses them as longs, and returns * them as an array of longs. * @return all remaining longs on standard input, as an array * @throws InputMismatchException if any token cannot be parsed as a `long` */ static readAllLongs(): Promise; /** * Reads all remaining tokens from standard input, parses them as doubles, and returns * them as an array of doubles. * @return all remaining doubles on standard input, as an array * @throws InputMismatchException if any token cannot be parsed as a `double` */ static readAllDoubles(): Promise; /** * Reads all remaining tokens, parses them as integers, and returns * them as an array of integers. * @return all remaining integers, as an array * @throws InputMismatchException if any token cannot be parsed as an `int` * @deprecated Replaced by {@link #readAllInts()}. */ static readInts(): Promise; /** * Reads all remaining tokens, parses them as doubles, and returns * them as an array of doubles. * @return all remaining doubles, as an array * @throws InputMismatchException if any token cannot be parsed as a `double` * @deprecated Replaced by {@link #readAllDoubles()}. */ static readDoubles(): Promise; /** * Reads all remaining tokens and returns them as an array of strings. * @return all remaining tokens, as an array of strings * @deprecated Replaced by {@link #readAllStrings()}. */ static readStrings(): Promise; }