Define verbosity levels with an enumeration.

src/main/java/cryptator/Cryptagen.java

@@ -16,13 +16,12 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import cryptator.cmd.AbstractOptionsParser;
 import cryptator.cmd.CryptaBiConsumer;
+import cryptator.cmd.OptionsParserWithLog;
 import cryptator.cmd.WordArray;
 import cryptator.config.CryptagenConfig;
 import cryptator.gen.CryptaListGenerator;
 import cryptator.solver.CryptaModelException;
-import cryptator.solver.CryptaSolver;
 
 public final class Cryptagen {
 
@@ -44,6 +43,8 @@ public static int doMain(final String[] args) {
             final WordArray words = buildWords(config.getArguments(), config);
             if (words != null) {
                 return generate(words, config);
+            } else {
+                LOGGER.log(Level.WARNING, "Empty word list.");
             }
         }
         JULogUtil.flushLogs();
@@ -96,25 +97,14 @@ private static WordArray buildWords(final List<String> arguments, final Cryptage
         }
     }
 
-    private static final class CryptagenOptionsParser extends AbstractOptionsParser<CryptagenConfig> {
+    private static final class CryptagenOptionsParser extends OptionsParserWithLog<CryptagenConfig> {
 
-        protected CryptagenOptionsParser() {
-            super(Cryptagen.class, new CryptagenConfig());
-        }
+        private static final String ARG_NAME = "WORDS...";
 
-        @Override
-        protected void configureLoggers() {
-            if (config.isVerbose()) {
-                JULogUtil.configureLoggers(Level.ALL);
-            } else {
-                JULogUtil.setLevel(Level.WARNING, CryptaSolver.LOGGER);
-            }
+        protected CryptagenOptionsParser() {
+            super(Cryptagen.class, new CryptagenConfig(), ARG_NAME, JULogUtil.getDefaultLogManager());
         }
 
-        @Override
-        public String getArgumentName() {
-            return "WORDS...";
-        }
     }
 
     private static CryptaBiConsumer buildBiConsumer(final CryptagenConfig config) {
@@ -127,6 +117,7 @@ private static CryptaBiConsumer buildBiConsumer(final CryptagenConfig config) {
     }
 
     private static int generate(final WordArray words, final CryptagenConfig config) {
+        LOGGER.log(Level.CONFIG, () -> "Word List Features:\n" + words.toDimacs());
         final CryptaListGenerator gen = new CryptaListGenerator(words, config, LOGGER);
         final CryptaBiConsumer cons = buildBiConsumer(config);
         try {

src/main/java/cryptator/Cryptamancer.java

@@ -12,9 +12,9 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import cryptator.cmd.AbstractOptionsParser;
+import cryptator.cmd.OptionsParserWithLog;
 import cryptator.config.CryptaConfig;
-import cryptator.config.CryptamancerConfig;
+import cryptator.config.CryptaLogConfig;
 import cryptator.game.CryptaGameDecision;
 import cryptator.game.CryptaGameEngine;
 import cryptator.game.CryptaGameException;
@@ -29,22 +29,12 @@ public final class Cryptamancer {
 
     public static final Logger LOGGER = Logger.getLogger(Cryptamancer.class.getName());
 
-    private static class CryptamancerOptionsParser extends AbstractOptionsParser<CryptamancerConfig> {
+    private static class CryptamancerOptionsParser extends OptionsParserWithLog<CryptaLogConfig> {
 
-        protected CryptamancerOptionsParser() {
-            super(Cryptamancer.class, new CryptamancerConfig());
-        }
-
-        @Override
-        protected void configureLoggers() {
-            if (config.isVerbose()) {
-                JULogUtil.setLevel(Level.CONFIG, getLogger(), CryptaGameEngine.LOGGER);
-            }
-        }
+        private static final String ARG_NAME = "CRYPTARITHM";
 
-        @Override
-        public String getArgumentName() {
-            return "CRYPTARITHM";
+        protected CryptamancerOptionsParser() {
+            super(Cryptamancer.class, new CryptaLogConfig(), ARG_NAME, JULogUtil.getDefaultLogManager());
         }
 
         @Override
@@ -57,7 +47,7 @@ private Cryptamancer() {
         super();
     }
 
-    public static ICryptaNode parseCryptarithm(final CryptamancerConfig config) {
+    public static ICryptaNode parseCryptarithm(final CryptaLogConfig config) {
         final String cryptarithm = config.getArguments().get(0);
         try {
             return Cryptator.parseCryptarithm(cryptarithm, new CryptaParserWrapper(), LOGGER);
@@ -111,7 +101,7 @@ public static void main(final String[] args) throws Exception {
         if (!optparser.parseOptions(args)) {
             return;
         }
-        final CryptamancerConfig config = optparser.getConfig();
+        final CryptaLogConfig config = optparser.getConfig();
 
         final ICryptaNode node = parseCryptarithm(config);
         if (node == null) {

src/main/java/cryptator/Cryptator.java

@@ -11,8 +11,8 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-import cryptator.cmd.AbstractOptionsParser;
 import cryptator.cmd.CryptaBiConsumer;
+import cryptator.cmd.OptionsParserWithLog;
 import cryptator.config.CryptatorConfig;
 import cryptator.parser.CryptaParserException;
 import cryptator.parser.CryptaParserWrapper;
@@ -54,22 +54,12 @@ public static int doMain(final String[] args) {
         return exitCode;
     }
 
-    private static class CryptatorOptionsParser extends AbstractOptionsParser<CryptatorConfig> {
+    private static class CryptatorOptionsParser extends OptionsParserWithLog<CryptatorConfig> {
 
-        CryptatorOptionsParser() {
-            super(Cryptator.class, new CryptatorConfig());
-        }
-
-        @Override
-        public String getArgumentName() {
-            return "CRYPTARITHMS...";
-        }
+        private static final String ARG_NAME = "CRYPTARITHMS...";
 
-        @Override
-        protected void configureLoggers() {
-            if (config.isVerbose()) {
-                JULogUtil.configureLoggers(Level.ALL);
-            }
+        CryptatorOptionsParser() {
+            super(Cryptator.class, new CryptatorConfig(), ARG_NAME, JULogUtil.getDefaultLogManager());
         }
     }
 

src/main/java/cryptator/JULogUtil.java

@@ -18,6 +18,7 @@
 
 import cryptator.game.CryptaGameEngine;
 import cryptator.solver.CryptaSolver;
+import cryptator.specs.ICryptaLogManager;
 
 public final class JULogUtil {
 
@@ -62,7 +63,7 @@ public static void setLevel(final Level level, final Logger... loggers) {
     }
 
     public static void flushLogs(final Logger logger) {
-        logger.log(Level.FINE, "Flush logger {0}", logger.getName());
+        logger.log(Level.FINEST, "Flush logger {0}", logger.getName());
         for (Handler handler : logger.getHandlers()) {
             handler.flush();
         }
@@ -78,6 +79,33 @@ public static void flushLogs() {
                 flushLogs(manager.getLogger(name));
             }
         }
+    }
+
+    public static final ICryptaLogManager DEFAULT_LOG_MANAGER = new DefaultLogManager();
+
+    public static ICryptaLogManager getDefaultLogManager() {
+        return DEFAULT_LOG_MANAGER;
+    }
+
+    private static class DefaultLogManager implements ICryptaLogManager {
+
+        @Override
+        public void setQuiet() {
+            ICryptaLogManager.super.setQuiet();
+            JULogUtil.setLevel(Level.INFO, Cryptagen.LOGGER, Cryptator.LOGGER);
+        }
+
+        @Override
+        public void setNormal() {
+            ICryptaLogManager.super.setNormal();
+            JULogUtil.setLevel(Level.CONFIG, Cryptagen.LOGGER);
+        }
+
+        @Override
+        public void setVerbose() {
+            ICryptaLogManager.super.setVerbose();
+            JULogUtil.setLevel(Level.FINE, Cryptagen.LOGGER);
+        }
 
     }
 

src/main/java/cryptator/cmd/AbstractOptionsParser.java

@@ -9,6 +9,7 @@
 package cryptator.cmd;
 
 import java.io.ByteArrayOutputStream;
+import java.io.OutputStreamWriter;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -24,21 +25,26 @@ public abstract class AbstractOptionsParser<E extends CryptaConfig> {
 
     protected final E config;
 
-    protected AbstractOptionsParser(final Class<?> mainClass, final E config) {
+    private final String argumentName;
+
+    protected AbstractOptionsParser(final Class<?> mainClass, final E config, final String argumentName) {
         super();
         this.mainClass = mainClass;
         this.config = config;
+        this.argumentName = argumentName;
     }
 
     public final Logger getLogger() {
         return Logger.getLogger(mainClass.getName());
     }
 
-    protected final String getCommandName() {
+    private final String getCommandName() {
         return mainClass.getName();
     }
 
-    protected abstract String getArgumentName();
+    private final String getArgumentName() {
+        return argumentName;
+    }
 
     protected abstract void configureLoggers();
 
@@ -69,7 +75,8 @@ public final boolean parseOptions(final String[] args) {
             configureLoggers();
             if (checkConfiguration()) {
                 if (checkArguments()) {
-                    getLogger().log(Level.CONFIG, "Parse options [OK]\n{0}", config);
+                    getLogger().log(Level.CONFIG, "Parse options [OK]");
+                    getLogger().log(Level.FINE, "Configuration:\n{0}", config);
                     return true;
                 } else {
                     getLogger().log(Level.SEVERE, "Parse arguments [FAIL]\n{0}", config.getArguments());
@@ -83,25 +90,35 @@ public final boolean parseOptions(final String[] args) {
         }
 
         if (getLogger().isLoggable(Level.INFO)) {
-            getLogger().info(buildHelpMessage(parser));
+            getLogger().info(buildHelpMessage(parser, OptionHandlerFilter.PUBLIC));
         }
         return false;
 
     }
 
-    private String buildHelpMessage(CmdLineParser parser) {
-        StringBuilder b = new StringBuilder();
-        b.append(" Help:\n");
-        b.append("java ").append(getCommandName()).append(" [options...] ").append(getArgumentName()).append("\n");
+    private String printUsage(CmdLineParser parser, OptionHandlerFilter filter) {
         final ByteArrayOutputStream os = new ByteArrayOutputStream();
-        parser.printUsage(os);
-        b.append(os.toString());
-        b.append("\nExamples:");
-        b.append("\njava ").append(getCommandName()).append(" ")
-                .append(parser.printExample(OptionHandlerFilter.REQUIRED)).append(" ").append(getArgumentName());
+        parser.printUsage(new OutputStreamWriter(os), null, filter);
+        return os.toString();
+    }
+
+    private String printExample(String options) {
+        return "java " + getCommandName() + " " + options + " " + getArgumentName();
+    }
+
+    private String printExample(CmdLineParser parser, OptionHandlerFilter filter) {
+        return printExample(parser.printExample(filter));
+    }
 
-        b.append("\njava ").append(getCommandName()).append(" ").append(parser.printExample(OptionHandlerFilter.ALL))
-                .append(" ").append(getArgumentName());
+    private String buildHelpMessage(CmdLineParser parser, OptionHandlerFilter filter) {
+        StringBuilder b = new StringBuilder();
+        b.append(" Help message:\n");
+        b.append(printExample("[options...]")).append("\n");
+        b.append(printUsage(parser, filter));
+        b.append("\nExamples:");
+        b.append("\n").append(printExample(parser, OptionHandlerFilter.REQUIRED));
+        b.append("\n").append(printExample(parser, filter));
         return b.toString();
     }
+
 }

src/main/java/cryptator/cmd/CryptaBiConsumer.java

@@ -133,7 +133,7 @@ private class SolutionChecker implements BiConsumer<ICryptaNode, ICryptaSolution
         public void accept(final ICryptaNode n, final ICryptaSolution s) {
             try {
                 if (eval.evaluate(n, s, base).compareTo(BigInteger.ZERO) != 0) {
-                    logger.log(Level.CONFIG, "Eval cryptarithm solution #{0} [OK]", solutionCount);
+                    logger.log(Level.FINE, "Eval cryptarithm solution #{0} [OK]", solutionCount);
                 } else {
                     errorCount++;
                     logger.log(Level.SEVERE, "Eval cryptarithm solution #{0} [KO]", solutionCount);

src/main/java/cryptator/cmd/OptionsParserWithLog.java

@@ -0,0 +1,28 @@
+/**
+ * This file is part of cryptator, https://github.com/arnaud-m/cryptator
+ *
+ * Copyright (c) 2022, Université Côte d'Azur. All rights reserved.
+ *
+ * Licensed under the BSD 3-clause license.
+ * See LICENSE file in the project root for full license information.
+ */
+package cryptator.cmd;
+
+import cryptator.config.CryptaLogConfig;
+import cryptator.specs.ICryptaLogManager;
+
+public class OptionsParserWithLog<E extends CryptaLogConfig> extends AbstractOptionsParser<E> {
+
+    private final ICryptaLogManager logManager;
+
+    public OptionsParserWithLog(Class<?> mainClass, E config, String argumentName, ICryptaLogManager logManager) {
+        super(mainClass, config, argumentName);
+        this.logManager = logManager;
+    }
+
+    @Override
+    protected void configureLoggers() {
+        config.getVerbosity().applyTo(logManager);
+    }
+
+}

src/main/java/cryptator/cmd/Verbosity.java

@@ -0,0 +1,37 @@
+/**
+ * This file is part of cryptator, https://github.com/arnaud-m/cryptator
+ *
+ * Copyright (c) 2022, Université Côte d'Azur. All rights reserved.
+ *
+ * Licensed under the BSD 3-clause license.
+ * See LICENSE file in the project root for full license information.
+ */
+package cryptator.cmd;
+
+import cryptator.specs.ICryptaLogManager;
+
+public enum Verbosity {
+    SILENT, QUIET, NORMAL, VERBOSE, VERY_VERBOSE, DEBUG;
+
+    public void applyTo(ICryptaLogManager manager) {
+        setVerbosity(manager, this);
+    }
+
+    public static void setVerbosity(ICryptaLogManager manager, Verbosity verbosity) {
+        if (verbosity != null && manager != null) {
+            if (verbosity.equals(SILENT)) {
+                manager.setSilent();
+            } else if (verbosity.equals(QUIET)) {
+                manager.setQuiet();
+            } else if (verbosity.equals(NORMAL)) {
+                manager.setNormal();
+            } else if (verbosity.equals(VERBOSE)) {
+                manager.setVerbose();
+            } else if (verbosity.equals(VERY_VERBOSE)) {
+                manager.setVeryVerbose();
+            } else if (verbosity.equals(DEBUG)) {
+                manager.setDebug();
+            }
+        }
+    }
+}

src/main/java/cryptator/cmd/WordArray.java

@@ -70,6 +70,11 @@ public final int getUB() {
         return ub;
     }
 
+    public String toDimacs() {
+        return "c WORDS " + words.length + "\nc RIGHT_MEMBER " + (hasRightMember() ? "FIXED" : "FREE")
+                + "\nc DOUBLY_TRUE " + (isDoublyTrue() ? lb + "-" + ub : "NO");
+    }
+
     @Override
     public String toString() {
         return "WordArray [words=" + Arrays.toString(words) + ", rightMember=" + rightMember + ", lb=" + lb + ", ub="