Newsgroup: it.comp.java
Titolo: programmi a linea di comando: best pratices?

Qualcuno mi sa indicare qualche fonte di informazioni che tratti della
scrittura di software con interfaccia a linea di comando, o a console? In
giro  su internet e sui manuali ho trovato qualcosa, ma solo cose
generiche, del tipo leggi il comando, passalo ad uno switch, e fai
qualcosa.
Questo perň puň andare bene quando si hanno pochi comandi, ma quando
iniziano a diventare un pň piů complessi diventa macchinoso aggiungere
case su case...
Grazie per le eventuali info!
Raffaele
-- 
Raffaele Castagno
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 case su case...
Bhe, cmq č normale che tu debba utilizzare uno switch-like statement: come
puoi discriminare i comandi l'uno dal altro? Cmq spero tu nn stia facendo un
lungo e gigantesco main o giu' di li:
io una cosa come stai facendo tu la farei raffinata tipo un interfaccia o
classe astratta che rappresenta il comando, ogni comando la implementa,
dividi  eventualemente in gerarchie, cosi ti puoi permettere il parsing dei
comandi gerarchico. Leggi il comando, lo parserizzi e crei l'oggetto, dai in
pasto l'oggetto ad un oggetto/interprete che lo esegue. Crei l'eventuale
risposta da mandare a console.
-- 
Ciao e buon lavoro,
  Renato
---- 
Renato Eschini
   Inera srl
   Via Vespucci 41
   56100 Pisa
   Tel:         (+39) (0)50 2201218
   WWW:         
http://www.inera.it

Guarda qui:
http://jakarta.apache.org/commons/cli/
http://www.onjava.com/pub/a/onjava/2003/06/25/commons.html
Però è un po' complicatuccio, nel senso che se hai diverse applicazioni, 
tutte simili ma con parametri leggermente diversi, opzionali, etc. 
allora CLI fa per te; di contro se la tua app è semplice evita di 
usarlo, ti risparmi un po' di grattacapi
-- 
  -- + Setaceous Pig + --
http://megadix.users.mcs2.netarray.com/
http://www.jroller.com/page/megadix/


http://csvtosql.sourceforge.net/

forse però gli serviva tipo un menu e non i parametri di avvio. ?!


 Guarda qui:
Grazie ma non è quello che cerco. Non mi serve un gestore di parametri, ma
un sistema interattivo, tipo console. L'utente inserisce un comando, vede
il risultato, altro comando, etc, tipo shell...


 risposta da mandare a console.
Ogni comando dovrebbe rappresentare alla fine un metodo di una classe.
Essendo uno strategico, si potrebbero avere cose del tipo:
strategic>move unit 001 12 12
Che in qualche maniera deve eseguire il metodo move(Long x, Long y) della
classe corrispondente all'unità con id 001.
Comunque credo che possa essere d'aiuto dare un'occhiata ai sorgenti di
beanshell.
Saluti!


 
Io ho fatto così:
per la lettura dei dati ho usato un BufferedReader collegato a System.in ed
ho utilizzato il relativo metodo readLine().
Per il parsing dei comandi ho creato una classe che prendeva in input la
stringa "grezza" e tramite l'utilizzo della classe StringTokenizer (te la
consiglio vivamente) divideva il comando (move nel tuo caso) in una Stringa
e gli eventuali parametri in un array di Stringhe { "001", "12", "12" }.
La stringa comprendente il comando e l'array di parametri andavano a
comporre i metodi privati della classe ed erano accessibili tramite metodi
Getters pubblici al resto dell'applicazione.
Eccoti la classe Command, non è il massimo e ha bisogno di un paio di
aggiustamenti, ma funziona e cmq puoi estrarne le cose che ti servono per
il tuo prog.
Ciao
/*
 * Command.java
 * 
 * Created on 19-giu-2004
 */
package utilities;
import java.util.StringTokenizer;
public class Command {
    // il comando così come viene ricevuto
    private String rawCommand;
    // la stringa del comando
    private String command;
    // il primo parametro
    private String firstParam;
    // la lista dei parametri
    private String[] params;
    // il conteggio dei parametri
    private int paramCount = 0;
 
    private Command(String command, String rawcmd) {
 
        this.command = command;
        this.rawCommand = rawcmd;
    }
    /**
     * TODO: descrivere in dettaglio la classe  
     * 
     * @param rawcmd Il comando da interpretare
     * @return       L'oggetto command costituente il comando digitato /
ricevuto
     */
    public static Command parseCommand(String rawcmd) {
        // rimuove gli spazi in eccesso
        rawcmd = rawcmd.trim();
        if (rawcmd.equals("")) {
            return null;
        }
 
        // crea un'istanza di StringTokenizer che suddividerà 
        // la stringa di input in più token
        StringTokenizer tokenizer = new StringTokenizer(rawcmd);
        // controlla che vi sia almeno un token        
        if (tokenizer.countTokens()>0) {
            // estrae un token
            String firstToken = tokenizer.nextToken();
            /* crea un'istanza della classe Command, passandogli al
costruttore
             * il primo token (la stringa di comando) e la stringa grezza
così
             * come è stata ricevuta. 
             */
            Command cmd = new Command(firstToken, rawcmd);
            // se vi sono altri tokens
            if (tokenizer.hasMoreTokens()) {
                // costruisce l'array di stringhe inserendo tutti i tokens
                String[] params = new String[tokenizer.countTokens()];
                // cicla fin quando vi sono token
                int i=0;
                while (tokenizer.hasMoreTokens()) {
                    params[i++] = tokenizer.nextToken();
                }
                cmd.setParams(params);
            }
            return cmd;
 
        } else {
            return null;
        }
 
    }
    // metodi Getters e Setters pubblici
    public String getCommand() {
        return command;
    }
 
    public String getFirstParam() {
        return firstParam;
    }
 
    public int getParamCount() {
        return paramCount;
    }
 
    public String[] getParams() {
        return params;
    }
 
    protected void setParams(String[] params) {
        this.params = params;
        if (params != null) {
            firstParam = params[0];
            paramCount = params.length;
        }
    }
 
    public String getRawCommand() {
        return rawCommand;
    }
}

 Io ho fatto cosě:
Grazie mille! Lo metto da parte poi lo studio!


 puoi discriminare i comandi l'uno dal altro? 
Normale mica tanto... si possono discriminare dal tipo 
uL
-- 
