Newsgroup: it.comp.java
Titolo: Problemi con gli stream?

Salve a tutto il NG.
Sto realizzando un piccolo (e banale) programmino in Java, che,
sfruttando una classe Sun per la redirezione dello stdout, dovrebbe
stampare su un file il contenuto di una cartella (ricorsivamente o
fermandosi alla directory corrente). Ora il problema: ho fatto in modo
che il programma possa visualizzare di seguito piu' cartelle: cioe'
dopo aver terminato la visualizzazione compare un menu' che chiede se
si vuole visualizzare qualche altra directory. E qui e' nato un
problema: nel secondo file le voci compaiono due volte, nel terzo tre,
e cosi' via. Cioe' se nella directory ho un file tmo.log, il primo
file di log sara';
tmo.log (e fin qui...)
il secondo:
tmo.logtmo.log
il terzo:
tmo.logtmo.logtmo.log.
Qualcuno sa dirmi perche'?
Se occorre posso postare il codice (non l'ho fatto perche' si tratta
di circa 350 righe, e non volevo appesantire il messaggio con qualcosa
di inutile o non richiesto.
Grazie a tutti
Riccardo

 wrote in message 39ec8ebb...@news.libero.it...



Ciao e grazie.
Questo e' il costruttore della classe:
class UsoDelDisco3{
    private String directory;
    private String fileLog="";
    private boolean recors=true;
    private BufferedReader buf=new BufferedReader(new
InputStreamReader(System.in));
 
    /**
     * Costruttore senza parametri
     */
    UsoDelDisco3()
    {
	setDirectory(listenDir());
	setFileLog(listenFile());
	setRecors(listenRec());
	if (recors)
	    {
		try{
		    SaveOutput.start(fileLog);
		    leggiDir(directory);
		}catch (Exception e){e.printStackTrace();
		}finally{
		    //Interrompiamo la cattura dei caratteri e la loro
		    //registrazione nel file di log
		    SaveOutput.stop();
		}
	    }
	else   
	    {
		try{
		    SaveOutput.start(fileLog);
		    leggiDirnRic(directory);
		}catch (Exception e) {e.printStackTrace();
		}finally{
		    SaveOutput.stop();
		}
	    }
	menu();
    }
Questo il metodo menu() che ricarica una nuova istanza:
public void menu()
    {
	System.out.println("\nVuoi visualizzare altre directory?
(S/N)");
	try{
	String ch=leggi();
	if ((ch.equals("s"))||(ch.equals("S")))
	    {
		UsoDelDisco3 uds=new UsoDelDisco3();
	    }
	else  if ((ch.equals("n"))||(ch.equals("N")))
	    {
		System.exit(0);
	    } 
	else
	    {
		System.err.println("Risposta sconosciuta." );
	    }
	}catch (IOException ex) {System.err.println("Errore nella
lettura dei parametri.");
	}
    }
 
    Questo il metodo che stampa il file di log:
 private void leggiDir(String fs)
    {
	File f=new File(fs);	  //parametro 1: file (directory) di
partenza
	if (f.exists())			  //se esiste...
	    {
		if (f.isDirectory())  //se si tratta di una
directory..
		    {	 
			String list[]=f.list();  // array di String
con file contenuti 
			Arrays.sort(list);   // ordina l'array
 
			for (int i=0; i<list.length; i++)
// la scorre con un ciclo for
			    {
				leggiDir (fs+'/'+list[i]);
//richiamando il metodo per ogni file trovato
			    }
		    } 
		System.out.println(fs);
	    }
    }
 
   In sostanza, viene richiesto, tramite un metodo di lettura che usa
il Buffered dichiarato in apertura, il percorso della directory, del
file di log e se la scansione deve essere ricorsiva. In base a cio'
viene creato un oggetto UsoDelDisco, che stampa in file e a video
(qui, senza problemi) il percorso dei file.
Terminato questo richiama il metodo menu(), che chiede se si vuole
istanziare un nuovo oggetto e lo istanzia, se richiesto. Tutto qui.
Il metodo di ridirezione dell'output e' di Sun, percio' dovrebbe
essere corretto.
Grazie, e mi scuso per il messaggio lungo.
Riccardo

 file://richiamando il metodo per ogni file trovato



Grazie per il tempo che sprecherai. Eccotti il codice:
(Tieni conto solo del primo costruttore)
/** 
* Classe che stampa in un file di testo e mostra in video tutti i file
contenuti in una directory
* indicata da riga di comando.
* Funziona in maniera ricorsiva
* @author Riccardo Bachis
* @version 0.1 beta
*/
// Editor: Emacs
// OS: Linux Red Hat 6.2
import java.io.*;
import java.util.Arrays;
/**
* Classe che legge e visualizza ricorsivamente nomi di file e
directory
*/
class UsoDelDisco3{
    private String directory;
    private String fileLog="";
    private boolean recors=true;
    private BufferedReader buf=new BufferedReader(new
InputStreamReader(System.in));
 
    /**
     * Costruttore senza parametri
     */
    UsoDelDisco3()
    {
	setDirectory(listenDir());
	setFileLog(listenFile());
	setRecors(listenRec());
	if (recors)
	    {
		try{
		    SaveOutput.start(fileLog);
		    leggiDir(directory);
		}catch (Exception e){e.printStackTrace();
		}finally{
		    //Interrompiamo la cattura dei caratteri e la loro
		    //registrazione nel file di log
		    SaveOutput.stop();
		}
	    }
	else   
	    {
		try{
		    SaveOutput.start(fileLog);
		    leggiDirnRic(directory);
		}catch (Exception e) {e.printStackTrace();
		}finally{
		    SaveOutput.stop();
		}
	    }
	menu();
    }
 
    /** 
     * Costruttore
     * @param String files: directory di partenza
     */
    UsoDelDisco3(String files)
    {
	directory=files;
	setFileLog(listenFile());
	setRecors(listenRec());
	try{
	    SaveOutput.start(fileLog);
	    if (recors)
		{
		    leggiDir(directory);
		}
	    else
		{
		    leggiDirnRic(directory);
		}
	}catch (Exception e) {e.printStackTrace();
	}finally{
	    SaveOutput.stop();
	}
	menu();
    }
 
    /**
     * Costruttore con due parametri
     * @param String dir: percorso della directory da analizzare
     * @param String log: percorso del file di log
     */
    UsoDelDisco3( String dir, String log)
    {
	directory=dir;
	fileLog=log;
	setRecors(listenRec());
	try{
	    SaveOutput.start(fileLog);
	    if (recors)
		{
		    leggiDir(directory);
		}
	    else
		{
		    leggiDirnRic(directory);
		}
	}catch (Exception e ) {e.printStackTrace();
	}finally{
	    SaveOutput.stop();
	}
	menu();
    }
 
    /**
     * Richiede l'inserimento della directory da analizzare
     * @return String directory: directory da analizzare
     */
    public String listenDir()
    {
	String directory=null;
 
	System.out.print("\n Ora inserisci il nome della directory da
visualizzare:");
	try{
	    directory=this.leggi();
	}catch (IOException e) { System.err.println("Errore nella
lettura dei dati: ");
	}
	return directory;
    }
    /**
     * Richiede il percorso del file dove memorizzare i risultati
     * @return String file: percorso del file di log
     */
    public String listenFile()
    {
	String file=null;
	System.out.print("Indica il percorso e il nome del file di
log: ");
	try{
	    file=this.leggi();
	}catch (IOException io) { System.err.println("Errore nella
lettura dei dati.");
	}
	return file;
    }
 
    /**
     * Richiede all'utente se la visualizzazione deve essere ricorsiva
     */
    public boolean listenRec()
    {
	String bool="";
	boolean temp=true;
	System.out.print("La ricerca puo' fermarsi alla directory
corrente o proseguire ricorsivamente.\nVuoi fermarti alla directory
corrente? (s/n)");
	try{
	    bool=this.leggi();
	}catch (IOException e) {System.err.println("Errore nella
lettura dei dati.");
	}
 
	if ((bool.equals("s"))||(bool.equals("S")))
	    {
		temp=false;
	    }
 
	else if ((bool.equals("n"))||(bool.equals("N")))
	    {
		temp=true;
	    }
	return temp;
    }
 
 
    public void menu()
    {
	System.out.println("\nVuoi visualizzare altre directory?
(S/N)");
	try{
	String ch=leggi();
	if ((ch.equals("s"))||(ch.equals("S")))
	    {
		UsoDelDisco3 uds=new UsoDelDisco3();
	    }
	else  if ((ch.equals("n"))||(ch.equals("N")))
	    {
		System.exit(0);
	    } 
	else
	    {
		System.err.println("Risposta sconosciuta." );
	    }
	}catch (IOException ex) {System.err.println("Errore nella
lettura dei parametri.");
	}
    }
 
    public String leggi() throws IOException
    {
	String line=buf.readLine();
	return line;
    }
    /**
     * Metodo principale. Scorre ricorsivamente una directory data
     * @param String file: directory da scorrere
     * @param String limite: filtro indicante la grandezza minima del
file da visualizzare
     */
    private void leggiDir(String fs)
    {
	File f=new File(fs);	  //parametro 1: file (directory) di
partenza
	if (f.exists())			  //se esiste...
	    {
		if (f.isDirectory())  //se si tratta di una
directory..
		    {	 
			String list[]=f.list();  // array di String
con file contenuti 
			Arrays.sort(list);   // ordina l'array
 
			for (int i=0; i<list.length; i++)
// la scorre con un ciclo for
			    {
				leggiDir (fs+'/'+list[i]);
//richiamando il metodo per ogni file trovato
			    }
		    } 
		System.out.println(fs);
	    }
    }
 
    /**
     * Visualizza il contenuto della directory corrente in maniera non
ricorsiva
     */
    private void leggiDirnRic(String fs)
    {
	File f=new File (fs);
	if (f.exists())
	    {
		if (f.isDirectory())
		    {
			String list[]=f.list();
			Arrays.sort(list);
			for (int i=0; i<list.length;i++)
			    {
				File ft=new File(f.getPath(),
list[i]);
				if (ft.isDirectory())
				    {
System.out.println(list[i].toUpperCase());
				    }
				else
				    {
					System.out.println(list[i]);
				    }		
			    }
		    }
	    }
    }	    
    /**
     * Metodo che imposta il valore di directory
     * @param String x: String che indica il percorso della directory
da visualizzare
     */
    public void setDirectory(String x)
    {
	directory=x;
    }
    /**
     * Restituisce il valore di directory
     * @return String directory: percorso della directry di lavoro
     */
    public String getDirectory()
    {
	return directory;
    }
    /**
     * Metodo che imposta il valore di fileLog
     * @param String fl: percorso del file di log
     */
    public void setFileLog( String fl)
    {
	fileLog=fl;
    }
    /**
     * Metodo che restituisce il valore di fileLog
     * @return String: il percorso del file di log
     */
    public String getFileLog()
    {
	return fileLog;
    }
    /**
     * Imposta il valore di recors
     */
    public void setRecors(boolean sd)
    {
	recors=sd;
    }
    /**
     * Restituisce il valore recors
     */
    public boolean getRecors()
    {
	return recors;
    }
} 
 
 /** 
 * Classe che ridireziona lo stdout e lo stderr su un file
 */
class SaveOutput extends PrintStream{
 
    /** 
     * Stream di output
     */
    static OutputStream logfile;
    /**
     * Stdout predefinito
     */
    static PrintStream oldStdout;
    /**
     * Stderr predefinito
     */
    static PrintStream oldStderr;
 
    /**
     * Costruttore
     * @param ps: PrintStream
     */
    SaveOutput(PrintStream ps)
    {
	super(ps);
    }
 
    /**
     * Inizia a copiare lo Standard Output e l'Error nel file di log
     * @param String f: file di output
     */
    public static void start(String f) throws IOException
    {
	//salva i vecchi setting
	oldStdout = System.out;
	oldStderr= System.err;
 
	//creazione/apertura del file di log
	logfile= new PrintStream( new BufferedOutputStream( new
FileOutputStream(f)));
	//inizia la redirezione dell'output
	System.setOut(new SaveOutput(System.out));
	System.setErr(new SaveOutput(System.err));
    }
 
    /**
     * Chiusura della redirezione e ripristino dei vecchi setting
     */
    public static void stop()
    {
	System.setOut(new SaveOutput(oldStdout));
	System.setErr(new SaveOutput(oldStderr));
	try{
	    logfile.close(); //se omesso non si scrive il file
	}catch (Exception e){e.printStackTrace();
	}
    }
 
    /**
     * Override dei metodi ella classe PrintStream
     */
    public void write(int b)
    {
	try{
	    logfile.write(b);
	}catch(Exception e){e.printStackTrace();
	setError();
	}
	super.write(b);
    }
 
    /**
     * Override della classe PrintStream
     */
    public void write(byte buf[],int off,int len)
    {
	try{
	    logfile.write(buf,off,len);
	}catch(Exception e){e.printStackTrace();
	setError();
	}
	super.write(buf,off,len);
    }
}
public class ProvaViewer{
 
    static public void main(String argv[])
    {
	if (argv.length>2)
	    {
		System.err.println("Troppi parametri.");
		System.exit(0);
	    }
	else{
	    System.out.println("\n\n");
	    System.out.println("\tVISUALIZZATORE DI FILE");
	    System.out.println("   Versione 0.1 beta");
	    System.out.println("   Autore: Riccardo Bachis\n   e-mail:
rba...@tiscalinet.it
\n    home page: 
http://web.tiscalinet.it
");
	    System.out.println("\n\nQuesta semplice utility mostrera'
a video e stampera' su un file di log il contenuto di una directory
ricorsivamente.");
	    UsoDelDisco3 prova;    
 
	    if (argv.length<1)
		{
		    prova=new UsoDelDisco3();
		}
	    else if (argv.length==1)
		{
		    prova=new UsoDelDisco3(argv[0]);
		}
	    else if (argv.length==2)
		{
		    prova=new UsoDelDisco3 (argv[0], argv[1]);
		}
	}    
    }
}