How to use

createArgument

method

in

org.apache.tools.ant.types.Commandline

/**
 * flag to create backups; optional, default=false
 * @param backups if true create backups
 */
public void setBackups(boolean backups) {
  if (backups) {
    cmd.createArgument().setValue("-b");
  }
}

/**
 * flag to ignore whitespace differences; default=false
 * @param ignore if true ignore whitespace differences
 */
public void setIgnorewhitespace(boolean ignore) {
  if (ignore) {
    cmd.createArgument().setValue("-l");
  }
}

/**
 * Set the location of the extensions directories.
 *
 * @param path the string version of the path.
 * @deprecated since 1.5.x.
 *             Use the {@link #setExtdirs(Path)} version.
 */
@Deprecated
public void setExtdirs(final String path) {
  cmd.createArgument().setValue("-extdirs");
  cmd.createArgument().setValue(path);
}

/**
 * Specify the file containing the overview to be included in the generated
 * documentation.
 *
 * @param f the file containing the overview.
 */
public void setOverview(final File f) {
  cmd.createArgument().setValue("-overview");
  cmd.createArgument().setFile(f);
}

/**
 * Output file encoding name.
 *
 * @param enc name of the encoding to use.
 */
public void setDocencoding(final String enc) {
  cmd.createArgument().setValue("-docencoding");
  cmd.createArgument().setValue(enc);
  docEncoding = enc;
}

/**
 * Set the maximum memory to be used by the javadoc process
 *
 * @param max a string indicating the maximum memory according to the
 *        JVM conventions (e.g. 128m is 128 Megabytes)
 */
public void setMaxmemory(final String max) {
  cmd.createArgument().setValue("-J-Xmx" + max);
}

/**
 * Specifies the CSS stylesheet file to use.
 *
 * @param f the file with the CSS to use.
 */
public void setStylesheetfile(final File f) {
  cmd.createArgument().setValue("-stylesheetfile");
  cmd.createArgument().setFile(f);
}

/**
 * Specifies the HTML help file to use.
 *
 * @param f the file containing help content.
 */
public void setHelpfile(final File f) {
  cmd.createArgument().setValue("-helpfile");
  cmd.createArgument().setFile(f);
}

/**
 * Work silently unless an error occurs; optional, default=false
 * @param q if true suppress set the -s option on the patch command
 */
public void setQuiet(boolean q) {
  if (q) {
    cmd.createArgument().setValue("-s");
  }
}

/**
 * Assume patch was created with old and new files swapped; optional,
 * default=false
 * @param r if true set the -R option on the patch command
 */
public void setReverse(boolean r) {
  if (r) {
    cmd.createArgument().setValue("-R");
  }
}

/**
 * Set the directory where the Javadoc output will be generated.
 *
 * @param dir the destination directory.
 */
public void setDestdir(final File dir) {
  destDir = dir;
  cmd.createArgument().setValue("-d");
  cmd.createArgument().setFile(destDir);
}

/**
 * Set the location of the extensions directories.
 *
 * @param path a path containing the extension directories.
 */
public void setExtdirs(final Path path) {
  cmd.createArgument().setValue("-extdirs");
  cmd.createArgument().setPath(path);
}

private void doDocFilesSubDirs(final Commandline toExecute) {
  if (docFilesSubDirs) {
    toExecute.createArgument().setValue("-docfilessubdirs");
    if (excludeDocFilesSubDir != null && !excludeDocFilesSubDir.trim().isEmpty()) {
      toExecute.createArgument().setValue("-excludedocfilessubdir");
      toExecute.createArgument().setValue(excludeDocFilesSubDir);
    }
  }
}

/**
 * The name of a file to send the output to, instead of patching
 * the file(s) in place; optional.
 * @param file the file to send the output to
 * @since Ant 1.6
 */
public void setDestfile(File file) {
  if (file != null) {
    cmd.createArgument().setValue("-o");
    cmd.createArgument().setFile(file);
  }
}

/**
 * Utility method to add an argument to the command line conditionally
 * based on the given flag.
 *
 * @param b the flag which controls if the argument is added.
 * @param arg the argument value.
 */
private void addArgIf(final boolean b, final String arg) {
  if (b) {
    cmd.createArgument().setValue(arg);
  }
}

/**
 * Set the local to use in documentation generation.
 *
 * @param locale the locale to use.
 */
public void setLocale(final String locale) {
  // createArgument(true) is necessary to make sure -locale
  // is the first argument (required in 1.3+).
  cmd.createArgument(true).setValue(locale);
  cmd.createArgument(true).setValue("-locale");
}

/**
 * Set the encoding name of the source files,
 *
 * @param enc the name of the encoding for the source files.
 */
public void setEncoding(final String enc) {
  cmd.createArgument().setValue("-encoding");
  cmd.createArgument().setValue(enc);
}

/**
 * Append the arguments to the existing command.
 * @param line an array of arguments to append.
 */
public void addArguments(String[] line) {
  for (String l : line) {
    createArgument().setValue(l);
  }
}

/**
 * This method adds a command line argument to an external command.
 *
 * I do not understand what this method does in this class ???
 * particularly not why it is public ????
 * AntoineLL July 23d 2003
 *
 * @param c  command line to which one argument should be added
 * @param arg argument to add
 */
public void addCommandArgument(Commandline c, String arg) {
  c.createArgument().setValue(arg);
}

private void doSourcePath(final Commandline toExecute, final Path sourceDirs) {
  if (!sourceDirs.isEmpty()) {
    toExecute.createArgument().setValue("-sourcepath");
    toExecute.createArgument().setPath(sourceDirs);
  }
}