package iutsud ;

import java.io.BufferedReader ;
import java.io.InputStreamReader ;

/**
 *	Cette classe fournit des méthodes simples pour lire les types
 *	de base sur l'entrée standard (au clavier).<p>
 *	La lecture est faite par des instructions du type : 
 *	<pre><code>		int 	i = Console.<b>readInt()</b> ; 
 *		double 	d = Console.<b>readDouble()</b> ; 
 *		char 	c = Console.<b>readChar()</b> ;
 *			...</code> </pre>
 *
 *	<li>Le principe général est de lire ligne par ligne et de ne traiter
 *  qu'une seule donnée par ligne.
 *  <li>En cas d'erreur le programme est arrêté en levant une exception  ;
 *	il affiche alors un message d'erreur ainsi que le contenu de la pile d'exécution.
 *	<li>L'introduction d'une ligne vide provoque une erreur sauf pour <code>readChar()</code>
 *	qui renvoie le caractère de fin de ligne <code>'\n'</code>, et sauf pour <code>readLine()</code>
 *	qui renvoie la chaîne vide.
 *	<li>La rencontre de la fin de fichier (Ctrl-D au clavier) est généralement
 *	considérée comme une erreur sauf pour <code>readLine()</code> qui renvoie <code>null</code>.
 *  <p>
 *	Le point de départ a été la classe <code>sdsu.io.Console</code> de l'université
 *	de San Diego (<a href="http://www.eli.sdsu.edu/java-SDSU">http://www.eli.sdsu.edu/java-SDSU</a>).
 *	Cette classe a été simplifiée pour répondre à nos besoins particuliers pour 
 *	l'enseignement de l'introduction à l'algorithmique.
 *	Le code a été entièrement remanié pour utiliser les fonctions de 
 *	conversion du langage Java.
 *	Des améliorations pourraient certainement y être apportées en utilisant
 *	la classe <code>Number</code> notamment pour les problèmes d'internationalisation,
 *	liés à l'écriture des nombres en <b>virgule</b> flottante.
 *  <p> 
 *	
 *		<b>Utilisation</b> : <p>
 *		<li>Le fichier <code>Console.class</code> se trouve sous le répertoire
 *		<code>/usr/local/lib/java/iutsud</code>.
 *		<li>La variable <code>CLASSPATH</code> doit contenir
 *		<code>/usr/local/lib/java</code>. Sur <i>sterne</i> elle est initialisée
 *		automatiquement au démarrage de la session avec cette valeur.
 *		<li>Les classes utilisatrices doivent importer la classe
 *		<code>Console</code> depuis le package <code>iutsud</code> par l'instruction 
 *		<code>import iutsud.Console</code>
 *	
 *
 * <p>Le document de présentation peut être généré depuis le source par la commande : <br>
 *	<code> javadoc -version -author iutsud</code>
 * @author Raymond Schneider 
 * (<a href=mailto:Raymond.Schneider@iutsud.u-strasbg.fr>Raymond.Schneider@iutsud.u-strasbg.fr</a>)
 * @version version 0.1 17/07/98
 */
 
public class Console {

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


    private static void main(String args[]) {

	while (true) {
	
		System.out.print( "Print a Base ");
		int base = Console.readInt() ;
		System.out.print( "Print a Long in base " + base +  " : ") ;
		long lb = Console.readLong(base) ;
		System.out.println( "You typed: " + lb );

		System.out.print( "Print a Byte ");
		byte k = Console.readByte() ;
		System.out.println( "You typed: " + k );

		System.out.print( "Print a Short ");
		int j = Console.readShort() ;
		System.out.println( "You typed: " + j );

		System.out.print( "Print a Int ");
		int i = Console.readInt() ;
		System.out.println( "You typed: " + i );

		System.out.print( "Print a Long ");
		long l = Console.readLong() ;
		System.out.println( "You typed: " + l );

		System.out.print( "Print a Float ");
		float f = Console.readFloat() ;
		System.out.println( "You typed: " + f );

		System.out.print( "Print a Double ");
		double d = Console.readDouble() ;
		System.out.println( "You typed: " + d );
	
		System.out.print( "Print a Boolean ");
		boolean b = Console.readBoolean() ;
		System.out.println( "You typed: " + b );

		System.out.print( "Print a Char ");
		char c = Console.readChar() ;		
		System.out.println( "You typed: " + c ); 
		}
    }
	
	private Console()
	{
		super() ;
	}
	
	/**
	 *	Exception levée lors d'une erreur de lecture
	 */
 
	public static class ReadException extends RuntimeException	
	{
		public ReadException(String message)
		{
			super(message) ;
		}
	}	// end class ReadException
	
	/**
	 *	Exception levée lors d'une erreur de conversion
	 */
 
	public static class ConvertionException extends RuntimeException	
	{
		public ConvertionException(String message)
		{
			super(message) ;
		}
	}	// end class ConvertionException 
	
   
    /**
	 *	Quitte le programme en levant l'exception e 
	 *	Le système afficheraé le message d'erreur associé
	 *	ainsi que la pile d'ecxécution
	 *	@param	e	l'exception à lever
	 */
	 		
	/*
     * Exits programs after throwing an exception 
     * @param	e	exception to be thrown
     */
	 
	static final void exitProgram( RuntimeException e ) 
		{
		throw e ;
		}
		
    /**
	 *	Quitte le programme suite à une erreur de conversion ;
	 * 	affiche un message d'erreur en levant l'exception
	 *	<code>Console.ConvertionException</code> 
	 *	@param	s			la chaîne à convertir
	 *	@param	t			le type vers lequel il fallait convertir
	 */
	 
    /*
     * Exits programs after displaying a conversion error message 
     * and after dumping the Thread's stack
     * @param	s		String that could not be converted
     * @param	t		Conversion Destination Type 
     */
		
	private static final void conversionError( String s , String t )
		{
		exitProgram( new ConvertionException( 
							conversionErrorMessage( s , t ) ) ) ;
		}
		
    /**
	 *	Quitte le programme suite à une erreur de lecture ;
	 * 	affiche un message d'erreur en levant l'exception
	 *	<code>Console.ReadException</code> 
	 *	@param	s			la raison de l'erreur à afficher
	 *	@param	t			le type lu
	 */
	 
    /*
     * Exits programs after displaying a conversion error message 
     * and after dumping the Thread's stack
     * @param	s		the error cause
     * @param	t		Read Destination Type 
     */
		
	private static final void readError( String s , String t )
		{
		exitProgram( new ReadException ( s + " lors de la lecture d'un " + t) );
		}
		
    /**
	 *	Compose le message d'erreur à afficher suite à une erreur de conversion ;
	 *	@param	s			la chaîne à convertir
	 *	@param	t			le type vers lequel il fallait convertir
	 */
	 
    /*
     * Bulids a conversion error message 
     * @param	s		String that could not be converted
     * @param	t		Conversion Destination Type 
     */
		
	private static String conversionErrorMessage( String s, String t )
		{
		return  '"' + s + '"' + " ne peut être convertie en " + t ;
		}
		
    // Input methods ----------------------------------------------------

    /**
     * Lit une valeur booléenne dans une ligne.
     * Lit une ligne et détermine si elle représente <code>true</code> ou <code>false</code>.  
	 * Les valeurs possibles sont : <i>true</i> and <i>false</i>,
     * 								<i>vrai</i> and <i>faux</i>.
     * La comparaison est insensible à la casse (majuscule, minuscule).
	 *
     * Le programme stoppe en cas d'erreur de lecture ou en fin de fichier
     * @return la valeur booléene correspondante.
     */
	 
    /*
     * Reads an ASCII boolean value.
     * It reads a word and determines if it represents <code>true</code> or
     * <code>false</code>.  Possible values are: <i>true</i> and <i>false</i>,
     * <i>vrai</i> and <i>faux</i>.
     * The comparison is case insensitive.
     * Program exits on read errors or EOF
     * @return the boolean.
     */
	 
public static boolean readBoolean()
{
boolean b = false ;
String s ;
	
	s= readLine("boolean") ;
	
	if (s.equalsIgnoreCase(String.valueOf(false))
		|| s.equalsIgnoreCase("faux") )
		b= false;
	
	else if (s.equalsIgnoreCase(String.valueOf(true))
		|| s.equalsIgnoreCase("vrai") )
		b= true;
	
	else
		conversionError( s , "boolean" ) ;
	
	return b;

}	// end readBoolean

    /**
     * Lit un caractère dans une ligne.
	 * La ligne lue doit contenir au maximum un caractère. 
	 * Si la ligne est vide le caractère <code>'\n'</code> est renvoyé. 
     * 
     * Le programme stoppe en cas d'erreur de lecture ou en fin de fichier 
	 * ou encore si la ligne contenait plusieurs caractères.
     * @return le caractère lu ou <code>'\n'</code> si la ligne était vide.
     */

    /*
     * Reads one ASCII character and convert it into the internal <code>char</code>
     * format. If the line is empty <code>'\n'</code> is returned. 
	 * If more than one character are available in the line, only the first one is returned ; all other are
     * ignored.
     * Program exits on read errors or EOF or if more characters are available
     * @return the character or <code>'\n'</code> if line was empty.
     */
     
public static char readChar()
{
String s ;
char c = '\n' ;
	
	s= readNewLine("char");
	
	if (s.length() == 1)
		c= s.charAt(0);
	else if ( s.length()  != 0 )
		exitProgram( new ReadException( 
						"La ligne lue contenait plus d'un caractère : " 
							+ '"' + s + '"' + '\n' )
					);	
	
	return c ;
	
}

    /**
     * Lit un nombre en virgule flottante et en double précision dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>double</code> en Java et permettre la conversion par :
     * 		<code>Double(String).doubleValue()</code>
	 * Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
     * 
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @return la valeur <code>double</code> correspondante.
     */

    /*
     * Reads an ASCII decimal floating point number.
     * A floating point number should obey Java String conversion :
     * 		<code>Double(String).doubleValue()</code>
     * Program exits on read errors or EOF
     * @return the double.
     */
    
public static double readDouble()
{
String s ;
double d = 0.0 ;

	s= readLine("double");
		
	try
		{
		d = new Double(s).doubleValue() ;
		}
	catch (NumberFormatException e)
		{
		conversionError( s, "double");
		}
		
	return d ;

}

    /**
     * Lit un nombre en virgule flottante et en simple précision dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>float</code> en Java et permettre la conversion par :
	 * 		<code>Float(String).floatValue()</code>
	 * Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
     * 
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @return la valeur <code>float</code> correspondante.
     */

    /*
     * Reads an ASCII decimal floating point number.
     * A floating point number should obey Java String conversion :
	 * 		<code>Float(String).floatValue()</code>
     * Program exits on read errors or EOF
     * @return the double.
     */
    
public static float readFloat()
{
String s ;
float f = 0.0F ;

	s= readLine("float");

	try
		{
		f = new Float(s).floatValue() ;
		}
	catch (NumberFormatException e)
		{
		conversionError( s, "float" );
		}
		
	return f ;

}

    /**
     * Lit un nombre entier dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>int</code> en Java et permettre la conversion par :
	 * 		<code>Integer.parseInt(String)</code>.
	 * Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
	 *
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @return la valeur <code>int</code> correspondante.
     */

    /*
     * Reads an ASCII decimal integer conforming to <code>Integer.parseInt(String)</code>.
     * Integers can be preceded by optional whitespace (SPACE or TAB).
     * Program exits on read errors or EOF
     * @return the integer.
     */
     
public static int readInt() 
{
int i = 0 ;
String s ;

	s= readLine("int");

	try
		{
		i = Integer.parseInt(s) ;
		}
	catch (NumberFormatException e)
		{
		conversionError( s, "int" );
		}
		
	return i ;

}

    /**
     * Lit un nombre entier long écrit en base <code>b</code> dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>long</code> en Java et permettre la conversion par :
     * 		<code>Long.parseLong(String,b)</code>
	 * Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
	 *
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @param	b	la base dans laquelle l'entier lu est exprimé  
     * @return la valeur <code>long</code> correspondante.
     */

    /*
     * Reads an ASCII long expressed in base <code>b</code> and conforming 
     * to <code>Long.parseLong(String,b)</code>
     * Longs can be preceded by optional whitespace (SPACE or TAB).
     * Program exits on read errors or EOF
     * @param	b	the numbering base used to make the conversion  
     * @return the long.
     */
	 
public static long readLong(int b) 
{
long l = 0L;
String s ;
String t = "long" ; 

	if ( b != 10)
		t= t + " in base " + b ;
	
	s= readLine(t);
	

	try
		{
		l = Long.parseLong(s, b) ;
		}
	catch (NumberFormatException e)
		{
		conversionError( s, t) ;
		}
		
	return l ;
	
}
    /**
     * Lit un nombre entier long dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>long</code> en Java et permettre la conversion par :
     * 		<code>Long.parseLong(String)</code>
	 * Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
	 *
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @return la valeur <code>long</code> correspondante.
     */

    /*
     * Reads an ASCII decimal long conforming to <code>Long.parseLong(String)</code>
     * Longs can be preceded by optional whitespace (SPACE or TAB).
     * Program exits on read errors or EOF
     * @return the long.
     */
	 
public static long readLong() 
{
	return readLong(10) ;
}

    /**
     * Lit un nombre entier court dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>short</code> en Java et permettre la conversion par :
     * 		<code>Short.parseShort(String)</code>
	 * Le nombre peut tre preécédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
	 *
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @return la valeur <code>short</code> correspondante.
     */

    /*
     * Reads an ASCII decimal short.
     * Shorts can be preceded by optional whitespace (SPACE or TAB).
     * Program exits on read errors or EOF
     * @return the short.
     */
     
public static short readShort() 
{
short j = 0 ;
String s = readLine("short");

	try
		{
		j = Short.parseShort(s) ;
		}
	catch (NumberFormatException e)
		{
		conversionError( s, "short" );
		}
		
	return j ;
	
}

    /**
     * Lit un octet dans une ligne. 
	 * Ces nombres doivent être conforme à l'écriture standard des constantes 
	 * <code>byte</code> en Java et permettre la conversion par :
     * 		<code>Byte.parseByte(String)</code>
	 * Le nombre peut être précédé ou suivi d'un nombre quelconque d'espaces
	 * (SPACE ou TAB). La ligne lue ne doit comporter qu'un seul nombre.
	 *
     * Le programme stoppe en cas d'erreur ou en fin de fichier
     * @return la valeur <code>byte</code> correspondante.
     */
	 
    /*
     * Reads an ASCII decimal byte.
     * Bytes can be preceded by optional whitespace (SPACE or TAB).
     * Program exits on read errors or EOF
     * @return the byte.
     */
     
public static byte readByte() 
{
byte b = 0 ;
String s = readLine("byte");

	try
		{
		b = Byte.parseByte(s) ;
		}
	catch (NumberFormatException e)
		{
		conversionError( s, "byte" );
		}
		
	return b ;
	
}
    /**
     * Lit une ligne. 
	 *
     * Le programme stoppe en cas d'erreur de lecture.
     * @return une chaîne indiquant le contenu de la ligne ou
     * une chaîne vide lorsque la ligne était vide ou
     * <code>null</code> en fin de fichier .
    */

    /*
     * Reads a line.
     * Program exits on read errors
     * @return the line content or an empty string if nothing entered or <code>null</code> if EOF reached .
     */
     
	public static String readLine() 
		{
		String s = null ;
		
		try
			{
			s= cin.readLine();
			}
		catch ( java.io.EOFException error)
			{
			s = null ;
			}
		catch ( Exception error )
			{
			exitProgram( new RuntimeException(error.toString()) ) ;
			}
			
		return s ;
		}
		
    /**
     * Lit une nouvelle ligne. 
	 *
     * Le programme stoppe en cas d'erreur de lecture ou si la fin de fichier
	 * est rencontrée.
     * @param	t	chaîne indiquant le type de la donnée lue dans cette ligne
     * @return une chaîne indiquant le contenu de la ligne ou
     * une chaîne vide lorsque la ligne était vide .
     */

    /*
     * Reads a new line.
     * Program exits on read errors or if EOF is reached.
     * @param	t	String indicating the type expected in the line
     * @return the line content or an empty string if nothing entered .
     */
	 
private static String readNewLine(String t) 
{
String s ;
	
	s= readLine() ;

	if ( s == null)
		readError ( " Fin de fichier inattendue" , t) ;
	
	return s ;
}
		
    /**
     * Lit une donnée de type <code>t</code> dans une ligne non vide. 
	 *
     * Le programme stoppe en cas d'erreur de lecture, de fin de fichier
	 * ou si la ligne était vide.
     * @param	t	chaîne indiquant le type de la donnée lue dans cette ligne
     * @return une chaîne indiquant le contenu non vide de la ligne.
    */

  /*
    * Reads a data of type <code>t</code> in a non empty line.
    * Program exits on read errors or EOF or if line is empty
    * @param	t	String indicating the type expected in the line
    * @return the non empty line content
    */
     
private static String readLine(String t) 
{
String s ;
	
	s= readNewLine(t).trim() ;

	if (s.length() == 0)
		readError ( " Ligne vide" , t) ;
		
	return s ;
}

    
		
} // end class Console