package APCS;

//********************************************************************

// Keyboard.java

// Authors: John Lewis and William Loftus

// From: Java Software Solutions

// Facilitates keyboard input by abstracting details about input

// parsing, conversions, and exception handling.

//********************************************************************

import java.io.*;

import java.util.*;

public class Keyboard

{

//************* Error Handling Section **************************

private static boolean printErrors = true;

private static int errorCount = 0;

//-----------------------------------------------------------------

// Returns the current error count.

//-----------------------------------------------------------------

public static int getErrorCount()

{

return errorCount;

}

//-----------------------------------------------------------------

// Resets the current error count to zero.

//-----------------------------------------------------------------

public static void resetErrorCount (int count)

{

errorCount = 0;

}

//-----------------------------------------------------------------

// Returns a boolean indicating whether input errors are

// currently printed to standard output.

//-----------------------------------------------------------------

public static boolean getPrintErrors()

{

return printErrors;

}

//-----------------------------------------------------------------

// Sets a boolean indicating whether input errors are to be

// printed to standard output.

//-----------------------------------------------------------------

public static void setPrintErrors (boolean flag)

{

printErrors = flag;

}

//-----------------------------------------------------------------

// Increments the error count and prints the error message if

// appropriate.

//-----------------------------------------------------------------

private static void error (String str)

{

errorCount++;

if (printErrors)

System.out.println (str);

}

//************* Tokenized Input Stream Section ******************

private static String current_token = null;

private static StringTokenizer reader;

private static BufferedReader in = new BufferedReader (new InputStreamReader(System.in));

//-----------------------------------------------------------------

// Gets the next input token assuming it may be on subsequent

// input lines.

//-----------------------------------------------------------------

private static String getNextToken()

{

return getNextToken (true);

}

//-----------------------------------------------------------------

// Gets the next input token, which may already have been read.

//-----------------------------------------------------------------

private static String getNextToken (boolean skip)

{

String token;

if (current_token == null)

token = getNextInputToken (skip);

else

{

token = current_token;

current_token = null;

}

return token;

}

//-----------------------------------------------------------------

// Gets the next token from the input, which may come from the

// current input line or a subsequent one. The parameter

// determines if subsequent lines are used.

//-----------------------------------------------------------------

private static String getNextInputToken (boolean skip)

{

final String delimiters = " \t\n\r\f";

String token = null;

try

{

if (reader == null)

reader = new StringTokenizer (in.readLine(), delimiters, true);

while (token == null || ((delimiters.indexOf (token) >= 0) && skip))

{

while (!reader.hasMoreTokens())

reader = new StringTokenizer (in.readLine(), delimiters,true);

token = reader.nextToken();

}

}

catch (Exception exception)

{

token = null;

}

return token;

}

//-----------------------------------------------------------------

// Returns true if there are no more tokens to read on the

// current input line.

//-----------------------------------------------------------------

public static boolean endOfLine()

{

return !reader.hasMoreTokens();

}

//************* Reading Section *********************************

//-----------------------------------------------------------------

// Returns a string read from standard input.

//-----------------------------------------------------------------

public static String readString()

{

String str;

try

{

str = getNextToken(false);

while (! endOfLine())

{

str = str + getNextToken(false);

}

}

catch (Exception exception)

{

error ("Error reading String data, null value returned.");

str = null;

}

return str;

}

//-----------------------------------------------------------------

// Returns a space-delimited substring (a word) read from

// standard input.

//-----------------------------------------------------------------

public static String readWord()

{

String token;

try

{

token = getNextToken();

}

catch (Exception exception)

{

error ("Error reading String data, null value returned.");

token = null;

}

return token;

}

//-----------------------------------------------------------------

// Returns a boolean read from standard input.

//-----------------------------------------------------------------

public static boolean readBoolean()

{

String token = getNextToken();

boolean bool;

try

{

if (token.toLowerCase().equals("true"))

bool = true;

else if (token.toLowerCase().equals("false"))

bool = false;

else

{

error ("Error reading boolean data, false value returned.");

bool = false;

}

}

catch (Exception exception)

{

error ("Error reading boolean data, false value returned.");

bool = false;

}

return bool;

}

//-----------------------------------------------------------------

// Returns a character read from standard input.

//-----------------------------------------------------------------

public static char readChar()

{

String token = getNextToken(false);

char value;

try

{

if (token.length() > 1)

{

current_token = token.substring (1, token.length());

}

else

current_token = null;

value = token.charAt (0);

}

catch (Exception exception)

{

error ("Error reading char data, MIN_VALUE value returned.");

value = Character.MIN_VALUE;

}

return value;

}

//-----------------------------------------------------------------

// Returns an integer read from standard input.

//-----------------------------------------------------------------

public static int readInt()

{

String token = getNextToken();

int value;

try

{

value = Integer.parseInt (token);

}

catch (Exception exception)

{

error ("Error reading int data, MIN_VALUE value returned.");

value = Integer.MIN_VALUE;

}

return value;

}

//-----------------------------------------------------------------

// Returns a long integer read from standard input.

//-----------------------------------------------------------------

public static long readLong()

{

String token = getNextToken();

long value;

try

{

value = Long.parseLong (token);

}

catch (Exception exception)

{

error ("Error reading long data, MIN_VALUE value returned.");

value = Long.MIN_VALUE;

}

return value;

}

//-----------------------------------------------------------------

// Returns a float read from standard input.

//-----------------------------------------------------------------

public static float readFloat()

{

String token = getNextToken();

float value;

try

{

value = (new Float(token)).floatValue();

}

catch (Exception exception)

{

error ("Error reading float data, NaN value returned.");

value = Float.NaN;

}

return value;

}

//-----------------------------------------------------------------

// Returns a double read from standard input.

//-----------------------------------------------------------------

public static double readDouble()

{

String token = getNextToken();

double value;

try

{

value = (new Double(token)).doubleValue();

}

catch (Exception exception)

{

error ("Error reading double data, NaN value returned.");

value = Double.NaN;

}

return value;

}

}//end class