parser da riga di comando per Qt4

Question

Sto cercando un parser da riga di comando per Qt4.

Ho fatto una piccola ricerca su google e ho trovato questo: http://www.froglogic.com/pg?id=PublicationsFreeware&category=getopt tuttavia manca il supporto per le opzioni "--enable-foo" e "--disable-foo". Oltre a ciò, sembra un vero vincitore.

EDIT:

Sembra Frologic rimosso questo. Quindi le migliori opzioni che vedo stanno usando Boost (che non è API o stabile ABI) o che forgiano il supporto per kdelibs. Yay ...

Answer 1

Dal momento che Qt 5.2 si può finalmente trovare una soluzione in QtCore sé: ho contribuito QCommandLineParser lì.

Answer 2

Dev'essere specifico per Qt4? In caso contrario, GNU Getopt è davvero bello, anche se le licenze potrebbero essere un problema se non si sta facendo software open source.

Answer 3

Tale pacchetto supporta --disable-foo e --enable-foo tramite opts.addSwitch ("disable-foo", & foo_disabled); e opts.addSwitch ("enable-foo", & foo_enabled);. È necessario gestire il controllo di entrambi e trattare con qualcuno che specifica entrambi (oops).

Quello che non capisco è come questo abbia a che fare con QT4 ...

Answer 4

QCoreApplication's constructors richiedono (int &argc, char **argv) (e QApplication eredita da QCoreApplication). Come il documentation states, è altamente raccomandato che

Dal QApplication si occupa anche di argomenti della riga di comando più comuni, di solito è una buona idea di crearla prima qualsiasi interpretazione o la modifica dei argv è fatto in l'applicazione stessa.

E se si sta lasciando Qt ottenere il primo passaggio a gestire argomenti in ogni modo, sarebbe anche una buona idea usare QStringList QCoreApplication::arguments() invece di camminare attraverso argv; QApplication può rimuovere alcuni degli argomenti che ha preso per il proprio uso.

Questo non si presta ad essere molto compatibile con altre biblioteche argomento-analisi ...

Tuttavia, kdelibs viene fornito con un bel parser argomento, KCmdLineArgs. È LGPL e può essere utilizzato senza KApplication se lo si desidera realmente (chiamare KCmdLineArgs::init).

KCmdLineOptions options; 
options.add("enable-foo", ki18n("enables foo")); 
options.add("nodisable-foo", ki18n("disables foo")); 
// double negatives are confusing, but this makes disable-foo enabled by default 

KCmdLineArgs::addCmdLineOptions(options); 
KApplication app; 
KCmdLineArgs *args = KCmdLineArgs::parsedArgs(); 

if (args->isSet("enable-foo") && !args->isSet("disable-foo")) 
    cout << "foo enabled" << endl; 
else 
    cout << "foo disabled" << endl; 

Non testato (chi mette mai alla prova quello che pubblicano su S.O.?).

Answer 5

Davvero un metodo semplice è quello di eseguire la scansione di "chiave = valore" args,
metterli in una tabella dicono zz.map: QString -> QVariant,
e ottenere i loro valori con zz.map.value (chiave, predefinito). Un esempio:

#include "ztest.h" 
Ztest zz; 
int main(int argc, char* argv[]) 
{ 
    zz.eqargs(++ argv); // scan test=2 x=str ... to zz.map 

    QString xx = zz.map.value("xx", ""); 
    if(Zint(Size, 10)) // a #def -> zz.map.value("Size", 10) 
     ... 

ztest.h è < 1 pagina, sotto; lo stesso per Python ~ 10 linee.

(Ognuno ha il suo parser di opzioni preferito; questo è il più semplice.
Vale la pena ripetere: tuttavia di specificare le opzioni, loro eco al file di output-
"ogni scienziato che conosco ha difficoltà a tenere traccia di quali parametri hanno usato l'ultima volta che correvano uno script")

To. fare QPoints, ecc lavoro, ovviamente ha bisogno di un QString -> QPoint parser. Qualcuno sa perché questo non funziona (in Qt 4.4.3)?

QPoint pt(0,0); 
QDataStream s("QPoint(1,2)"); 
s >> pt; 
qDebug() << "pt:" << pt; // QPoint(1364225897,1853106225) ?? 

Aggiunto 25nov -

// ztest.h: scan args x=2 s=str ... to a key -> string table 
// usage: 
// Ztest ztest; 
// int main(int argc, char* argv[]) 
// { 
//  QApplication app(argc, argv); 
//  ztest.eqargs(++ argv); // scan leading args name=value ... 
//  int x = Zint(x, 10); // arg x= or default 10 
//  qreal ff = Zreal(ff, 3.14); 
//  QString s = Zstr(s, "default"); 
// care: int misspelled = Zint(misspellled) -- you lose 
//version: 2009-06-09 jun denis 

#ifndef ztest_h 
#define ztest_h 

#include <QHash> 
#include <QString> 
#include <QVariant> 
#include <QRegExp> 

//------------------------------------------------------------------------------ 
class Ztest { 
public: 
    QHash< QString, QVariant > map; 
    int test; // arg test=num, if(ztest.test) 

    Ztest() : test(0) {} 

    QVariant val(const QString& key, const QVariant& default_ = 0) 
    { 
    return map.value(key, default_); 
    } 

    void setval(const QString& key, const QVariant& val) 
    { 
    map[key] = val; 
    if(key == "test" || key == "Test") 
     test = val.toInt(); 
    } 

//------------------------------------------------------------------------------ 
    // ztest.eqargs(++ argv) scans test=2 x=3 ... -> ztest table 
    void eqargs(char** argv) 
    { 
    char** argv0 = argv; 
    char *arg; 
    QRegExp re("(\\w+)=(.*)"); // name= anything, but not ./file=name 
    for(; (arg = *argv) && re.exactMatch(arg); argv ++){ 
     setval(re.cap(1), re.cap(2)); 
    } 
     // change argv[0..] -> args after all name=values 
    while((*argv0++ = *argv++) != 0) {} 
    } 
}; 

extern Ztest ztest; 

    // macros: int x = Zint(x, 10): x= arg or default 10 
#define Zstr(key, default) ztest.val(#key, default).toString() 
#define Zint(key, default) ztest.val(#key, default).toInt() 
#define Zreal(key, default) ztest.val(#key, default).toDouble() 

#endif 

Answer 6

Anche per alcune opzioni di fantasia si può provare parsing gperf.

IBM ha un bel tutorial su di esso.

Answer 7

Guardate questa: http://code.google.com/p/qtargparser/

Answer 8

Un'altra opzione mi sono imbattuto mentre cerca di fare anche questo:

http://code.google.com/p/qgetopts/

non ho usato però.

Answer 9

C'è anche QxtCommandOptions da http://www.libqxt.org/

Answer 10

Questo è più o meno la stessa risposta ephemient, ma con una semplice espressione regolare per aiutare analizzare i args. (In questo modo potrebbe essere utile se avete solo bisogno di una manciata di args)

Run con questo:

./QArgTest --pid=45 --enable-foo 

E il codice:

int main(int argc, char *argv[]) { 
    QApplication app(argc, argv, false); 
    qDebug() << "QApp arg test app"; 

    QStringList args = app.arguments(); 

    int pid = 0; 

    QRegExp rxArgPid("--pid=([0-9]{1,})"); 
    QRegExp rxArgFooEna("--enable-foo"); 
    QRegExp rxArgFooDis("--disable-foo"); 

    for (int i = 1; i < args.size(); ++i) { 
     if (rxArgPid.indexIn(args.at(i)) != -1) { 
      pid = rxArgPid.cap(1).toInt(); 
      qDebug() << i << ":" << args.at(i) << rxArgPid.cap(1) << pid; 
     } 
     else if (rxArgFooEna.indexIn(args.at(i)) != -1) { 
      qDebug() << i << ":" << args.at(i) << "Enable Foo"; 
     } 
     else if (rxArgFooDis.indexIn(args.at(i)) != -1) { 
      qDebug() << i << ":" << args.at(i) << "Disable Foo"; 
     } 
     else { 
      qDebug() << "Uknown arg:" << args.at(i); 
     } 
    } 
    return 0; 
} 

Answer 11

E 'il 2013 e ancora "1st party" pars pars. Anyways..if qualcuno trova ad affrontare lo stesso problema e vorrei evitare le curve di apprendimento che vengono con librerie cmd parser, qui è una soluzione "rapida & sporco" per voi: -

QString QArgByKey(QString key, QChar sep = QChar('\0')) //prototype usually in separate header 

QString QArgByKey(QString key, QChar sep) 
{ 
    bool sepd=sep!=QChar('\0'); 
    int pos=sepd?qApp->arguments().indexOf(QRegExp('^'+key+sep+"\\S*")):qApp->arguments().indexOf(QRegExp(key)); 
    return pos==-1?QString::null: 
    (sepd?qApp->arguments().at(pos).split(sep).at(1):(++pos<qApp->arguments().size()?qApp->arguments().at(pos):QString::null)); 
} 

Esempio: -

user@box:~$ ./myApp firstKey=Value1 --secondKey Value2 thirdKey=val3.1,val3.2,val3.3 --enable-foo 

Usage:

QString param1 = QArgByKey("firstkey",'='); // Returns `Value1` from first pair 
QString param2 = QArgByKey("--secondkey"); // Returns `Value2` from second pair 
QString param3-1 = QArgByKey("thirdkey",'=').split(',').at(0); // Returns `val3.1` 
bool fooEnabled = qApp->arguments().contains("--enable-foo"); //To check for `--enable-foo` 

Parametri possono essere passati in qualsiasi ordine

Edit: Gli aggiornamenti a questo frammento saranno found here