package cs1;

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