public DecompilerSettings getDecompilerSettings() {
   CommandLineOptions options = new CommandLineOptions();
   JCommander jCommander = new JCommander(options); // TODO remove dependency on JCommander?
   String[] args = new String[Settings.values().length * 2];
   int index = 0;
   for (TransformerSettings.Setting setting : Settings.values()) {
     args[index++] = "--" + setting.getParam();
     args[index++] = String.valueOf(setting.isEnabled());
   }
   jCommander.parse(args);
   DecompilerSettings settings = new DecompilerSettings();
   settings.setFlattenSwitchBlocks(options.getFlattenSwitchBlocks());
   settings.setForceExplicitImports(!options.getCollapseImports());
   settings.setForceExplicitTypeArguments(options.getForceExplicitTypeArguments());
   settings.setRetainRedundantCasts(options.getRetainRedundantCasts());
   settings.setShowSyntheticMembers(options.getShowSyntheticMembers());
   settings.setExcludeNestedTypes(options.getExcludeNestedTypes());
   settings.setOutputDirectory(options.getOutputDirectory());
   settings.setIncludeLineNumbersInBytecode(options.getIncludeLineNumbers());
   settings.setRetainPointlessSwitches(options.getRetainPointlessSwitches());
   settings.setUnicodeOutputEnabled(options.isUnicodeOutputEnabled());
   settings.setMergeVariables(options.getMergeVariables());
   settings.setShowDebugLineNumbers(options.getShowDebugLineNumbers());
   settings.setSimplifyMemberReferences(options.getSimplifyMemberReferences());
   settings.setDisableForEachTransforms(options.getDisableForEachTransforms());
   settings.setTypeLoader(new InputTypeLoader());
   if (options.isRawBytecode()) {
     settings.setLanguage(Languages.bytecode());
   } else if (options.isBytecodeAst()) {
     settings.setLanguage(
         options.isUnoptimized() ? Languages.bytecodeAstUnoptimized() : Languages.bytecodeAst());
   }
   return settings;
 }
  public static void main(String[] args) throws Throwable {
    StreamFile2RDF streamfile2rdf = new StreamFile2RDF();
    JCommander com = new JCommander(streamfile2rdf, args);
    com.setProgramName("stream2file");

    if (streamfile2rdf.parameters.size() == 1) {
      System.err.println("No output file specified, writing to standard output.");
      streamfile2rdf.rdfOutput = "stdout";
      streamfile2rdf.InputStream = streamfile2rdf.parameters.get(0);

    } else if (streamfile2rdf.parameters.size() == 2) {
      streamfile2rdf.InputStream = streamfile2rdf.parameters.get(0);
      streamfile2rdf.rdfOutput = streamfile2rdf.parameters.get(1);

    } else {
      com.usage();
      System.exit(1);
    }

    System.out.println(
        "Converting '"
            + streamfile2rdf.InputStream
            + "' to Stream File'"
            + streamfile2rdf.rdfOutput
            + "'");

    streamfile2rdf.execute();
    System.out.println("Bye!");
    System.exit(0);
  }
Exemple #3
0
  @Override
  public int run(String[] args) throws Exception {
    try {
      jc.parse(args);
    } catch (ParameterException pe) {
      System.err.println(pe.getMessage());
      return 1;
    }

    if ("help".equals(jc.getParsedCommand())) {
      return help.usage(jc, COMMANDS);
    }

    Command cmd = COMMANDS.get(jc.getParsedCommand());
    if (cmd == null) {
      return help.usage(jc, COMMANDS);
    }
    try {
      return cmd.execute(getConf());
    } catch (CommandException ce) {
      System.err.println("Command Error: " + ce.getMessage());
      return 1;
    } catch (IllegalArgumentException e) {
      System.err.println("Argument Error: " + e.getMessage());
      return 1;
    } catch (IllegalStateException e) {
      System.err.println("State Error: " + e.getMessage());
      return 1;
    }
  }
  static Configuration parseConfiguration(String[] args) {
    Configuration configuration = new Configuration();
    JCommander jCommander;

    List<String> crateArgs = new ArrayList<>();
    List<String> safeArgs = new ArrayList<>(args.length);
    for (String arg : args) {
      if (HELP_OPTIONS.contains(arg)) {
        jCommander = new JCommander(configuration);
        jCommander.usage();
        System.exit(1);
      }
      if (arg.startsWith("-Des.")) {
        String argKey = arg.split("\\=")[0];
        if (PROTECTED_CRATE_ARGS.contains(argKey)) {
          throw new IllegalArgumentException(
              String.format(
                  "Argument \"%s\" is protected and managed by the framework. "
                      + "It cannot be set by the user",
                  argKey));
        } else {
          crateArgs.add(arg);
        }
      } else {
        safeArgs.add(arg);
      }
    }
    jCommander = new JCommander(configuration, safeArgs.toArray(new String[safeArgs.size()]));
    configuration.crateArgs(crateArgs);
    LOGGER.debug("args: {}", configuration);
    return configuration;
  }
Exemple #5
0
 public Main() {
   jc = new JCommander(this);
   jc.addCommand("help", help, "-help", "--help");
   for (Map.Entry<String, Command> e : COMMANDS.entrySet()) {
     jc.addCommand(e.getKey(), e.getValue());
   }
 }
 public static Parameters parseArgs(String[] args) {
   Parameters parameters = new Parameters();
   JCommander jc = new JCommander(parameters, args);
   jc.setProgramName(name);
   if (parameters.help) {
     jc.usage();
   }
   return parameters;
 }
  TrackAnalyzer(String[] args) throws Exception {

    JCommander jcommander = new JCommander(c, args);
    jcommander.setProgramName("TrackAnalyzer");
    if ((c.filenames.size() == 0 && Utils.isEmpty(c.filelist)) || c.help) {
      jcommander.usage();
      System.exit(-1);
    }
    if (c.debug) {
      Logger.getLogger(TrackAnalyzer.class.getName()).setLevel(Level.ALL);
    } else {
      Logger.getLogger(TrackAnalyzer.class.getName()).setLevel(Level.WARNING);
    }
    // we have a list, read all the filenames in the list and
    // collect them in 'filenames'
    if (!Utils.isEmpty(c.filelist)) {
      try {
        // use buffering, reading one line at a time
        // FileReader always assumes default encoding is OK!
        BufferedReader input = new BufferedReader(new FileReader(new File(c.filelist)));
        try {
          String line = null; // not declared within while loop
          /*
           * readLine is a bit quirky :
           * it returns the content of a line MINUS the newline.
           * it returns null only for the END of the stream.
           * it returns an empty String if two newlines appear in a row.
           */
          while ((line = input.readLine()) != null) {
            filenames.add(line);
          }
        } finally {
          input.close();
        }
      } catch (IOException ex) {
        ex.printStackTrace();
        System.exit(-1);
      }
    }
    // add filenames from command line
    filenames.addAll(c.filenames);

    if (!Utils.isEmpty(c.writeList)) {
      try {
        writeListWriter = new BufferedWriter(new FileWriter(c.writeList));
      } catch (IOException ex) {
        Logger.getLogger(TrackAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    k = new KeyFinder();
    p = new Parameters();
    p.setHopSize(8192);
  }
  public static void main(String[] args) {
    /* Parse and validate command line parameters */
    CommandLineParameters params = new CommandLineParameters();
    try {
      JCommander jc = new JCommander(params, args);
      if (params.help) {
        jc.setProgramName("java -Xmx[several]G -jar otp.jar");
        jc.usage();
        System.exit(0);
      }
      params.infer();
    } catch (ParameterException pex) {
      LOG.error("Parameter error: {}", pex.getMessage());
      System.exit(1);
    }

    OTPConfigurator configurator = new OTPConfigurator(params);

    // start graph builder, if asked for
    GraphBuilderTask graphBuilder = configurator.builderFromParameters();
    if (graphBuilder != null) {
      graphBuilder.run();
      // Inform configurator which graph is to be used for in-memory handoff.
      if (params.inMemory) configurator.makeGraphService(graphBuilder.getGraph());
    }

    // start visualizer, if asked for
    GraphVisualizer graphVisualizer = configurator.visualizerFromParameters();
    if (graphVisualizer != null) {
      graphVisualizer.run();
    }

    // start web server, if asked for
    GrizzlyServer grizzlyServer = configurator.serverFromParameters();
    if (grizzlyServer != null) {
      while (true) { // Loop to restart server on uncaught fatal exceptions.
        try {
          grizzlyServer.run();
          return;
        } catch (Throwable throwable) {
          throwable.printStackTrace();
          LOG.error(
              "An uncaught {} occurred inside OTP. Restarting server.",
              throwable.getClass().getSimpleName());
        }
      }
    }

    if (graphBuilder == null && graphVisualizer == null && grizzlyServer == null) {
      LOG.info("Nothing to do. Use --help to see available tasks.");
      ;
    }
  }
Exemple #9
0
 private void showHelpForOneCommand(List<ICommand> commands, PrintWriter pw) {
   String commandName = commandNames.get(0);
   for (ICommand command : commands) {
     if (commandName.equals(command.getName())) {
       JCommander commander = new JCommander();
       commander.setProgramName(command.getName());
       commander.addObject(command);
       StringBuilder sb = new StringBuilder();
       sb.append("\n");
       commander.usage(sb);
       pw.println(sb.toString());
     }
   }
 }
  /**
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) throws RuntimeException, Exception {
    is = new ImageSimilarity();

    jc = new JCommander(is);
    jc.setProgramName("ImageSimilarity");

    try {
      jc.parse(args);
    } catch (ParameterException pe) {
      System.out.println("Wrong console parameters. See usage of ImageSimilarity below:");
      jc.usage();
    }

    is.setup();
  }
Exemple #11
0
  public static void main(String[] args) throws Exception {
    System.setProperty("javax.net.debug", "none");
    App app = new App();
    AppParameters params = new AppParameters();
    JCommander jcmd = new JCommander(params);

    try {
      jcmd.parse(args);

      app.setParams(params);
      app.scepCLI();
    } catch (ParameterException e) {
      jcmd.usage();
    }
  }
 public static void main(String[] args) {
   PublishNanopub obj = new PublishNanopub();
   JCommander jc = new JCommander(obj);
   try {
     jc.parse(args);
   } catch (ParameterException ex) {
     jc.usage();
     System.exit(1);
   }
   try {
     obj.run();
   } catch (Exception ex) {
     ex.printStackTrace();
     System.exit(1);
   }
 }
  private void run() {

    try {
      graph = Graph.load(new File(graphPath), Graph.LoadLevel.DEBUG);
    } catch (Exception e) {
      LOG.error("Exception while loading graph from " + graphPath);
      e.printStackTrace();
      return;
    }
    LOG.info("done loading graph.");

    if (outPath != null) {
      try {
        writer = new HTMLWriter(outPath);
      } catch (FileNotFoundException ex) {
        java.util.logging.Logger.getLogger(AnnotationsToHTML.class.getName())
            .log(Level.SEVERE, null, ex);
        LOG.error("Exception while opening output file {}:{}", outPath, ex.getMessage());
        return;
      }
    } else {
      writer = new HTMLWriter(System.out);
    }

    String command = jc.getParsedCommand();
    if (command.equals("annotate")) {
      annotationEndpoints.run();
    }

    if (outPath != null) {
      LOG.info("HTML is in {}", outPath);
    }

    writer.close();
  }
Exemple #14
0
  public static void main(String[] args) throws Exception {
    Options opts = new Options();

    JCommander jcmd = new JCommander(opts);
    jcmd.setProgramName("itunesclone");

    jcmd.parse(args);

    if (opts.help) {
      jcmd.usage();
      return;
    }

    RunType runType = opts.dryRun ? RunType.DRY_RUN : RunType.THE_REAL_DEAL;

    CloneProgressReporter progressReporter = null;
    CountingProgressReporter counter = null;

    switch (opts.logLevel) {
      case 0:
        progressReporter = new SilentProgressReporter();
        break;

      case 1:
        counter = new CountingProgressReporter();
        progressReporter = counter;
        break;

      case 2:
        TextProgressReporter tpr = new TextProgressReporter(System.out, false);
        counter = new CountingProgressReporter();
        progressReporter = new ChainedProgressReporter(tpr, counter);
        break;
    }

    assert (progressReporter != null);

    FFMPEGMetadataCache.getInstance().setCacheDirectory(opts.cache.toPath());

    (new DirCloner(runType, opts.codec))
        .clone(opts.src.toPath(), opts.dest.toPath(), progressReporter);

    if (opts.logLevel != 0) {
      counter.printStatistics(System.out);
      FFMPEGMetadataCache.getInstance().printStatistics(System.out);
    }
  }
Exemple #15
0
  private static void initParameters(String[] args) {
    Parameters parameters = new Parameters();
    JCommander jCommander = new JCommander(parameters);

    try {
      jCommander.parse(args);

      precision = parameters.getPrecision() + 1;
      tasks = parameters.getTasks();
      quiet = parameters.getQuiet();
      fileName = parameters.getFileName();

    } catch (ParameterException ex) {
      System.out.println(MESSAGE_COULD_NOT_GET_PARAMETERS);
      jCommander.usage();
    }
  }
  public AnnotationsToHTML(String[] args) {
    jc = new JCommander(this);
    jc.addCommand(annotationEndpoints);

    try {
      jc.parse(args);
    } catch (Exception e) {
      System.out.println(e.getMessage());
      jc.usage();
      System.exit(1);
    }

    if (help || jc.getParsedCommand() == null) {
      jc.usage();
      System.exit(0);
    }
  }
 /**
  * Test method for {@link
  * org.verapdf.cli.VeraPdfCliProcessor#createProcessorFromArgs(org.verapdf.cli.commands.VeraCliArgParser)}
  * .
  *
  * @throws IOException
  * @throws FileNotFoundException
  * @throws ProfileException
  * @throws JAXBException
  */
 @Test
 public final void testCreateProcessorFromArgsNewProfile()
     throws ProfileException, FileNotFoundException, IOException, JAXBException {
   VeraCliArgParser parser = new VeraCliArgParser();
   JCommander jCommander = VeraPdfCliProcessorTest.initialiseJCommander(parser);
   jCommander.parse(new String[] {});
   VeraPdfCliProcessor proc = VeraPdfCliProcessor.createProcessorFromArgs(parser);
   assertTrue(proc.validator.getProfile().getPDFAFlavour() == PDFAFlavour.PDFA_1_B);
   ProfileDirectory directory = Profiles.getVeraProfileDirectory();
   assertTrue(directory.getValidationProfiles().size() > 0);
   for (ValidationProfile profile : directory.getValidationProfiles()) {
     File tmpProfile = File.createTempFile("verapdf", "profile");
     try (OutputStream os = new FileOutputStream(tmpProfile)) {
       Profiles.profileToXml(profile, os, Boolean.FALSE);
       testWithProfileFile(profile.getPDFAFlavour(), tmpProfile);
     }
   }
 }
  private void go(String[] args) throws IOException, JSONException, TemplateException {
    Arguments arguments = new Arguments();
    JCommander jCommander = new JCommander(arguments, args);
    jCommander.setProgramName("GenerateAndroidProvider");

    if (arguments.help) {
      jCommander.usage();
      return;
    }

    getConfig(arguments.inputDir);

    loadModel(arguments.inputDir);
    generateColumns(arguments);
    generateWrappers(arguments);
    generateContentProvider(arguments);
    generateSqliteHelper(arguments);
  }
  public static void main(String[] argv) {
    CopyToHdfs obj = new CopyToHdfs();
    JCommander cmdr = new JCommander(obj, argv);

    // Dump the help screen if we have to
    if (obj.help || argv.length == 0) {
      cmdr.usage();
      return;
    }

    try {
      obj.copy_jsonlog();
    } catch (RuntimeException re_ex) {
      Writer result = new StringWriter();
      PrintWriter printWriter = new PrintWriter(result);
      re_ex.printStackTrace(printWriter);
      new Syslog().error(result.toString());
    }
  }
  /** @param args */
  public static void main(String... args) {
    Thread.setDefaultUncaughtExceptionHandler(new LoggedUncaughtExceptionHandler());
    GigawordIngesterRunner run = new GigawordIngesterRunner();
    JCommander jc = new JCommander(run, args);
    jc.setProgramName(GigawordIngesterRunner.class.getSimpleName());
    if (run.delegate.help) {
      jc.usage();
    }

    try {
      Path outpath = Paths.get(run.delegate.outputPath);
      IngesterParameterDelegate.prepare(outpath);

      GigawordDocumentConverter conv = new GigawordDocumentConverter();
      for (String pstr : run.delegate.paths) {
        LOGGER.debug("Running on file: {}", pstr);
        Path p = Paths.get(pstr);
        new ExistingNonDirectoryFile(p);
        Path outWithExt = outpath.resolve(p.getFileName().toString().split("\\.")[0] + ".tar.gz");

        if (Files.exists(outWithExt)) {
          if (!run.delegate.overwrite) {
            LOGGER.info(
                "File: {} exists and overwrite disabled. Not running.", outWithExt.toString());
            continue;
          } else {
            Files.delete(outWithExt);
          }
        }

        try (OutputStream os = Files.newOutputStream(outWithExt);
            GzipCompressorOutputStream gout = new GzipCompressorOutputStream(os);
            TarArchiver arch = new TarArchiver(gout)) {
          Iterator<Communication> iter = conv.gzToStringIterator(p);
          while (iter.hasNext()) {
            arch.addEntry(new ArchivableCommunication(iter.next()));
          }
        }
      }
    } catch (NotFileException | IOException e) {
      LOGGER.error("Caught exception processing.", e);
    }
  }
  /**
   * Parses command line arguments and populates this command line instance.
   *
   * <p>If the command line arguments include the "help" argument, or if the arguments have
   * incorrect values or order, then usage information is printed to {@link System#out} and the
   * program terminates.
   *
   * @param args the command line arguments
   * @return an instance of the parsed arguments object
   */
  public Arguments parse(String[] args) {

    JCommander jCommander = new JCommander(this);
    jCommander.setProgramName("jsonschema2pojo");

    try {
      jCommander.parse(args);

      if (this.showHelp) {
        jCommander.usage();
        exit(EXIT_OKAY);
      }
    } catch (ParameterException e) {
      System.err.println(e.getMessage());
      jCommander.usage();
      exit(EXIT_ERROR);
    }

    return this;
  }
 private static void testWithProfileFile(final PDFAFlavour flavour, final File profileFile)
     throws ProfileException, FileNotFoundException, IOException, JAXBException {
   String[] argVals = new String[] {"-p", "--profile"};
   VeraCliArgParser parser = new VeraCliArgParser();
   JCommander jCommander = VeraPdfCliProcessorTest.initialiseJCommander(parser);
   for (String arg : argVals) {
     jCommander.parse(new String[] {arg, profileFile.getAbsolutePath()});
     VeraPdfCliProcessor proc = VeraPdfCliProcessor.createProcessorFromArgs(parser);
     try (InputStream is = new FileInputStream(profileFile)) {
       ValidationProfile profile = Profiles.profileFromXml(is);
       assertEquals(flavour, proc.validator.getProfile().getPDFAFlavour());
       assertTrue(profile != proc.validator.getProfile());
       assertEquals(
           Profiles.profileToXml(profile, Boolean.TRUE)
               + "\n"
               + Profiles.profileToXml(proc.validator.getProfile(), Boolean.TRUE),
           profile.getRules(),
           proc.validator.getProfile().getRules());
     }
   }
 }
Exemple #23
0
  public static void main(String... args) throws Exception {
    Main main = new Main();

    JCommander commander = new JCommander(main);
    commander.setProgramName(Main.class.getName());

    try {
      commander.parse(args);
    } catch (ParameterException pe) {
      commander.usage();

      System.exit(-1);
    }

    if (main.help) {
      commander.usage();

      System.exit(0);
    }

    main.run();
  }
  public static void main(String[] args) {
    final Options options = new Options();
    JCommander jCommander = new JCommander(options);
    jCommander.setProgramName("java -jar ColorBleeding.jar");
    try {
      String inPath = "/tmp/images";
      String[] argv = {
          /* "-overwrite", */
        "-dir",
        inPath,
        "-debug",
        "-maxiterations",
        "2",
        "-outdir",
        "/tmp/result",
        "-numthreads",
        "8"
      };

      if (System.getProperty("overrideArgs", "false").equals("true")) {
        args = argv;
      }

      jCommander.parse(args);

      execute(options);

    } catch (ParameterException e) {
      logger.error(e.getMessage());
      if (jCommander != null) {
        jCommander.usage();
      }
    } catch (IOException e) {
      logger.error("Error while processing images", e);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Exemple #25
0
  public static void main(String... args) {
    CommandLineArgs parsedArgs = new CommandLineArgs();
    JCommander jc = new JCommander(parsedArgs);

    try {
      jc.parse(args);
    } catch (ParameterException e) {
      StringBuilder out = new StringBuilder(e.getLocalizedMessage()).append("\n\n");
      jc.usage(out);
      System.err.println(out.toString());
      System.exit(1);
      return;
    }
    if (parsedArgs.help) {
      jc.usage();
      return;
    }

    SpoonRunner spoonRunner =
        new SpoonRunner.Builder() //
            .setTitle(parsedArgs.title)
            .setApplicationApk(parsedArgs.apk)
            .setInstrumentationApk(parsedArgs.testApk)
            .setOutputDirectory(parsedArgs.output)
            .setDebug(parsedArgs.debug)
            .setAndroidSdk(parsedArgs.sdk)
            .setNoAnimations(parsedArgs.noAnimations)
            .setTestSize(parsedArgs.size)
            .setAdbTimeout(parsedArgs.adbTimeoutSeconds * 1000)
            .setClassName(parsedArgs.className)
            .setMethodName(parsedArgs.methodName)
            .useAllAttachedDevices()
            .build();

    if (!spoonRunner.run() && parsedArgs.failOnFailure) {
      System.exit(1);
    }
  }
 public static void main(String[] args) {
   JCommanderTwitterStream jcts = new JCommanderTwitterStream();
   new JCommander(jcts, args);
   if (jcts.isHelp()) {
     JCommander jc = new JCommander(jcts, args);
     jc.usage();
     return;
   }
   String stringKeywords = jcts.getKeywords().stream().collect(joining(" "));
   if (jcts.isStream()) {
     try {
       if (jcts.getLimit() < Integer.MAX_VALUE) {
         throw new ParameterException("You can't have stream with limit.");
       }
       streamTweets(stringKeywords, jcts.getLocation(), jcts.isHideRetweets());
     } catch (URLs.ConnectionException
         | URLs.HTTPQueryException
         | MalformedURLException
         | ParameterException
         | GeolocationSearch.NoKeyException
         | GeolocationSearch.SearchLocationException e) {
       System.err.println(e.getMessage());
       System.exit(1);
     }
   } else {
     try {
       printTweets(stringKeywords, jcts.getLocation(), jcts.getLimit(), jcts.isHideRetweets());
     } catch (TwitterException
         | URLs.ConnectionException
         | GeolocationSearch.SearchLocationException
         | MalformedURLException
         | GeolocationSearch.NoKeyException
         | URLs.HTTPQueryException e) {
       System.err.println(e.getMessage());
       System.exit(1);
     }
   }
 }
  public static void main(String[] args) throws Exception {
    EncoderConfig config = new EncoderConfig();
    JCommander jCommander = new JCommander(config, args);
    jCommander.setProgramName(CommandLineEncoder.class.getSimpleName());
    if (config.help) {
      jCommander.usage();
      return;
    }

    String outFileString = config.outputFileBase;
    if (EncoderConfig.DEFAULT_OUTPUT_FILE_BASE.equals(outFileString)) {
      outFileString += '.' + config.imageFormat.toLowerCase(Locale.ENGLISH);
    }
    Map<EncodeHintType, Object> hints = new EnumMap<>(EncodeHintType.class);
    if (config.errorCorrectionLevel != null) {
      hints.put(EncodeHintType.ERROR_CORRECTION, config.errorCorrectionLevel);
    }
    BitMatrix matrix =
        new MultiFormatWriter()
            .encode(
                config.contents.get(0), config.barcodeFormat, config.width, config.height, hints);
    MatrixToImageWriter.writeToPath(matrix, config.imageFormat, Paths.get(outFileString));
  }
  protected static HelpCommand addCommands(
      final ResourceBundle bundle, final JCommander commander) {
    final HelpCommand result = new HelpCommand(commander, bundle);

    commander.addCommand(result);
    commander.addCommand(new StartCommand());
    commander.addCommand(new StopCommand());
    commander.addCommand(new StatusCommand());
    commander.addCommand(new SamplerCommand());
    commander.addCommand(new MetadataCommand());
    commander.addCommand(new CheckCommand());
    commander.addCommand(new TestCommand());

    fixResourceBundleBug(commander, bundle);
    return result;
  }
 protected static JCommander createCommander(final ResourceBundle bundle) {
   final JCommander result = new JCommander();
   result.setAcceptUnknownOptions(false);
   result.setCaseSensitiveOptions(false);
   result.setProgramName("metrics-sampler");
   result.setColumnSize(120);
   result.setDescriptionsBundle(bundle);
   return result;
 }
Exemple #30
0
  public void printUsage() {
    JCommander jc = new JCommander(this);
    // print usage in not sorted fields order (by default its sorted by description)
    PrintStream out = System.out;
    out.println();
    out.println("jadx - dex to java decompiler, version: " + JadxDecompiler.getVersion());
    out.println();
    out.println("usage: jadx [options] " + jc.getMainParameterDescription());
    out.println("options:");

    List<ParameterDescription> params = jc.getParameters();
    Map<String, ParameterDescription> paramsMap =
        new LinkedHashMap<String, ParameterDescription>(params.size());
    int maxNamesLen = 0;
    for (ParameterDescription p : params) {
      paramsMap.put(p.getParameterized().getName(), p);
      int len = p.getNames().length();
      if (len > maxNamesLen) {
        maxNamesLen = len;
      }
    }
    Field[] fields = JadxCLIArgs.class.getDeclaredFields();
    for (Field f : fields) {
      String name = f.getName();
      ParameterDescription p = paramsMap.get(name);
      if (p == null) {
        continue;
      }
      StringBuilder opt = new StringBuilder();
      opt.append(' ').append(p.getNames());
      addSpaces(opt, maxNamesLen - opt.length() + 2);
      opt.append("- ").append(p.getDescription());
      out.println(opt);
    }
    out.println("Example:");
    out.println(" jadx -d out classes.dex");
  }