Unix4jCommandBuilder (unix4j 0.4 API)

All Superinterfaces:

Cat.Interface<Unix4jCommandBuilder>, Cd.Interface<Unix4jCommandBuilder>, CommandBuilder, CommandInterface<Unix4jCommandBuilder>, Cut.Interface<Unix4jCommandBuilder>, Echo.Interface<Unix4jCommandBuilder>, Find.Interface<Unix4jCommandBuilder>, From.Interface<Unix4jCommandBuilder>, Grep.Interface<Unix4jCommandBuilder>, Head.Interface<Unix4jCommandBuilder>, Ls.Interface<Unix4jCommandBuilder>, Sed.Interface<Unix4jCommandBuilder>, Sort.Interface<Unix4jCommandBuilder>, Tail.Interface<Unix4jCommandBuilder>, To, Uniq.Interface<Unix4jCommandBuilder>, Wc.Interface<Unix4jCommandBuilder>, Xargs.Interface<Unix4jCommandBuilder>

All Known Implementing Classes:

DefaultUnix4jCommandBuilder
```
public interface Unix4jCommandBuilder
extends CommandBuilder, Cat.Interface<Unix4jCommandBuilder>, Cd.Interface<Unix4jCommandBuilder>, Cut.Interface<Unix4jCommandBuilder>, Echo.Interface<Unix4jCommandBuilder>, Find.Interface<Unix4jCommandBuilder>, From.Interface<Unix4jCommandBuilder>, Grep.Interface<Unix4jCommandBuilder>, Head.Interface<Unix4jCommandBuilder>, Ls.Interface<Unix4jCommandBuilder>, Sed.Interface<Unix4jCommandBuilder>, Sort.Interface<Unix4jCommandBuilder>, Tail.Interface<Unix4jCommandBuilder>, Uniq.Interface<Unix4jCommandBuilder>, Wc.Interface<Unix4jCommandBuilder>, Xargs.Interface<Unix4jCommandBuilder>
```
Builder for a unix4j command or a chain of joined commands. Application code does usually not directly refer to this class but uses it indirectly through the static methods in Unix4j.
Note that the command creation methods do not return a new command instance. Instead, the builder stores the created commands and only returns a Command object when the CommandBuilder.build() method is invoked. Most applications, however, need not to call build() explicitly. The command can be built and executed in a single step by calling one of the toXXX(..) methods, such as To.toStdOut(), To.toFile(String) or To.toStringResult().
The Command object returned by the CommandBuilder.build() method can represent a single command or a chain of commands. In a command chain, the previous command usually pipes its output as standard input into the next command (the pipe symbol between two commands in unix). For come commands, however, chaining has a different interpretation. An example is the xargs command: here, the next command after xargs receives arguments from xargs instead of (standard) input.

Method Summary

Methods
Modifier and Type	Method and Description
`Unix4jCommandBuilder`	`apply(LineOperation operation)` Adds a new command based on the specified operation and adds it to the chain of commands held by this builder.
`Unix4jCommandBuilder`	`cat()` Reads the lines from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`cat(CatOptions options)` Reads the lines from the standard input and writes them to the standard output; the given options define the details of the output format.
`Unix4jCommandBuilder`	`cat(CatOptions options, File... files)` Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format.
`Unix4jCommandBuilder`	`cat(CatOptions options, String... paths)` Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format.
`Unix4jCommandBuilder`	`cat(File... files)` Reads the lines from the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`cat(String... args)` Reads the lines from files specified as arguments and writes them to the standard output.
`Unix4jCommandBuilder`	`cd()` Changes the current directory to the user home directory as defined by the execution context (usually the directory specified by the `"user.home"` system property).
`Unix4jCommandBuilder`	`cd(File file)` The current working directory is changed to the given file.
`Unix4jCommandBuilder`	`cd(String path)` The current working directory is changed to the given file.
`Unix4jCommandBuilder`	`cut(CutOptions options, int... indexes)` Cuts the fields or characters using the given indexes from the input line and writes them to the output.
`Unix4jCommandBuilder`	`cut(CutOptions options, Range range)` Cuts the fields or characters using the given range from the input line and writes them to the output.
`Unix4jCommandBuilder`	`cut(CutOptions options, String delimiter, char outputDelimiter, int... indexes)` Cuts the fields using the given indexes and using the given delimiter from the input line and writes them to the output using the given outputDelimiter.
`Unix4jCommandBuilder`	`cut(CutOptions options, String delimiter, char outputDelimiter, Range range)` Cuts the fields using the given range and using the given delimiter from the input line and writes them to the output using the given outputDelimiter.
`Unix4jCommandBuilder`	`cut(CutOptions options, String delimiter, int... indexes)` Cuts the fields using the given indexes from the input line and writes them to the output.
`Unix4jCommandBuilder`	`cut(CutOptions options, String delimiter, Range range)` Cuts the fields using the given range from the input line and writes them to the output.
`Unix4jCommandBuilder`	`cut(String... args)` Cuts the fields or characters from the input line and writes them to the standard output.
`Unix4jCommandBuilder`	`echo(EchoOptions options, String... strings)` Writes any of the specified strings, separated by single blank (`' '`) characters to the standard output suppressing the trailing line ending if the `-n` option is specified.
`Unix4jCommandBuilder`	`echo(EchoOptions options, String string)` Writes the specified string followed by a newline character to the standard output suppressing the trailing line ending if the `-n` option is specified.
`Unix4jCommandBuilder`	`echo(String... args)` Writes any of the specified strings, separated by single blank (`' '`) characters to the standard output suppressing the trailing line ending if the `"-n"` option is specified.
`Unix4jCommandBuilder`	`find(FindOptions options, Date time)` Finds all files that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`Unix4jCommandBuilder`	`find(FindOptions options, Date time, String name)` Finds all files matching the given `name` that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`Unix4jCommandBuilder`	`find(FindOptions options, long size)` Finds all files matching the specified file `size` in or below the user's current working directory and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(FindOptions options, long size, Date time, String name)` Finds all files matching the given `name` and `size` and have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`Unix4jCommandBuilder`	`find(FindOptions options, long size, String name)` Finds all files matching the specified file `name` and `size` in or below the user's current working directory and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(FindOptions options, String name)` Finds all files matching the specified `name` in or below the user's current working directory and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(FindOptions options, String path, Date time)` Finds all files that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`Unix4jCommandBuilder`	`find(FindOptions options, String path, Date time, String name)` Finds all files matching the given `name` that have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`Unix4jCommandBuilder`	`find(FindOptions options, String path, long size)` Finds all files matching the specified file `size` in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(FindOptions options, String path, long size, Date time, String name)` Finds all files matching the given `name` and `size` and have been created, modified or accessed before or after the specified `time` (depending on the given `-time...` options).
`Unix4jCommandBuilder`	`find(FindOptions options, String path, long size, String name)` Finds all files matching the specified file `name` and `size` in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(FindOptions options, String path, String name)` Finds all files matching the specified `name` in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(long size)` Finds all files matching the specified file `size` in or below the user's current working directory and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(long size, String name)` Finds all files matching the specified file `name` and `size` in or below the user's current working directory and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(String... args)` Finds all files matching the search criteria specified by the given arguments and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(String path)` Finds all files in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(String path, long size)` Finds all files matching the specified file `size` in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(String path, long size, String name)` Finds all files matching the specified file `name` and `size` in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`find(String path, String name)` Finds all files matching the specified `name` in or below the directory specified by `path` and writes the file names to the standard output.
`Unix4jCommandBuilder`	`from(Collection<? extends String> lines)` Uses the strings in the specified `input` collection as input lines for the next command.
`Unix4jCommandBuilder`	`from(Input input)` Reads from the given input object and redirects the contents into the next command.
`Unix4jCommandBuilder`	`from(InputStream stream)` Reads from the given input stream and redirects the contents into the next command.
`Unix4jCommandBuilder`	`from(Reader reader)` Uses the given reader and redirects the read input into the next command.
`Unix4jCommandBuilder`	`from(URL url)` Reads from the given URL and redirects the contents into the next command.
`Unix4jCommandBuilder`	`fromFile(File file)` Redirects the contents of the given file into the next command.
`Unix4jCommandBuilder`	`fromFile(String path)` Redirects the contents of the given file into the next command.
`Unix4jCommandBuilder`	`fromResource(String resource)` Reads from the given resource relative to the classpath and redirects the contents into the next command.
`Unix4jCommandBuilder`	`fromString(String string)` Uses the given string as input for the next command.
`Unix4jCommandBuilder`	`fromStrings(String... strings)` Uses the given strings as input for the next command.
`Unix4jCommandBuilder`	`grep(GrepOptions options, Pattern pattern)` Filters the input lines from the standard input and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(GrepOptions options, Pattern pattern, File... files)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(GrepOptions options, Pattern pattern, String... paths)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(GrepOptions options, String regexp)` Filters the input lines from the standard input and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(GrepOptions options, String regexp, File... files)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(GrepOptions options, String regexp, String... paths)` Filters the input lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(Pattern pattern)` Filters the input lines from the standard input and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(Pattern pattern, File... files)` Filters the lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(Pattern pattern, String... paths)` Filters the lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(String... args)` Filters the input lines from the standard input or the provided input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(String regexp)` Filters the input lines from the standard input and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`grep(String regexp, File... files)` Filters the lines from the specified input files and writes the matching lines to the standard output.
`Unix4jCommandBuilder`	`head()` Reads the first 10 lines from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`head(File... files)` Reads the first 10 lines from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`head(HeadOptions options, long count)` Reads the first `count` lines or characters from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`head(HeadOptions options, long count, File... files)` Reads the first `count` lines or characters from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`head(HeadOptions options, long count, String... paths)` Reads the first `count` lines or characters from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`head(long count)` Reads the first `count` lines from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`head(long count, File... files)` Reads the first `count` lines from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`head(long count, String... paths)` Reads the first `count` lines from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`head(String... args)` Reads the first n lines from each of the files specified and writes them to the standard output.
`Unix4jCommandBuilder`	`join(Command<?> command)` Adds the specified command to the chain of commands held by this builder.
`Unix4jCommandBuilder`	`ls()` Lists all files and directories in the user's current working directory and writes them to the output.
`Unix4jCommandBuilder`	`ls(File... files)` Prints the name of the given files and lists all files contained in directories for every directory in `files`.
`Unix4jCommandBuilder`	`ls(LsOptions options)` Lists all files and directories in the user's current working directory and writes them to the output using the given options specifying the details of the output format.
`Unix4jCommandBuilder`	`ls(LsOptions options, File... files)` Prints the name of the given files and lists all files contained in directories for every directory in `files`.
`Unix4jCommandBuilder`	`ls(LsOptions options, String... paths)` Prints the name of the given files and lists all files contained in directories for every directory in `files`.
`Unix4jCommandBuilder`	`ls(String... args)` Prints the name of the specified files and lists all files contained in directories for every directory in those files.
`Unix4jCommandBuilder`	`reset()` Resets this command builder to its initial state.
`Unix4jCommandBuilder`	`sed(SedOptions options, String regexp)` Executes the sed command specified by the given options or executes the print command p if no command option has been declared.
`Unix4jCommandBuilder`	`sed(SedOptions options, String string1, String string2)` Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
`Unix4jCommandBuilder`	`sed(SedOptions options, String string1, String string2, int... occurrence)` Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
`Unix4jCommandBuilder`	`sed(String... args)` Executes the sed script specified by the given arguments and writes the result to the standard output.
`Unix4jCommandBuilder`	`sed(String script)` Executes the given sed script, such as "s/original/replacement/g".
`Unix4jCommandBuilder`	`sed(String regexp, String replacement)` Substitutes the replacement string for instances of the regexp in the matched line.
`Unix4jCommandBuilder`	`sed(String regexp, String replacement, int... occurrence)` Substitutes the replacement string for instances of the regexp in the matched line.
`Unix4jCommandBuilder`	`sort()` Sort the lines read from the standard input and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(Comparator<? super Line> comparator)` Sort the lines read from the standard input and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(Comparator<? super Line> comparator, File... files)` Sort the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(Comparator<? super Line> comparator, String... paths)` Sort the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(File... files)` Sort the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(SortOptions options)` Sorts, merges, or sequence checks the lines read from the standard input and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(SortOptions options, Comparator<? super Line> comparator)` Sorts, merges, or sequence checks the lines read from the standard input and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(SortOptions options, Comparator<? super Line> comparator, File... files)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(SortOptions options, Comparator<? super Line> comparator, String... paths)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(SortOptions options, File... files)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(SortOptions options, String... paths)` Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`sort(String... args)` Sort the lines of all the specified files together and writes the result to the standard output.
`Unix4jCommandBuilder`	`tail()` Reads the last 10 lines from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(File... files)` Reads the last 10 lines from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(long count)` Reads the last `count` lines from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(long count, File... files)` Reads the last `count` lines from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(long count, String... paths)` Reads the last `count` lines from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(String... args)` Reads the last n lines from each of the files specified and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(TailOptions options, long count)` Reads the last `count` lines or characters from the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(TailOptions options, long count, File... files)` Reads the last `count` lines or characters from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`tail(TailOptions options, long count, String... paths)` Reads the last `count` lines or characters from each of the specified files and writes them to the standard output.
`Unix4jCommandBuilder`	`uniq()` Reads from the standard input and compares adjacent lines, writing one copy of each input line to the standard output.
`Unix4jCommandBuilder`	`uniq(File file)` Reads from the specified input `file` and compares adjacent lines, writing one copy of each input line to the standard output.
`Unix4jCommandBuilder`	`uniq(String... args)` Reads the file specified by the `"--path"` operand (the default operand) and writes only unique lines to the standard output.
`Unix4jCommandBuilder`	`uniq(String path)` Reads the file specified by its `path` and compares adjacent lines, writing one copy of each input line to the standard output.
`Unix4jCommandBuilder`	`uniq(UniqOptions options)` Reads from the standard input and compares adjacent lines, writing one copy of each input line to the standard output.
`Unix4jCommandBuilder`	`uniq(UniqOptions options, File file)` Reads from the specified input `file` and compares adjacent lines, writing one copy of each input line to the standard output.
`Unix4jCommandBuilder`	`uniq(UniqOptions options, String path)` Reads the file specified by its `path` and compares adjacent lines, writing one copy of each input line to the standard output.
`Unix4jCommandBuilder`	`wc()` Executes a count of lines, words and chars contained in the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`wc(File... files)` Executes a count of lines, words and chars contained in each input file and writes them to the standard output.
`Unix4jCommandBuilder`	`wc(String... args)` One or several counts are executed and written to the standard output.
`Unix4jCommandBuilder`	`wc(WcOptions options)` Executes a one or more counts, depending on the given options, in the standard input and writes them to the standard output.
`Unix4jCommandBuilder`	`wc(WcOptions options, File... files)` Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output.
`Unix4jCommandBuilder`	`wc(WcOptions options, String[] paths)` Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output.
`Unix4jCommandBuilder`	`xargs()` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(int maxArgs)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(long maxLines)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(long maxLines, int maxArgs)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(String... args)` Reads items from the standard input, delimited by blanks and newlines or a specified delimiter, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(String delimiter)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(String delimiter, int maxArgs)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(String delimiter, long maxLines)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(String delimiter, long maxLines, int maxArgs)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(String delimiter, String eof, long maxLines, int maxArgs)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, int maxArgs)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, long maxLines)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, long maxLines, int maxArgs)` Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, String delimiter)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, String delimiter, int maxArgs)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, String delimiter, long maxLines)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, String delimiter, long maxLines, int maxArgs)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.
`Unix4jCommandBuilder`	`xargs(XargsOptions options, String delimiter, String eof, long maxLines, int maxArgs)` Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input.

Methods inherited from interface org.unix4j.builder.CommandBuilder
build, toString

Methods inherited from interface org.unix4j.builder.To
toDevNull, toExitValue, toFile, toFile, toLineList, toOutput, toOutputStream, toStdOut, toStringList, toStringResult, toWriter

- Method Detail
  - cat
```
Unix4jCommandBuilder cat()
```
    Reads the lines from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cat in interface Cat.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cat
```
Unix4jCommandBuilder cat(String... args)
```
    Reads the lines from files specified as arguments and writes them to the standard output. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). File arguments are expanded if wildcards are used. All file arguments are processed in command-argument order.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cat in interface Cat.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and file operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). File arguments are expanded if wildcards are used.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cat
```
Unix4jCommandBuilder cat(File... files)
```
    Reads the lines from the specified files and writes them to the standard output. The files are processed in command-argument order.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cat in interface Cat.Interface<Unix4jCommandBuilder>
    
    Parameters:
    files - The input files to be printed; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cat
```
Unix4jCommandBuilder cat(CatOptions options)
```
    Reads the lines from the standard input and writes them to the standard output; the given options define the details of the output format.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cat in interface Cat.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the cat command.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cat
```
Unix4jCommandBuilder cat(CatOptions options,
                       File... files)
```
    Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format. The files are processed in command-argument order.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cat in interface Cat.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the cat command.
    files - The input files to be printed; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cat
```
Unix4jCommandBuilder cat(CatOptions options,
                       String... paths)
```
    Reads the lines from the specified files and writes them to the standard output; the given options define the details of the output format. The path arguments are expanded if wildcards are used and processed in command-argument order.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cat in interface Cat.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the cat command.
    paths - Pathnames of the input files to be printed; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cd
```
Unix4jCommandBuilder cd()
```
    Changes the current directory to the user home directory as defined by the execution context (usually the directory specified by the "user.home" system property).
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cd in interface Cd.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cd
```
Unix4jCommandBuilder cd(File file)
```
    The current working directory is changed to the given file. If the specified file argument does not represent a valid directory, an exception is thrown. Note that relative paths are not resolved with the (old) current working directory. Use the String path to enable relative path resolving and wildcards.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cd in interface Cd.Interface<Unix4jCommandBuilder>
    
    Parameters:
    file - the file to use as input; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cd
```
Unix4jCommandBuilder cd(String path)
```
    The current working directory is changed to the given file. Relative paths are resolved on the basis of the (old) current working directory. Wildcards are possible if the first matching file represents a directory. If the first file specified by the given path argument is not a valid directory, an exception is thrown.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cd in interface Cd.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - the directory to become the new current working directory; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(String... args)
```
    Cuts the fields or characters from the input line and writes them to the standard output. Depending on the provided options and operands, range, delimiter or indexes define the cut.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--range" operand have to be prefixed with the operand name (e.g. "--indexes" for subsequent index operand values).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(CutOptions options,
                       Range range)
```
    Cuts the fields or characters using the given range from the input line and writes them to the output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - options for the cut command
    range - select only these fields
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(CutOptions options,
                       int... indexes)
```
    Cuts the fields or characters using the given indexes from the input line and writes them to the output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - options for the cut command
    indexes - select these chars/field based on the given indexes. Indexes are 1 based. i.e. the first character/field on a line has an index of 1.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(CutOptions options,
                       String delimiter,
                       Range range)
```
    Cuts the fields using the given range from the input line and writes them to the output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - options for the cut command
    delimiter - use as the output delimiter the default is to use the input delimiter
    range - select only these fields
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(CutOptions options,
                       String delimiter,
                       int... indexes)
```
    Cuts the fields using the given indexes from the input line and writes them to the output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - options for the cut command
    delimiter - use as the output delimiter the default is to use the input delimiter
    indexes - select these chars/field based on the given indexes. Indexes are 1 based. i.e. the first character/field on a line has an index of 1.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(CutOptions options,
                       String delimiter,
                       char outputDelimiter,
                       Range range)
```
    Cuts the fields using the given range and using the given delimiter from the input line and writes them to the output using the given outputDelimiter.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - options for the cut command
    delimiter - use as the output delimiter the default is to use the input delimiter
    outputDelimiter - use as the output delimiter the default is to use the input delimiter
    range - select only these fields
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - cut
```
Unix4jCommandBuilder cut(CutOptions options,
                       String delimiter,
                       char outputDelimiter,
                       int... indexes)
```
    Cuts the fields using the given indexes and using the given delimiter from the input line and writes them to the output using the given outputDelimiter.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    cut in interface Cut.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - options for the cut command
    delimiter - use as the output delimiter the default is to use the input delimiter
    outputDelimiter - use as the output delimiter the default is to use the input delimiter
    indexes - select these chars/field based on the given indexes. Indexes are 1 based. i.e. the first character/field on a line has an index of 1.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - echo
```
Unix4jCommandBuilder echo(String... args)
```
    Writes any of the specified strings, separated by single blank (' ') characters to the standard output suppressing the trailing line ending if the "-n" option is specified.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    echo in interface Echo.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options for the command and the strings to be written to the output. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--").
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - echo
```
Unix4jCommandBuilder echo(EchoOptions options,
                        String string)
```
    Writes the specified string followed by a newline character to the standard output suppressing the trailing line ending if the -n option is specified.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    echo in interface Echo.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the echo command.
    string - A string to be written to standard output.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - echo
```
Unix4jCommandBuilder echo(EchoOptions options,
                        String... strings)
```
    Writes any of the specified strings, separated by single blank (' ') characters to the standard output suppressing the trailing line ending if the -n option is specified.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    echo in interface Echo.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the echo command.
    strings - Strings to be written to standard output, separated by single blank characters.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(String... args)
```
    Finds all files matching the search criteria specified by the given arguments and writes the file names to the standard output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--name" operand have to be prefixed with the operand name.
    The files names written to the output are relative paths referring to the working directory (or -- if provided -- relative to the path given after the "--path" operand name).
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--path" operand have to be prefixed with the operand name (e.g. "--name" for subsequent path operand values).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(String path)
```
    Finds all files in or below the directory specified by path and writes the file names to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(String path,
                        String name)
```
    Finds all files matching the specified name in or below the directory specified by path and writes the file names to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(long size)
```
    Finds all files matching the specified file size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(String path,
                        long size)
```
    Finds all files matching the specified file size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(String path,
                        long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String name)
```
    Finds all files matching the specified name in or below the user's current working directory and writes the file names to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        String name)
```
    Finds all files matching the specified name in or below the directory specified by path and writes the file names to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        long size)
```
    Finds all files matching the specified file size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        long size)
```
    Finds all files matching the specified file size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        Date time)
```
    Finds all files that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the user's current working directory are written to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        Date time)
```
    Finds all files that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the directory specified by path are written to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the user's current working directory and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        long size,
                        String name)
```
    Finds all files matching the specified file name and size in or below the directory specified by path and writes the file names to the standard output. Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        Date time,
                        String name)
```
    Finds all files matching the given name that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the user's current working directory are written to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        Date time,
                        String name)
```
    Finds all files matching the given name that have been created, modified or accessed before or after the specified time (depending on the given -time... options). The names of the matching files found in or below the directory specified by path are written to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        long size,
                        Date time,
                        String name)
```
    Finds all files matching the given name and size and have been created, modified or accessed before or after the specified time (depending on the given -time... options).
    Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative. The names of the matching files found in or below the user's current working directory are written to the standard output.
    The files names written to the output are relative paths referring to the working directory.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - find
```
Unix4jCommandBuilder find(FindOptions options,
                        String path,
                        long size,
                        Date time,
                        String name)
```
    Finds all files matching the given name and size and have been created, modified or accessed before or after the specified time (depending on the given -time... options).
    Matching files use at least size bytes on disk if size is positive, or at most abs(size) bytes if size is zero or negative. The names of the matching files found in or below the directory specified by path are written to the standard output.
    The files names written to the output are paths relative to the specified path operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    find in interface Find.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the file search.
    path - Starting point for the search in the directory hierarchy; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    size - Consider only files using at least size bytes if size is positive, or at most abs(size) bytes if size is zero or negative.
    time - Consider only files that have been created, modified or accessed before or after the specified time operand; consider the -time... options for details of the comparison.
    name - Name pattern to match the file name after removing the path with the leading directories; wildcards * and ? are supported, or full regular expressions if either of the options -regex (-r) or -iregex (-i) is specified.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - fromString
```
Unix4jCommandBuilder fromString(String string)
```
    Uses the given string as input for the next command. If the string contains line ending codes (UNIX or DOS independent from the host operating system), the string is split into multiple lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    fromString in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    string - the string to use as input
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - fromStrings
```
Unix4jCommandBuilder fromStrings(String... strings)
```
    Uses the given strings as input for the next command. Each string usually represents a single line of the input; however, if any of the strings contains line ending codes (UNIX or DOS independent from the host operating system), it is split into multiple lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    fromStrings in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    strings - the input lines
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - from
```
Unix4jCommandBuilder from(Collection<? extends String> lines)
```
    Uses the strings in the specified input collection as input lines for the next command. Each string usually represents a single line of the input; however, if any of the strings contains line ending codes (UNIX or DOS independent from the host operating system), it is split into multiple lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    from in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    lines - collection with input lines
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - fromFile
```
Unix4jCommandBuilder fromFile(String path)
```
    Redirects the contents of the given file into the next command. This is essentially equivalent to the following syntax in a unix command shell: path > ...
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    fromFile in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - the file to use as input; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - fromFile
```
Unix4jCommandBuilder fromFile(File file)
```
    Redirects the contents of the given file into the next command. This is essentially equivalent to the following syntax in a unix command shell: file > ...
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    fromFile in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    file - the file to use as input; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - fromResource
```
Unix4jCommandBuilder fromResource(String resource)
```
    Reads from the given resource relative to the classpath and redirects the contents into the next command. The resource is usually a file or URL on the classpath. The resource is read using Class.getResourceAsStream(String).
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    fromResource in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    resource - a path to the file to redirect to the next command. The will need to be on the classpath. If the file is in the root directory, the filename should be prefixed with a forward slash. e.g.: "/test-file.txt"
    If the file is in a package, then the package should be specified prefixed with a forward slash, and with each dot "." replaced with a forward slash. e.g.: "/org/company/mypackage/test-file.txt"
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - from
```
Unix4jCommandBuilder from(InputStream stream)
```
    Reads from the given input stream and redirects the contents into the next command.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    from in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    stream - the input stream to read from
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - from
```
Unix4jCommandBuilder from(Reader reader)
```
    Uses the given reader and redirects the read input into the next command.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    from in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    reader - the reader used to read the input
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - from
```
Unix4jCommandBuilder from(URL url)
```
    Reads from the given URL and redirects the contents into the next command.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    from in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    url - the URL to read from
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - from
```
Unix4jCommandBuilder from(Input input)
```
    Reads from the given input object and redirects the contents into the next command.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    from in interface From.Interface<Unix4jCommandBuilder>
    
    Parameters:
    input - the input object to read from
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(String... args)
```
    Filters the input lines from the standard input or the provided input files and writes the matching lines to the standard output. A line matches if it contains the given "--regexp" operand value (default operand).
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--regexp" and "--paths" operands have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--pattern" and "--paths" operands have to be prefixed with the operand name (e.g. "--files" for subsequent file operand values).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(String regexp)
```
    Filters the input lines from the standard input and writes the matching lines to the standard output. A line matches if it contains the given regexp using case-sensitive string comparison.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(String regexp,
                        File... files)
```
    Filters the lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regexp string using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(Pattern pattern)
```
    Filters the input lines from the standard input and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    pattern - Lines will be printed which match the given pattern.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(Pattern pattern,
                        File... files)
```
    Filters the lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    pattern - Lines will be printed which match the given pattern.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(Pattern pattern,
                        String... paths)
```
    Filters the lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern using case-sensitive comparison. Line endings are not relevant for the comparison.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    pattern - Lines will be printed which match the given pattern.
    paths - Pathnames of the input files to be searched for the pattern; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(GrepOptions options,
                        String regexp)
```
    Filters the input lines from the standard input and writes the matching lines to the standard output. Every line is matched against the given regexp string; the exact comparison rules are defined by the specified matching options.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(GrepOptions options,
                        Pattern pattern)
```
    Filters the input lines from the standard input and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern; the exact comparison rules are defined by the specified matching options.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    pattern - Lines will be printed which match the given pattern.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(GrepOptions options,
                        String regexp,
                        File... files)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regexp string; the exact comparison rules are defined by the specified matching options.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(GrepOptions options,
                        String regexp,
                        String... paths)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regexp string; the exact comparison rules are defined by the specified matching options.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    regexp - Lines will be printed which match the given regular expression. The regexp string is surrounded with ".*" on both sides unless the --wholeLine option is specified. If the --fixedStrings option is used, plain string comparison is used instead of regular expression matching.
    paths - Pathnames of the input files to be searched for the pattern; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(GrepOptions options,
                        Pattern pattern,
                        File... files)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern; the exact comparison rules are defined by the specified matching options.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    pattern - Lines will be printed which match the given pattern.
    files - The input files to be searched for the pattern; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - grep
```
Unix4jCommandBuilder grep(GrepOptions options,
                        Pattern pattern,
                        String... paths)
```
    Filters the input lines from the specified input files and writes the matching lines to the standard output. Every line is matched against the given regular expression pattern; the exact comparison rules are defined by the specified matching options.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    grep in interface Grep.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the types of patterns and command behavior.
    pattern - Lines will be printed which match the given pattern.
    paths - Pathnames of the input files to be searched for the pattern; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head()
```
    Reads the first 10 lines from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(String... args)
```
    Reads the first n lines from each of the files specified and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--count" for a subsequent count operand value).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(long count)
```
    Reads the first count lines from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(HeadOptions options,
                        long count)
```
    Reads the first count lines or characters from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the head command.
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(File... files)
```
    Reads the first 10 lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(long count,
                        File... files)
```
    Reads the first count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(long count,
                        String... paths)
```
    Reads the first count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(HeadOptions options,
                        long count,
                        File... files)
```
    Reads the first count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the head command.
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - head
```
Unix4jCommandBuilder head(HeadOptions options,
                        long count,
                        String... paths)
```
    Reads the first count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    head in interface Head.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the head command.
    count - The first count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - ls
```
Unix4jCommandBuilder ls()
```
    Lists all files and directories in the user's current working directory and writes them to the output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    ls in interface Ls.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - ls
```
Unix4jCommandBuilder ls(String... args)
```
    Prints the name of the specified files and lists all files contained in directories for every directory in those files.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    ls in interface Ls.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--count" for a subsequent count operand value).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - ls
```
Unix4jCommandBuilder ls(File... files)
```
    Prints the name of the given files and lists all files contained in directories for every directory in files.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    ls in interface Ls.Interface<Unix4jCommandBuilder>
    
    Parameters:
    files - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - ls
```
Unix4jCommandBuilder ls(LsOptions options)
```
    Lists all files and directories in the user's current working directory and writes them to the output using the given options specifying the details of the output format.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    ls in interface Ls.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the output format.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - ls
```
Unix4jCommandBuilder ls(LsOptions options,
                      File... files)
```
    Prints the name of the given files and lists all files contained in directories for every directory in files. The given options define the details of the output format.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    ls in interface Ls.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the output format.
    files - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - ls
```
Unix4jCommandBuilder ls(LsOptions options,
                      String... paths)
```
    Prints the name of the given files and lists all files contained in directories for every directory in files. The given options define the details of the output format.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    ls in interface Ls.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the output format.
    paths - The files or directories used as starting point for the listing; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(String... args)
```
    Executes the sed script specified by the given arguments and writes the result to the standard output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--script" operand have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--script" operand have to be prefixed with the operand name (e.g. "--occurrence" for subsequent occurrence indices).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(String script)
```
    Executes the given sed script, such as "s/original/replacement/g".
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    script - Sed script as one string, such as "s/original/replacement/g".
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(String regexp,
                       String replacement)
```
    Substitutes the replacement string for instances of the regexp in the matched line.
    An ampersand ('&') appearing in the replacement is be replaced by the line matching the regexp. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    A line can be split by substituting a newline ('\n') into it.
    A substitution is considered to have been performed even if the replacement string is identical to the string that it replaces.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    regexp - Regular expression matched against a line.
    replacement - Replacement string for substitute command. An ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(String regexp,
                       String replacement,
                       int... occurrence)
```
    Substitutes the replacement string for instances of the regexp in the matched line. Only the given occurrences of the regexp found within the matched string are substituted.
    An ampersand ('&') appearing in the replacement is be replaced by the line matching the regexp. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    A line can be split by substituting a newline ('\n') into it.
    A substitution is considered to have been performed even if the replacement string is identical to the string that it replaces.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    regexp - Regular expression matched against a line.
    replacement - Replacement string for substitute command. An ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression. The characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    occurrence - Substitute for the given occurrences only of the regexp found within the matched string; the occurrence indices are one-based. If empty or omitted, all occurrences are substituted.
    (This operand only applies to the substitute command and is ignored by all other commands).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(SedOptions options,
                       String regexp)
```
    Executes the sed command specified by the given options or executes the print command p if no command option has been declared.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Sed options and commands
    regexp - Regular expression matched against a line.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(SedOptions options,
                       String string1,
                       String string2)
```
    Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Sed options and commands
    string1 - Regular expression matched against a line for all commands except for command y where string1 contains the source characters for the translation.
    string2 - Replacement string for substitute command s; appended, inserted or changed text for a, i and c command; destination characters for translate command y; ignored by all other commands.
    If string2 is a replacement string for the substitute command: an ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression; the characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    (This operand only applies to the commands s, a, i, c and y and is ignored by all other commands).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sed
```
Unix4jCommandBuilder sed(SedOptions options,
                       String string1,
                       String string2,
                       int... occurrence)
```
    Executes the sed command specified by the given options or executes the substitute command s if no command option has been declared.
    The string1 operand usually contains the regular expression matched against a line for all commands except for command y where string1 contains the source characters for the translation.
    The string2 operand contains the replacement string for the substitute command s. It contains the appended, inserted or changed text for the commands a, i and c, respectively, and the destination characters for the translate command y. All other commands ignore the string2 operand.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sed in interface Sed.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Sed options and commands
    string1 - Regular expression matched against a line for all commands except for command y where string1 contains the source characters for the translation.
    string2 - Replacement string for substitute command s; appended, inserted or changed text for a, i and c command; destination characters for translate command y; ignored by all other commands.
    If string2 is a replacement string for the substitute command: an ampersand ('&') appearing in the replacement string is replaced by the string matching the regular expression; the characters "\n", where n is a digit, are replaced by the text matched by the corresponding backreference expression. The special meaning of '&' and "\n" in this context can be suppressed by preceding it by a backslash.
    (This operand only applies to the commands s, a, i, c and y and is ignored by all other commands).
    occurrence - Substitute for the given occurrences only of the regexp found within the matched string; the occurrence indices are one-based. If empty or omitted, all occurrences are substituted.
    (This operand only applies to the substitute command and is ignored by all other commands).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort()
```
    Sort the lines read from the standard input and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(String... args)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--comparator" for a subsequent comparator operand value).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(File... files)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(Comparator<? super Line> comparator)
```
    Sort the lines read from the standard input and writes the result to the standard output.
    Line comparisons are based on the specified comparator.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    comparator - The comparator to use for the line comparisons.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(Comparator<? super Line> comparator,
                        File... files)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    comparator - The comparator to use for the line comparisons.
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(Comparator<? super Line> comparator,
                        String... paths)
```
    Sort the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    comparator - The comparator to use for the line comparisons.
    paths - Pathnames of the files to be sorted, merged, or checked; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(SortOptions options)
```
    Sorts, merges, or sequence checks the lines read from the standard input and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options for the sort command.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(SortOptions options,
                        File... files)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options for the sort command.
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(SortOptions options,
                        String... paths)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Comparisons are based on the entire line without line ending. The collating sequence of the current locale is used to perform the comparisons.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options for the sort command.
    paths - Pathnames of the files to be sorted, merged, or checked; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(SortOptions options,
                        Comparator<? super Line> comparator)
```
    Sorts, merges, or sequence checks the lines read from the standard input and writes the result to the standard output.
    Line comparisons are based on the specified comparator. All comparison related options are ignored except for --reverse.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options for the sort command.
    comparator - The comparator to use for the line comparisons.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(SortOptions options,
                        Comparator<? super Line> comparator,
                        File... files)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator. All comparison related options except for --reverse are ignored.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options for the sort command.
    comparator - The comparator to use for the line comparisons.
    files - The files to be sorted or merged; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - sort
```
Unix4jCommandBuilder sort(SortOptions options,
                        Comparator<? super Line> comparator,
                        String... paths)
```
    Sorts, merges, or sequence checks the lines the lines of all the specified files together and writes the result to the standard output.
    Line comparisons are based on the specified comparator. All comparison related options except for --reverse are ignored.
    The sort algorithm used is guaranteed to be stable: lines considered equal will not be reordered as a result of the sort. If two lines originate from different input files, the index of the file in the input arguments list defines the ordering of the lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    sort in interface Sort.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options for the sort command.
    comparator - The comparator to use for the line comparisons.
    paths - Pathnames of the files to be sorted, merged, or checked; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail()
```
    Reads the last 10 lines from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(String... args)
```
    Reads the last n lines from each of the files specified and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name (e.g. "--count" for a subsequent count operand value).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(long count)
```
    Reads the last count lines from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(TailOptions options,
                        long count)
```
    Reads the last count lines or characters from the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the tail command.
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(File... files)
```
    Reads the last 10 lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(long count,
                        File... files)
```
    Reads the last count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(long count,
                        String... paths)
```
    Reads the last count lines from each of the specified files and writes them to the standard output. If more than a single file is specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(TailOptions options,
                        long count,
                        File... files)
```
    Reads the last count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the tail command.
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    files - The input files to be filtered; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - tail
```
Unix4jCommandBuilder tail(TailOptions options,
                        long count,
                        String... paths)
```
    Reads the last count lines or characters from each of the specified files and writes them to the standard output. If more than a single file is specified and the -q option is not specified, each file is preceded by a header consisting of the string "==> XXX <==" where "XXX" is the name of the file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    tail in interface Tail.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - Options for the tail command.
    count - The last count lines of each input file are copied to standard output, starting from 1 (characters instead of lines if the -c option is specified, and offset from start instead of end with -s option). Must be a non-negative integer or an exception is thrown. If count is greater than the number number of lines (characters) in the input, the application will not error and send the whole file to the output.
    paths - Pathnames of the input files to be filtered; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq()
```
    Reads from the standard input and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated lines in the input are not detected if they are not adjacent (see --global or -g option); sorted input lines always result in unique output lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq(String... args)
```
    Reads the file specified by the "--path" operand (the default operand) and writes only unique lines to the standard output. The second and succeeding copies of repeated input lines are not written to the output.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--path" operand have to be prefixed with the operand name.
    Note that repeated lines in the input are not detected if they are not adjacent unless the --global is specified (sorted input lines always result in unique output lines).
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--path" operand have to be prefixed with the operand name.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq(File file)
```
    Reads from the specified input file and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated lines in the input are not detected if they are not adjacent (see --global or -g option); sorted input lines always result in unique output lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Parameters:
    file - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq(String path)
```
    Reads the file specified by its path and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated lines in the input are not detected if they are not adjacent (see --global or -g option); sorted input lines always result in unique output lines.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Parameters:
    path - The files or directories used as starting point for the listing; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq(UniqOptions options)
```
    Reads from the standard input and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated non-adjacent lines in the input are only detected with the --global or -g option. In other words, unique output lines are guaranteed only if either (a) the --global or -g option is specified, or (b) the input lines are sorted.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the uniqueness details for the output lines.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq(UniqOptions options,
                        File file)
```
    Reads from the specified input file and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated non-adjacent lines in the input are only detected with the --global or -g option. In other words, unique output lines are guaranteed only if either (a) the --global or -g option is specified, or (b) the input lines are sorted.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the uniqueness details for the output lines.
    file - The files or directories used as starting point for the listing; relative paths are not resolved (use the string path argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - uniq
```
Unix4jCommandBuilder uniq(UniqOptions options,
                        String path)
```
    Reads the file specified by its path and compares adjacent lines, writing one copy of each input line to the standard output. The second and succeeding copies of repeated adjacent input lines are not written to the output.
    Note that repeated non-adjacent lines in the input are only detected with the --global or -g option. In other words, unique output lines are guaranteed only if either (a) the --global or -g option is specified, or (b) the input lines are sorted.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    uniq in interface Uniq.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining the uniqueness details for the output lines.
    path - The files or directories used as starting point for the listing; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - wc
```
Unix4jCommandBuilder wc()
```
    Executes a count of lines, words and chars contained in the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    wc in interface Wc.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - wc
```
Unix4jCommandBuilder wc(String... args)
```
    One or several counts are executed and written to the standard output. Counts include lines, words and chars (depending on the provided options) and cumulative counts for all the files are displayed on a separate line after the output for the last file if more than one input file is specified.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    wc in interface Wc.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--paths" operand have to be prefixed with the operand name.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - wc
```
Unix4jCommandBuilder wc(File... files)
```
    Executes a count of lines, words and chars contained in each input file and writes them to the standard output. If more than one input file is specified, a line of cumulative counts for all the files is displayed on a separate line after the output for the last file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    wc in interface Wc.Interface<Unix4jCommandBuilder>
    
    Parameters:
    files - The input files; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - wc
```
Unix4jCommandBuilder wc(WcOptions options)
```
    Executes a one or more counts, depending on the given options, in the standard input and writes them to the standard output.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    wc in interface Wc.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - wc
```
Unix4jCommandBuilder wc(WcOptions options,
                      File... files)
```
    Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output. If more than one input file is specified, a line of cumulative counts for all the files is displayed on a separate line after the output for the last file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    wc in interface Wc.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    files - The input files; relative paths are not resolved (use the string paths argument to enable relative path resolving based on the current working directory).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - wc
```
Unix4jCommandBuilder wc(WcOptions options,
                      String[] paths)
```
    Executes a one or more counts, depending on the given options, in each of the given input files and writes them to the standard output. If more than one input file is specified, a line of cumulative counts for all the files is displayed on a separate line after the output for the last file.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    wc in interface Wc.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    paths - Pathnames of the input files; wildcards * and ? are supported; relative paths are resolved on the basis of the current working directory.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs()
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every input line; the item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(String... args)
```
    Reads items from the standard input, delimited by blanks and newlines or a specified delimiter, and provides variables for the items read from the standard input. The command following after xargs is executed once for every input line (or for multiple lines depending on the input options); the item variables are usually passed to the invoked command as arguments.
    Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--maxArgs" operand have to be prefixed with the operand name.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    args - String arguments defining the options and operands for the command. Options can be specified by acronym (with a leading dash "-") or by long name (with two leading dashes "--"). Operands other than the default "--maxArgs" operand have to be prefixed with the operand name (e.g. "--maxLines" for a subsequent line count operand value).
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(String delimiter)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every input line; the item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    delimiter - Input items are terminated by the specified characters.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(long maxLines)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines (or possibly fewer for the last invocation with the remaining lines at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(int maxArgs)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxArgs items read from the standard input (or possibly fewer for the last invocation with the remaining items at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(long maxLines,
                         int maxArgs)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines or maxArgs items (whichever occurs first). Fewer lines or items may be used for the last invocation with the remaining lines at the end of the file. The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(String delimiter,
                         long maxLines)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines (or possibly fewer for the last invocation with the remaining lines at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    delimiter - Input items are terminated by the specified characters.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(String delimiter,
                         int maxArgs)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxArgs items read from the standard input (or possibly fewer for the last invocation with the remaining items at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    delimiter - Input items are terminated by the specified characters.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(String delimiter,
                         long maxLines,
                         int maxArgs)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines or maxArgs items (whichever occurs first). Fewer lines or items may be used for the last invocation with the remaining lines at the end of the file. The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    delimiter - Input items are terminated by the specified characters.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(String delimiter,
                         String eof,
                         long maxLines,
                         int maxArgs)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. If the eof string occurs as a line of input, the rest of the input is ignored. The command following after xargs is executed once for every maxLines nonblank input lines or maxArgs items (whichever occurs first). Fewer lines or items may be used for the last invocation with the remaining lines at the end of the file. The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    delimiter - Input items are terminated by the specified characters.
    eof - If the end of file string occurs as a line of input, the rest of the input is ignored.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every input line; the item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         String delimiter)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every input line; the item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    delimiter - Input items are terminated by the specified characters.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         long maxLines)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines (or possibly fewer for the last invocation with the remaining lines at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         int maxArgs)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxArgs items read from the standard input (or possibly fewer for the last invocation with the remaining items at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         long maxLines,
                         int maxArgs)
```
    Reads items from the standard input, delimited by blanks (which can be protected with double or single quotes or a backslash) or newlines, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines or maxArgs items (whichever occurs first). Fewer lines or items may be used for the last invocation with the remaining lines at the end of the file. The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         String delimiter,
                         long maxLines)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines (or possibly fewer for the last invocation with the remaining lines at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    delimiter - Input items are terminated by the specified characters.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         String delimiter,
                         int maxArgs)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxArgs items read from the standard input (or possibly fewer for the last invocation with the remaining items at the end of the file). The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    delimiter - Input items are terminated by the specified characters.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         String delimiter,
                         long maxLines,
                         int maxArgs)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. The command following after xargs is executed once for every maxLines nonblank input lines or maxArgs items (whichever occurs first). Fewer lines or items may be used for the last invocation with the remaining lines at the end of the file. The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    delimiter - Input items are terminated by the specified characters.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - xargs
```
Unix4jCommandBuilder xargs(XargsOptions options,
                         String delimiter,
                         String eof,
                         long maxLines,
                         int maxArgs)
```
    Reads items from the standard input using the specified delimiter to separate items, and provides variables for the items read from the standard input. If the eof string occurs as a line of input, the rest of the input is ignored. The command following after xargs is executed once for every maxLines nonblank input lines or maxArgs items (whichever occurs first). Fewer lines or items may be used for the last invocation with the remaining lines at the end of the file. The item variables are usually passed to the invoked command as arguments.
    Note that the method returns this builder to allow for command chaining. The command itself is returned by the CommandBuilder.build() method. See class comments for more information.
    
    Specified by:
    
    xargs in interface Xargs.Interface<Unix4jCommandBuilder>
    
    Parameters:
    options - The options defining command behavior.
    delimiter - Input items are terminated by the specified characters.
    eof - If the end of file string occurs as a line of input, the rest of the input is ignored.
    maxLines - Use at most maxLines nonblank input lines per command invocation.
    maxArgs - Use at most maxArgs arguments per command invocation.
    
    Returns:
    this builder to allow for method chaining; method chaining is used here to create command chains; adding a command to the chain usually means that the previous command pipes its output to the next command (the pipe symbol in unix)
  - join
```
Unix4jCommandBuilder join(Command<?> command)
```
    Description copied from interface: CommandBuilder
    
    Adds the specified command to the chain of commands held by this builder. Application code rarely needs to call this method directly; the command specific methods are usually called instead to join an instance of a certain command, e.g. one of the grep(..) methods to join a grep command.
    If this is the fist joined command, the builder builds this command and returns or executes it if CommandBuilder.build() or toXXX(..) is called, respectively. If the command argument joins already existing commands, the last command in the chain redirects its output to the standard input of the specified command.
    
    Specified by:
    
    join in interface CommandBuilder
    
    Parameters:
    command - the command to join the last previously joined command
    
    Returns:
    the builder for chained method invocation to join other commands
  - apply
```
Unix4jCommandBuilder apply(LineOperation operation)
```
    Description copied from interface: CommandBuilder
    
    Adds a new command based on the specified operation and adds it to the chain of commands held by this builder.
    If this is the fist joined command, the builder builds the command created from the operation and returns or executes it if CommandBuilder.build() or toXXX(..) is called, respectively. If the command argument joins already existing commands, the last command in the chain redirects its output to the standard input of the specified command.
    
    Specified by:
    
    apply in interface CommandBuilder
    
    Parameters:
    operation - the operation on which the added command is based
    
    Returns:
    the builder for chained method invocation to join other commands
  - reset
```
Unix4jCommandBuilder reset()
```
    Description copied from interface: CommandBuilder
    
    Resets this command builder to its initial state. All joined commands are removed from the command chain leaving the builder in a state to build a NoOp command. New commands can be joined subsequently to create a new command chain.
    
    Specified by:
    
    reset in interface CommandBuilder
    
    Returns:
    the builder for chained method invocation for instance to join the first new command

Interface Unix4jCommandBuilder

Method Summary

Methods inherited from interface org.unix4j.builder.CommandBuilder

Methods inherited from interface org.unix4j.builder.To

Method Detail

cat

cat

cat

cat

cat

cat

cd

cd

cd

cut

cut

cut

cut

cut

cut

cut

echo

echo

echo

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

find

fromString

fromStrings

from

fromFile

fromFile

fromResource

from

from

from

from

grep

grep

grep

grep

grep

grep

grep

grep

grep

grep

grep

grep

head

head

head

head

head

head

head

head

head

ls

ls

ls

ls

ls

ls