package cs1;

//********************************************************************
// Keyboard.java Author: Saniya Khan, Shweta Kumar & Preeti Benarjee
//
// 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;
}
}

Thanks in advance
Shonali

It seems that you have omitted some code. Pls tell me the error msg u got during compilation.

--Monika--

"I can't compile the code" in the sense....??? wht error u r getting if u say compile???? can u give me the detail?

shall we close the thread?