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

// Keyboard.java Author: Lewis and Loftus

//

// 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;

}

}