Index: lutincommandline/src/java/org/codelutin/option/OptionParserContexts.java diff -u lutincommandline/src/java/org/codelutin/option/OptionParserContexts.java:1.3 lutincommandline/src/java/org/codelutin/option/OptionParserContexts.java:1.4 --- lutincommandline/src/java/org/codelutin/option/OptionParserContexts.java:1.3 Sat Mar 15 09:05:45 2008 +++ lutincommandline/src/java/org/codelutin/option/OptionParserContexts.java Sun Mar 16 11:08:27 2008 @@ -87,8 +87,6 @@ super(parent, withSons); } - //protected abstract Object instanciate(); - protected ParserException newError(String content, Exception e) { ParserException e1; if (e == null) { Index: lutincommandline/src/java/org/codelutin/option/OptionParser.java diff -u lutincommandline/src/java/org/codelutin/option/OptionParser.java:1.5 lutincommandline/src/java/org/codelutin/option/OptionParser.java:1.6 --- lutincommandline/src/java/org/codelutin/option/OptionParser.java:1.5 Sat Mar 15 09:05:17 2008 +++ lutincommandline/src/java/org/codelutin/option/OptionParser.java Sun Mar 16 11:08:27 2008 @@ -37,13 +37,10 @@ import java.io.Writer; import java.lang.reflect.Method; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.HashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; -import java.util.Set; /** * Parser abstrait d'options de la ligne de commande. @@ -124,7 +121,7 @@ protected Map unusedArguments; /** les erreurs rencontrées dans du dernier parsing */ - protected ParserException[] errors; + //protected ParserException[] errors; /** les arguments utilisés dans le dernier parsing */ protected String[] arguments; @@ -201,36 +198,38 @@ * Launch parsing of some arguments. * * @param args arguments to parse - * @throws ParserException if any problem while parsing - * @throws java.io.IOException if io problems with writers + * @throws ParserFailedException if io problems with writers */ - public void doParse(String... args) throws ParserException, IOException { + public void doParse(String... args) throws ParserFailedException { cleanResult(); arguments = args; - unusedArguments = new HashMap(); + Map unusedArguments = new HashMap(); ParserContext context = new ParserContext(this); - if (args.length == 0) { - errors = new ParserException[0]; - return; - } - // detect options - context.detectOptions(args); + if (args.length > 0) { - // instanciate real options from safe contexts - for (OptionContext optionContext : context.getContexts()) { - optionContext.instanciate(); - } + // detect options + context.detectOptions(args); - // transfert unused arguments - for (Integer unusedArgument : context.getUnusedArguments()) { - unusedArguments.put(unusedArgument, args[unusedArgument]); - } + // instanciate real options from safe contexts + for (OptionContext optionContext : context.getContexts()) { + optionContext.instanciate(); + } - // transfert errors from parser parser - errors = context.getErrors().toArray(new ParserException[context.getNbErrors()]); + // transfert unused arguments + for (Integer unusedArgument : context.getUnusedArguments()) { + unusedArguments.put(unusedArgument, args[unusedArgument]); + } + } // clean parser context.clear(); + + if (context.getNbErrors() > 0|| !unusedArguments.isEmpty()) { + + // transfert errors from parser parser + ParserException[] errors = context.getErrors().toArray(new ParserException[context.getNbErrors()]); + throw new ParserFailedException("there argument parsing failed", errors,arguments,unusedArguments); + } } /** @@ -368,14 +367,14 @@ } /** @return true 0; - } + //public boolean hasFailed() { + // return errors != null && errors.length > 0; + //} /** @return les erreurs rencontrées lors du dernier parsing */ - public ParserException[] getErrors() { - return errors; - } + //public ParserException[] getErrors() { + // return errors; + //} /** @return la liste des arguments non utilisés lors du dernier parsing */ public String[] getUnusedArguments() { @@ -395,36 +394,6 @@ ParserUtil.toString(getClass(), w, head, prefix, prefixOption, prefixConfig); } - /** - * Imprime dans un writer les erreurs rencontrées pendant l'analyse. - * - * @param w le writer à utiliser - * @throws IOException si problèmes d'écriture dans le writer - */ - public void printErrors(Writer w) throws IOException { - if (!hasFailed() && (unusedArguments == null || unusedArguments.isEmpty())) { - return; - } - w.append(_("lutinutil.parserdef.printError", Arrays.toString(arguments))).append('\n'); - if (!unusedArguments.isEmpty()) { - Set unsedPos = unusedArguments.keySet(); - w.append(_("lutinutil.parserdef.printError.unused.head", unsedPos.size())); - Iterator itr = unsedPos.iterator(); - for (int i = 0, j = unsedPos.size(); i < j; i++) { - int pos = itr.next(); - w.append(_("lutinutil.parserdef.printError.unused", i + 1, j, pos)); - w.append(unusedArguments.get(i)); - } - } - if (hasFailed()) { - w.append(_("lutinutil.parserdef.printError.head", errors.length)); - for (int i = 0, j = errors.length; i < j; i++) { - w.append(_("lutinutil.parserdef.printError.error", i + 1, j)); - w.append(errors[i].toString()); - } - } - } - @Override protected void finalize() throws Throwable { super.finalize(); @@ -462,6 +431,15 @@ return null; } + public Config getConfig(String key) { + for (ConfigKey optionKey : configKeys) { + if (optionKey.getCategory().equals(key)) { + return optionKey.getConfig(); + } + } + return null; + } + /** nettoye les résultat du parseur (utilisé avant tout parsing) */ protected void cleanResult() { for (OptionKey optionKey : optionKeys) { @@ -472,7 +450,6 @@ unusedArguments = null; } arguments = null; - errors = null; } @SuppressWarnings({"unchecked"}) Index: lutincommandline/src/java/org/codelutin/option/SimpleConfigImpl.java diff -u lutincommandline/src/java/org/codelutin/option/SimpleConfigImpl.java:1.5 lutincommandline/src/java/org/codelutin/option/SimpleConfigImpl.java:1.6 --- lutincommandline/src/java/org/codelutin/option/SimpleConfigImpl.java:1.5 Sat Mar 15 09:05:17 2008 +++ lutincommandline/src/java/org/codelutin/option/SimpleConfigImpl.java Sun Mar 16 11:08:27 2008 @@ -50,8 +50,6 @@ doInit(); } - - @Override public void save() throws IOException { // always save all configs in context in the same time Index: lutincommandline/src/java/org/codelutin/option/AbstractContext.java diff -u lutincommandline/src/java/org/codelutin/option/AbstractContext.java:1.1 lutincommandline/src/java/org/codelutin/option/AbstractContext.java:1.2 --- lutincommandline/src/java/org/codelutin/option/AbstractContext.java:1.1 Sat Mar 15 09:05:17 2008 +++ lutincommandline/src/java/org/codelutin/option/AbstractContext.java Sun Mar 16 11:08:27 2008 @@ -14,13 +14,9 @@ * par l'utilisateur. */ protected P parser; - /** - * flag pour indiquer si 'lon veut quitter l'appli après les options - */ + /** flag pour indiquer si 'lon veut quitter l'appli après les options */ protected boolean quit; - /** - * flag pour indiquer si l'on affiche ou non l'ui principale - */ + /** flag pour indiquer si l'on affiche ou non l'ui principale */ protected boolean launchUI = true; /** * flag pour indiquer une première utilisation de l'application (pas de @@ -28,7 +24,7 @@ */ protected boolean firstLaunch; - protected AbstractContext(String[] args) throws IOException, ParserException { + protected AbstractContext(String[] args) throws ParserFailedException, IOException { // parse arguments getParser().doParse(args); @@ -38,20 +34,16 @@ // init i18n with user locale (or default one if not found) initI18n(); - - // mark if first launch - if (getConfig()!=null) { + if (getConfig() != null) { + // mark if first launch setFirstLaunch(!getConfig().getSource().exists()); // save config getConfig().save(); } - } - /** - * initialisation i18n après init du parser et des configs. - */ + /** initialisation i18n après init du parser et des configs. */ public abstract void initI18n(); /** @@ -60,12 +52,9 @@ */ public abstract P getParser(); - /** - * @return la configuration principale de l'application - */ + /** @return la configuration principale de l'application */ public abstract Config getConfig(); - /** * @return true si on doit quitter l'application (uniquement utilisé * lors du démarrage de l'application lors de l'exécution des options Index: lutincommandline/src/java/org/codelutin/option/Config.java diff -u lutincommandline/src/java/org/codelutin/option/Config.java:1.5 lutincommandline/src/java/org/codelutin/option/Config.java:1.6 --- lutincommandline/src/java/org/codelutin/option/Config.java:1.5 Sat Mar 15 09:05:17 2008 +++ lutincommandline/src/java/org/codelutin/option/Config.java Sun Mar 16 11:08:27 2008 @@ -154,6 +154,18 @@ return null; } + public Object getProperty(String keyStr) { + ConfigPropertyKey key = getKey(keyStr); + if (safeKeys.contains(key)) { + return key.getCurrentValue(); + } + if (universe.contains(key)) { + // try default value + return key.getDefaultValue(); + } + return null; + } + public void save(BufferedOutputStream out) throws IOException { if (source == null) { return; Index: lutincommandline/src/java/org/codelutin/option/OptionAction.java diff -u lutincommandline/src/java/org/codelutin/option/OptionAction.java:1.3 lutincommandline/src/java/org/codelutin/option/OptionAction.java:1.4 --- lutincommandline/src/java/org/codelutin/option/OptionAction.java:1.3 Sun Mar 16 07:11:27 2008 +++ lutincommandline/src/java/org/codelutin/option/OptionAction.java Sun Mar 16 11:08:27 2008 @@ -64,4 +64,7 @@ protected void afterAll(C context, O... options) throws Exception { } + public Option getOption() { + return option; + } } Index: lutincommandline/src/java/org/codelutin/option/Option.java diff -u lutincommandline/src/java/org/codelutin/option/Option.java:1.1.1.1 lutincommandline/src/java/org/codelutin/option/Option.java:1.2 --- lutincommandline/src/java/org/codelutin/option/Option.java:1.1.1.1 Sat Feb 9 15:05:36 2008 +++ lutincommandline/src/java/org/codelutin/option/Option.java Sun Mar 16 11:08:27 2008 @@ -17,7 +17,7 @@ *@author Benjamin Poussin * * Copyright Code Lutin - *@version $Revision: 1.1.1.1 $ Mise a jour: $Date: 2008-02-09 15:05:36 $ par : $Author: tchemit $ + *@version $Revision: 1.2 $ Mise a jour: $Date: 2008-03-16 11:08:27 $ par : $Author: tchemit $ */ package org.codelutin.option; @@ -81,7 +81,7 @@ * @param named flag to say if named or not * @return the first value of the valued argument found, or null */ - protected T getValuedArgumentValue(int position, Class clazz, String key, boolean named) { + public T getValuedArgumentValue(int position, Class clazz, String key, boolean named) { return named ? filterValue(position, namedAndValued, clazz, key) : filterValue(position, valued, clazz, null); Index: lutincommandline/src/java/org/codelutin/option/ParserFailedException.java diff -u /dev/null lutincommandline/src/java/org/codelutin/option/ParserFailedException.java:1.1 --- /dev/null Sun Mar 16 11:08:32 2008 +++ lutincommandline/src/java/org/codelutin/option/ParserFailedException.java Sun Mar 16 11:08:27 2008 @@ -0,0 +1,101 @@ +package org.codelutin.option; + +import static org.codelutin.i18n.I18n._; + +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.io.Writer; +import java.util.Arrays; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +/** @author chemit */ +public class ParserFailedException extends Exception { + + private static final long serialVersionUID = 1946217922235980142L; + private ParserException[] errors; + private Map unusedArguments; + private String[] arguments; + + + public ParserFailedException(String message) { + super(message); + } + + public ParserFailedException(Throwable cause) { + super(cause); + } + + public ParserFailedException(String message, ParserException[] errors, String[] arguments, Map unusedArguments) { + super(message); + this.errors = errors; + this.arguments = arguments; + this.unusedArguments = unusedArguments; + } + + public int getNbErrors() { + return errors == null ? 0 : errors.length; + } + + public int getNbUnsued() { + return unusedArguments == null ? 0 : unusedArguments.size(); + } + + public ParserException[] getErrors() { + return errors; + } + + public void printStackTrace() { + PrintWriter w = new PrintWriter(System.err); + printStackTrace(w); + w.close(); + } + + public void printStackTrace(PrintStream s) { + printErrors(new OutputStreamWriter(s)); + super.printStackTrace(s); + s.flush(); + } + + public void printStackTrace(PrintWriter s) { + printErrors(s); + super.printStackTrace(s); + s.flush(); + } + + /** + * Imprime dans un writer les erreurs rencontrées pendant l'analyse. + * + * @param w le writer à utiliser + */ + protected void printErrors(Writer w) { + boolean hasFailed = errors != null && errors.length > 0; + + try { + w.append(_("lutinutil.parserdef.printError", Arrays.toString(arguments))).append('\n'); + if (!unusedArguments.isEmpty()) { + Set unsedPos = unusedArguments.keySet(); + w.append(_("lutinutil.parserdef.printError.unused.head", unsedPos.size())); + Iterator itr = unsedPos.iterator(); + for (int i = 0, j = unsedPos.size(); i < j; i++) { + int pos = itr.next(); + w.append(_("lutinutil.parserdef.printError.unused", i + 1, j, pos)); + w.append(unusedArguments.get(i)); + } + } + if (hasFailed) { + //w.append(_("lutinutil.parserdef.printError.head", errors.length)); + for (int i = 0, j = errors.length; i < j; i++) { + w.append(_("lutinutil.parserdef.printError.error", i + 1, j)); + w.append(errors[i].toString()); + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } + } + +}