package scacchi.main;
import java.io.*;
import scacchi.main.ArgomentiComando.*;
import scacchi.main.EccezioniTesto.*;
import scacchi.main.EccezioniPartita.*;
/**
* Interfaccia per l'acquisizione ed esecuzione dei comandi.
* I comandi sono stringhe separate da ';'.
* Per la sintassi dei comandi si veda {@link Comando}.
* @see Comando
* @see ComandoScacchi
* @see ArgomentiComando
*/
public abstract class InterfacciaComandi {
// ----------------------------------------------------------------------
// -- static --
// ----------------------------------------------------------------------
/**
* Errore nella lettura dall'interfaccia.
*/
public class InterfacciaException extends IOException {
public InterfacciaException(String s) { super(s); }
}
// ----------------------------------------------------------------------
// -- instance --
// ----------------------------------------------------------------------
// ---- instance fields ----
/** Lo stream di input dei comandi */
private Reader in;
/** Un tag che segnala un eventuale errore */
private boolean errore = false;
/** La stringa con un eventuale messaggio */
private String msg = "";
/** La stringa con il risultato dell'esecuzione del comando */
private String out = "";
/** L'ultimo comando letto */
private String cmd = "";
/** La partita che si sta giocando */
private Partita partita = null;
// ---- constructors ----
/**
* Crea una nuova interfaccia associata allo stream dello
* standard input.
*/
public InterfacciaComandi() {
this.in = new InputStreamReader(System.in); }
/**
* Crea una nuova interfaccia.
* @param in lo stream di caratteri da cui l'interfaccia legge l'input.
*/
public InterfacciaComandi(Reader in) { this.in = in; }
// ---- instance methods ----
/**
* Azzera i contenuti dei campi relativi al risultato di un comando.
*/
private void clean() {
errore = false;
msg = "";
out = "";
cmd = "";
}
/**
* Restituisce il messaggio memorizzato nell'interfaccia.
* @return La stringa con il messaggio di errore inviato
* dall'ultimo comando.
*/
public String msg() { return msg; }
/**
* Controlla se si è verificato un errore.
* @return true se l'ultimo comando ha dato un errore, false altrimenti.
*/
public boolean errore() { return errore; }
/**
* Restituisce l'ultimo comando letto.
* @return La stringa dell'ultimo comando priva di spazi iniziali/finali.
*/
public String cmd() { return cmd; }
/**
* Restituisce la risposta dell'ultimo comando.
* @return La stringa con la risposta dell'ultimo comando.
*/
public String out() { return out; }
/**
* La funzione che crea un nuovo comando.
* @param s La stringa del comando: la stringa deve iniziare con
* il carattere del comando (eventuali spazi prima del
* comando deve essere eliminati prima di chiamare la funzione).
* @return Il comando letto.
*/
public abstract Comando nuovoComando(String s)
throws NotazioneException;
/**
* Legge ed esegue il successivo comando
*/
public void nextComando() throws IOException {
clean(); // azzera i risultati del precedente comando
try { // leggi il comando
for (int i = in.read(); ((char) i) != ';'; i = in.read()) {
if (i == -1)
throw new InterfacciaException("Lo stream di input " +
"e' terminato " +
"in modo inatteso");
cmd = cmd + (char) i;
}
cmd = cmd.trim(); // elimina spazi iniziali/finali
Comando c = nuovoComando(cmd); // crea il comando letto
if (c.isComandoNuovaPartita()) {
partita = c.eseguiComandoNuovaPartita();
out = nuovoComando("p").eseguiComandoPartita(partita);
} else if(partita != null) {
out = c.eseguiComandoPartita(partita);
} else {
errore = true;
msg = "Occorre cominciare una partita";
}
} catch (NotazioneException e) {
errore = true;
msg = e.getMessage();
} catch (PartitaException e) {
errore = true;
msg = e.getMessage();
}
}
}