/*
  File: In.java

  Iain Hewson

  January 2001
*/

package basicIO;

import java.io.*;
import java.util.*;

/**
 * This class was developed for use by 241 students in the first couple 
 * of labs. It provides quick access to Java's input classes without 
 * having to use the try-catch  mechanism. The drawback with this is that
 * methods like <code>getInt </code> simply exit without giving you any 
 * choice if an error is encountered which may not be what you want.
 * An error message will however be output to standard out.
 */
public class In {
    private static BufferedReader reader =
	new BufferedReader(new InputStreamReader(System.in));
    private static String lineSep = System.getProperty("line.separator");
    private static StringTokenizer tokenizedInput = new StringTokenizer("");
    private static String inputString = "";

    /** This class can not be instantiated */
    private In(){}


    /**
     * Read a line in from standard input.
     * @return the line which was read in.
     */
    public static String readLine() {
	inputString = null;
	tokenizedInput = new StringTokenizer("");

	try {
	    inputString = reader.readLine();
	} catch (IOException e) {
	    System.out.println("Error: " + e.getMessage());
	    System.exit(-1);
	}
	tokenizedInput = (inputString != null) ?
	    new StringTokenizer(inputString) :
	    new StringTokenizer("");

	return inputString;
    }


    /**
     * Read in lines from standard input until an EOF is received.
     * @return the lines which were read (not including the final newline).
     */
    public static String readLines() {
	String temp = "";
	inputString = null;
	tokenizedInput = new StringTokenizer("");

	try {
	    while ((temp = reader.readLine()) != null) {
		inputString = (inputString != null) ?
		    inputString + lineSep + temp :
		    temp;
	    }
	} catch (IOException e) {
	    System.out.println("Error: " + e.getMessage());
	    System.exit(-1);
	}
	tokenizedInput = (inputString != null) ?
	    new StringTokenizer(inputString) :
	    new StringTokenizer("");

	return inputString;
    }


    /**
     * Get the last line(s) of input read using class In
     * @return the last line(s) of input read.
     */
    public static String getLast() {
	return inputString;
    }


    /**
     * Tells if the most recently read input has any more tokens left
     * to retrieve.
     * @return if there are tokens left. 
     */
    public static boolean hasMoreTokens() {
	return tokenizedInput.hasMoreTokens();
    }


    /**
     * Tells how many tokens the most recently read input has left
     * to be retrieved.
     * @return the number of unretrieved tokens
     */
    public static int countTokens() {
	return tokenizedInput.countTokens();
    }


    /**
     * Retrieves the next token in the most recently read input
     * and moves forward to the following token. If there are no
     * more tokens to retrieve and error message is displayed and
     * the string "Error" is returned.
     * @return the next token.
     */
    public static String nextToken() {
	try {
	    return tokenizedInput.nextToken();
	} catch (NoSuchElementException e) {
	    System.out.println("Error: no more tokens to get.");
	    System.exit(-1);
	    return "This shouldn't be reached";
	}
    }


    /**
     * Retrieves the next token in the most recently read input
     * but doesn't move forward to the following token. If there are no
     * more tokens to retrieve an error message is displayed and the
     * program exits.
     * @return the next token.
     */
    public static String peekToken() {
	String result = "";
	String tempStr = "";

	if (tokenizedInput.hasMoreTokens()) {
	    result = tokenizedInput.nextToken();
	}
	tempStr = result;
	while (tokenizedInput.hasMoreTokens()) {
	    tempStr += " " + tokenizedInput.nextToken();
	}
	tokenizedInput = new StringTokenizer(tempStr);
	if (tokenizedInput.hasMoreTokens()) {
	    return result;
	} else {
	    System.out.println("Error: no more tokens to get.");
	    System.exit(-1);
	    return "This shouldn't be reached";
	}
    }


    /**
     * Read the next token from the most recently read input as an int.
     * If it can be parsed as an int then return the result.
     * If an error occurs an error message is printed and the program exits.
     * @return the next token as an int
     */
    public static int getInt() {
	int result = -1;
	try {
	    result = Integer.parseInt(nextToken());
	} catch (NumberFormatException e) {
	    System.out.println("Error: " + e.getMessage() +
			       " is not a valid integer");
	    System.exit(-1);
	}
	return result;
    }


    /**
     * Read the next token from the most recently read input as a long.
     * If it can be parsed as a long then return the result.
     * If an error occurs an error message is printed and the program exits.
     * @return the next token as a long
     */
    public static long getLong() {
	long result = -1;
	try {
	    result = Long.parseLong(nextToken());
	} catch (NumberFormatException e) {
	    System.out.println("Error: " + e.getMessage() +
			       " is not a valid long integer");
	    System.exit(-1);
	}
	return result;
    }


    /**
     * Read the next token from the most recently read input as a float.
     * If it can be parsed as a float then return the result.
     * If an error occurs an error message is printed and the program exits.
     * @return the next token as a float.
     * /
    public static float getFloat() {
	float result = -1;
	try {
	    result = Float.parseFloat(nextToken());
	} catch (NumberFormatException e) {
	    System.out.println("Error: " + e.getMessage() +
			       " is not a valid float");
	    System.exit(-1);
	}
	return result;
    }


    /**
     * Read the next token from the most recently read input as a double.
     * If it can be parsed as a double then return the result.
     * If an error occurs an error message is printed and the program exits.
     * @return the next token as a double.
     * /
    public static double getDouble() {
	double result = -1;
	try {
	    result = Double.parseDouble(nextToken());
	} catch (NumberFormatException e) {
	    System.out.println("Error: " + e.getMessage() +
			       " is not a valid double");
	    System.exit(-1);
	}
	return result;
	}*/
}