CmdExecuter

java.lang.Object
- org.vishia.cmd.CmdExecuter

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable
```
public class CmdExecuter
extends java.lang.Object
implements java.io.Closeable
```
This class organizes the execution of commands with thread-parallel getting of the process outputs. It supports both command line invocations of the operation system (via ProcessBuilder) and call of JZtxtcmdScript sub routines (which may call internally command lines). It is especially proper for graphic applications: The execution of complex callbacks on graphical buttons should not be done in the graphic thread!

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`CmdExecuter.CmdQueueEntry`
`static interface`	`CmdExecuter.ExecuteAfterFinish` An implementation of this interface can be evaluate the output of the process after finish.
`(package private) class`	`CmdExecuter.InThread`
`(package private) class`	`CmdExecuter.OutThread`

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) boolean`	`bRunThreads` True for ever so long this class is used, it maybe so long this application runs.
`private java.nio.charset.Charset`	`charsetCmd` A maybe special charset for Input and output stream.
`(package private) java.util.concurrent.ConcurrentLinkedQueue<CmdExecuter.CmdQueueEntry>`	`cmdQueue`
`private java.lang.Appendable`	`echoCmd` Can be set especially for debug the commands.
`private CmdExecuter.OutThread`	`errThread` Both thread instances runs for ever so long bRunThreads is true.
`private CmdExecuter.ExecuteAfterFinish`	`executeAfterCmd` Set with an execute invocation, set to null if it was processed.
`private JZtxtcmdExecuter`	`jzcmdExecuter` For `JZtxtcmdScript.Subroutine`.
`private CmdExecuter.OutThread`	`outThread` Both thread instances runs for ever so long bRunThreads is true.
`private java.lang.Process`	`process` The running process or null.
`private java.lang.ProcessBuilder`	`processBuilder` Composite instance of the java.lang.ProcessBuilder.
`(package private) java.lang.String[]`	`sConsoleInvocation`
`(package private) java.lang.Thread`	`threadExecError`
`(package private) java.lang.Thread`	`threadExecIn`
`(package private) java.lang.Thread`	`threadExecOut` True if a process is started, false if it is finished.
`static java.lang.String`	`version` Version, License and History: 2022-01-21 Hartmut new `setEnvIgnoreCase(String, String)`: The Problem is that windows does not distinguish upper/lower case.

Constructor Summary

Constructors
Constructor and Description

CmdExecuter()
Constructs the class and starts the threads to getting output and error stream and putting the input stream to a process.

Constructors
Constructor and Description
`CmdExecuter()` Constructs the class and starts the threads to getting output and error stream and putting the input stream to a process.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`abortAllCmds()`
`boolean`	`abortCmd()` Aborts the running cmd.
`void`	`addCmd(JZtxtcmdScript.Subroutine jzsub, java.util.List<DataAccess.Variable<java.lang.Object>> args, java.lang.Appendable out, java.io.File currDir)` Same as `addCmd(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, Appendable, File, ExecuteAfterFinish)` but without execFinish
`void`	`addCmd(JZtxtcmdScript.Subroutine jzsub, java.util.List<DataAccess.Variable<java.lang.Object>> args, java.lang.Appendable out, java.io.File currDir, CmdExecuter.ExecuteAfterFinish execFinish)` Adds a Subroutine of an jzTc script to execute.
`void`	`addCmd(java.lang.String[] cmdArgs, java.lang.String input, java.util.List<java.lang.Appendable> outputs, java.util.List<java.lang.Appendable> errors, java.io.File currentDir, CmdExecuter.ExecuteAfterFinish executeAfterCmd)`
`void`	`addCmd(java.lang.String cmdline, java.lang.String input, java.lang.Appendable output, java.io.File currentDir, CmdExecuter.ExecuteAfterFinish executeAfterCmd)`
`void`	`clearCmdQueue()`
`void`	`close()` Closes the functionality, finished the threads.
`java.util.Map<java.lang.String,java.lang.String>`	`environment()` Returns the environment map for the internal `ProcessBuilder`.
`int`	`execute(java.lang.String[] cmdArgs, boolean donotwait, java.lang.String input, java.util.List<java.lang.Appendable> outputs, java.util.List<java.lang.Appendable> errors, CmdExecuter.ExecuteAfterFinish executeAfterCmd)` Executes a command with arguments and maybe waits for its finishing.
`int`	`execute(java.lang.String[] cmdArgs, java.lang.String input, java.lang.Appendable output, java.lang.Appendable error)` Executes a command with arguments and maybe waits for its finishing.
`int`	`execute(java.lang.String[] cmdArgs, java.lang.String input, java.util.List<java.lang.Appendable> outputs, java.util.List<java.lang.Appendable> errors)` Same as `#execute(String[], String, Appendable, Appendable, boolean)` but do not wait for finish if both outputs and errors are null.
`int`	`execute(java.lang.String cmdLine, java.lang.String input, java.lang.Appendable output, java.lang.Appendable error)` Executes a command with arguments and waits for its finishing.
`int`	`execute(java.lang.String cmdLine, java.lang.String input, java.lang.Appendable output, java.lang.Appendable error, boolean useShell)` Executes a command with arguments and waits for its finishing.
`CmdExecuter.CmdQueueEntry`	`executeCmdQueue(boolean abortOnError)` Executes the commands stored with `#addCmd(String[], String, List, List, ExecuteAfterFinish)`.
`void`	`finalize()` Stops the threads to get output.
`private java.lang.String`	`getRemoveEnv(java.lang.String name)`
`boolean`	`hasEntries()` Returns true if the associated queue has at least on entry.
`void`	`initJZcmdExecuter(JZtxtcmdScript script, java.lang.String sCurrdir, LogMessage log)`
`static void`	`main(java.lang.String[] args)` A test main programm only for class test espesically in debug mode.
`void`	`outAllEnvironment(java.lang.Appendable out)` Outputs all environment variables in a sorted form
`java.lang.String`	`prefixEnv(java.lang.String name, java.lang.String value)` Adds a prefix or sets an environment variable, especially usable for PATH.
`java.lang.String`	`prefixEnvIgnoreCase(java.lang.String name, java.lang.String value)` Adds a prefix or sets an environment variable, especially usable for PATH.
`void`	`setCharsetForOutput(java.lang.String nameCharset)`
`void`	`setCurrentDir(java.io.File dir)` Sets the current directory for the next execution.
`void`	`setEchoCmdOut(java.lang.Appendable echo)` Possible to use for debugging which commands are executed.
`java.lang.String`	`setEnv(java.lang.String name, java.lang.String value)` Sets an environment variable.
`java.lang.String`	`setEnvIgnoreCase(java.lang.String name, java.lang.String value)` Sets an environment variable.
`void`	`specifyConsoleInvocation(java.lang.String cmd)`
`static java.lang.String[]`	`splitArgs(java.lang.String line)` Splits command line arguments.
`static java.lang.String[]`	`splitArgs(java.lang.String line, int npreArgs, int npostArgs)` Splits command line arguments.
`static java.lang.String[]`	`splitArgs(java.lang.String line, java.lang.String[] preArgs, java.lang.String[] postArgs)` Splits command line arguments with given pre- and post arg array.
`(package private) void`	`stop()`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - version
```
public static final java.lang.String version
```
    Version, License and History:
    - 2022-01-21 Hartmut new setEnvIgnoreCase(String, String): The Problem is that windows does not distinguish upper/lower case. If an environment variable is existing, and the same with other case is set in the Map from Java's ProcessBuilder.environment(), then this variable is twice, with all following catastrophics. This routine repairs, as also prefixEnvIgnoreCase(String, String).
    - 2022-01-21 Hartmut improved: also >cmdExecuter finished on finish, Now it can be shown that a command was really running.
    - 2022-01-21 Hartmut refactored, enhanced: splitArgs(String, int, int) now regards also '' as quotation, for inner quotation. Using: myCmd -arg="'partial arg' second": Firstly 'partial arg' second is stored, and this is split after them with this operation.
    - 2022-01-19 Hartmut new: setEchoCmdOut(Appendable)
    - 2022-01-18 Hartmut new: hasEntries()
    - 2020-03-14 Hartmut new: addCmd(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, Appendable, File, ExecuteAfterFinish).
    - 2017-10-05 Hartmut new: setCharsetForOutput(String): git outputs its status etc. in UTF-8.
    - 2017-01-01 Hartmut new: now alternatively to the command process the JZtxtcmdExecuter#execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, boolean, Appendable, File) can be invoked by a #add The JZcmdExecuter may invoke an command process and uses this CmdExecuter too in the main thread. Therefore it is proper to join both invocation variants. The old class org.vishia.cmd.CmdQueue is obsolete then.
    - 2016-09-18 Hartmut new: addCmd(String[], String, List, List, File, ExecuteAfterFinish) and executeCmdQueue(boolean). That is a new feature to store simple system commands. The class CmdQueue may be over-engineered for some applications.
    - 2016-09-17 Hartmut new: execute(String[], boolean, String, List, List, ExecuteAfterFinish) have the argument CmdExecuter.ExecuteAfterFinish. This method is executed in the outThread after finishing the command and can evaluate the output of the command with a Java routine. The interface CmdExecuter.ExecuteAfterFinish can be overridden in any application for that appoach.
    - 2016-08-26 Hartmut new: splitArgs(String, String[], String[]) with pre- and post-arguments. Therewith both the invocation of a batch in Windows with "cmd.exe" can be organized as a Linux cmd with "sh.exe" can be invoked. The possibility execute(String, String, Appendable, Appendable, boolean) with "useShell=true" is not the favor because it is only one of the necessities. Nevertheless it works now with initial setting of sConsoleInvocation.
    - 2015-07-18 Hartmut chg: Now on execute(String[], String, Appendable, Appendable) etc. the error can be the same as the output. It is equate to error=null, only one output instance is used.
    - 2013-07-12 Hartmut new: #execute(String[], boolean, String, List, List) now with donotwait
    - 2013-07-12 Hartmut new: execute(String[], String, List, List) for more as one output or error. It is nice to write a process output similar to the System.out and to a internal buffer while the process runs. Catching in a buffer and write to System.out after the process is finished is not fine if the process needs some time or hangs.
    - 2012-11-19 Hartmut bug: Command line arguments in "": now regarded in splitArgs(String).
    - 2012-02-02 Hartmut bug: Calling abortCmd(): There was a situation were in CmdExecuter.OutThread.run() readline() hangs, though the process was destroyed. It isn't solved yet. Test whether it may be better to read the InputStream direct without wrapping with an BufferedReader.
    - 2011-12-31 Hartmut bugfix: The OutThread doesn't realize that the process was finished, because BufferedReader.ready() returns false and the buffer was not checked. So 'end of file' was not detected. Therefore CmdExecuter.OutThread.bProcessIsRunning set to false to abort waiting.
    - 2011-11-17 Hartmut new close() to stop threads.
    - 2011-10-09 Hartmut chg: rename 'execWait' to execute(String, String, Appendable, Appendable) because it has the capability of no-wait too.
    - 2011-10-09 Hartmut new: abortCmd(). experience: On windows the output getting thread may block.
    - 2011-10-08 chg the execute(String[], String, Appendable, Appendable) waits until all outputs are gotten in the outThread and errThread. Extra class CmdExecuter.OutThread for both errThread and outThread.
    - 2011-10-02 chg some experiences: It needs parallel threads to capture the output. Extra threads for out and err, because a read() waits in the out-Buffer and blocks while an error-info is present etc. The outputs should presented while the process runs, not only if it is finished. It is because the user should be informed why a process blocks or waits for something etc. This fact is implemented already in MainCmd.executeCmdLine(String[], ProcessBuilder, int, Appendable, String).
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    
    Constant Field Values
  - processBuilder
```
private final java.lang.ProcessBuilder processBuilder
```
    Composite instance of the java.lang.ProcessBuilder.
  - process
```
private java.lang.Process process
```
    The running process or null. Note that this class supports only running of one process at one time.
  - executeAfterCmd
```
private CmdExecuter.ExecuteAfterFinish executeAfterCmd
```
    Set with an execute invocation, set to null if it was processed.
  - echoCmd
```
private java.lang.Appendable echoCmd
```
    Can be set especially for debug the commands.
  - charsetCmd
```
private java.nio.charset.Charset charsetCmd
```
    A maybe special charset for Input and output stream. Hint: git uses UTF-8
  - bRunThreads
```
boolean bRunThreads
```
    True for ever so long this class is used, it maybe so long this application runs.
  - outThread
```
private final CmdExecuter.OutThread outThread
```
    Both thread instances runs for ever so long bRunThreads is true. They handle the output and error output if a process runs, and waits elsewhere.
  - errThread
```
private final CmdExecuter.OutThread errThread
```
    Both thread instances runs for ever so long bRunThreads is true. They handle the output and error output if a process runs, and waits elsewhere.
  - threadExecOut
```
final java.lang.Thread threadExecOut
```
    True if a process is started, false if it is finished.
  - threadExecIn
```
final java.lang.Thread threadExecIn
```
  - threadExecError
```
final java.lang.Thread threadExecError
```
  - cmdQueue
```
java.util.concurrent.ConcurrentLinkedQueue<CmdExecuter.CmdQueueEntry> cmdQueue
```
  - jzcmdExecuter
```
private JZtxtcmdExecuter jzcmdExecuter
```
    For JZtxtcmdScript.Subroutine. It is created on demand if necessity.
  - sConsoleInvocation
```
java.lang.String[] sConsoleInvocation
```
- Constructor Detail
  - CmdExecuter
```
public CmdExecuter()
```
    Constructs the class and starts the threads to getting output and error stream and putting the input stream to a process. This three threads runs anytime unless the class is garbaged or finalize() is called manually.
    
    Note: Starting of threads only if a command is executed results in a longer waiting time for fast simple commands. The input and output putting/getting threads wait in a while-loop until a command is executed.
- Method Detail
  - initJZcmdExecuter
```
public void initJZcmdExecuter(JZtxtcmdScript script,
                              java.lang.String sCurrdir,
                              LogMessage log)
                       throws java.lang.Throwable
```
    Throws:
    
    java.lang.Throwable
  - setCurrentDir
```
public void setCurrentDir(java.io.File dir)
```
    Sets the current directory for the next execution.
    
    Parameters:
    
    dir - any directory in the users file system.
  - setCharsetForOutput
```
public void setCharsetForOutput(java.lang.String nameCharset)
```
  - environment
```
public java.util.Map<java.lang.String,java.lang.String> environment()
```
    Returns the environment map for the internal ProcessBuilder. The returned Map can be modified, its modified content will be used on the next execute(...) invocation. The modification is valid for all following executes.
    Internal: ProcessBuilder.environment() will be called.
    
    Returns:
    
    the environment of the following executes, able to explore, able to change.
  - getRemoveEnv
```
private java.lang.String getRemoveEnv(java.lang.String name)
```
  - setEnv
```
public java.lang.String setEnv(java.lang.String name,
                               java.lang.String value)
```
    Sets an environment variable.
    
    Parameters:
    
    name - Note: For MS-Windows use setEnvIgnoreCase(String, String)
    
    value -
    
    Returns:
    
    the given value before, null if it was not defined. Usable for information.
  - setEnvIgnoreCase
```
public java.lang.String setEnvIgnoreCase(java.lang.String name,
                                         java.lang.String value)
```
    Sets an environment variable.
    
    Parameters:
    
    name - If a variable with abbreviating case exists, this will be deleted.
    
    value -
    
    Returns:
    
    the given value before, null if it was not defined. Usable for information.
  - prefixEnv
```
public java.lang.String prefixEnv(java.lang.String name,
                                  java.lang.String value)
```
    Adds a prefix or sets an environment variable, especially usable for PATH.
    
    Parameters:
    
    name - Note: For MS-Windows use prefixEnvIgnoreCase(String, String)
    
    value - add as prefix to existing value, or the new value if not exists.
    
    Returns:
    
    the given value before, null if it was not defined. Usable for information.
  - prefixEnvIgnoreCase
```
public java.lang.String prefixEnvIgnoreCase(java.lang.String name,
                                            java.lang.String value)
```
    Adds a prefix or sets an environment variable, especially usable for PATH.
    
    Parameters:
    
    name - If a variable with abbreviating case exists, this will be deleted.
    
    value - add as prefix to existing value, or the new value if not exists.
    
    Returns:
    
    the given value before, null if it was not defined. Usable for information.
  - outAllEnvironment
```
public void outAllEnvironment(java.lang.Appendable out)
                       throws java.io.IOException
```
    Outputs all environment variables in a sorted form
    
    Parameters:
    
    out -
    
    Throws:
    
    java.io.IOException
  - specifyConsoleInvocation
```
public void specifyConsoleInvocation(java.lang.String cmd)
```
  - setEchoCmdOut
```
public void setEchoCmdOut(java.lang.Appendable echo)
```
    Possible to use for debugging which commands are executed.
    
    Parameters:
    
    echo - Write the cmd and args to echo before execution. It writes in form: >cmdExecuter>cmd <args> <args>
  - addCmd
```
public void addCmd(java.lang.String cmdline,
                   java.lang.String input,
                   java.lang.Appendable output,
                   java.io.File currentDir,
                   CmdExecuter.ExecuteAfterFinish executeAfterCmd)
```
  - addCmd
```
public void addCmd(java.lang.String[] cmdArgs,
                   java.lang.String input,
                   java.util.List<java.lang.Appendable> outputs,
                   java.util.List<java.lang.Appendable> errors,
                   java.io.File currentDir,
                   CmdExecuter.ExecuteAfterFinish executeAfterCmd)
```
  - addCmd
```
public void addCmd(JZtxtcmdScript.Subroutine jzsub,
                   java.util.List<DataAccess.Variable<java.lang.Object>> args,
                   java.lang.Appendable out,
                   java.io.File currDir)
```
    Same as addCmd(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, Appendable, File, ExecuteAfterFinish) but without execFinish
    
    Parameters:
    
    jzsub -
    
    args -
    
    out -
    
    currDir -
  - addCmd
```
public void addCmd(JZtxtcmdScript.Subroutine jzsub,
                   java.util.List<DataAccess.Variable<java.lang.Object>> args,
                   java.lang.Appendable out,
                   java.io.File currDir,
                   CmdExecuter.ExecuteAfterFinish execFinish)
```
    Adds a Subroutine of an jzTc script to execute. The subroutine can invoke a cmd for a new process internally, this cmdExecuter is used because the given instance of a JZtxtcmdExecuter knows this.
    Note: call initJZcmdExecuter(JZtxtcmdScript, String, LogMessage) with that script which contains the sub routine before call this operation.
    
    Note: The execution of the subroutine is done in maybe another thread which call executeCmdQueue(boolean). Hint: It can be done for example by the main thread in a graphical application. The execution of complex callbacks on graphical buttons should not be done in the graphic thread!
    
    Parameters:
    
    jzsub - The dedicated subroutine from the script given with initJZcmdExecuter(JZtxtcmdScript, String, LogMessage)
    
    args - proper arguments
    
    out - The <:>...<.> text output is written into
    
    currDir - current directory for script execution
    
    execFinish - maybe null, this operation is called on finishing the subroutine. Maybe the text output on out should be append to an graphical window or such other, or the resulting files are used.
  - clearCmdQueue
```
public void clearCmdQueue()
```
  - hasEntries
```
public boolean hasEntries()
```
    Returns true if the associated queue has at least on entry. This operation can be used to check whether it is necessary to call executeCmdQueue(boolean) for example also for a specific breakpoint in an application:
    
    Returns:
  - executeCmdQueue
```
public CmdExecuter.CmdQueueEntry executeCmdQueue(boolean abortOnError)
```
    Executes the commands stored with #addCmd(String[], String, List, List, ExecuteAfterFinish). This can be invoked in a specific thread with the following pattern:
```
  Thread cmdThread = new Thread("gitGui-Cmd") {
```
    Parameters:
    
    abortOnError - stops execution if a command does not return 0.
    
    Returns:
    
    the last executed entry if an error occurs and 'abortOnError'==true. Elsewhere null
  - execute
```
public int execute(java.lang.String cmdLine,
                   java.lang.String input,
                   java.lang.Appendable output,
                   java.lang.Appendable error)
```
    Executes a command with arguments and waits for its finishing.
    
    Parameters:
    
    cmdLine - The command and its arguments in one line. To separate the command and its argument the method splitArgs(String) is used.
    
    input - The input stream of the command. TODO not used yet.
    
    output - Will be filled with the output of the command.
    
    error - Will be filled with the error output of the command. Maybe null or equal output, then the error output will be written to output with the same output thread.
  - execute
```
public int execute(java.lang.String cmdLine,
                   java.lang.String input,
                   java.lang.Appendable output,
                   java.lang.Appendable error,
                   boolean useShell)
```
    Executes a command with arguments and waits for its finishing. This routine is intent to open a shell window. It is not ready yet. On windows it should invoke cmd.exe, on linux maybe console. It should be configured for this instance. see #setConsoleInvocation(String).
    
    Parameters:
    
    cmdLine - The command and its arguments in one line. To separate the command and its argument the method splitArgs(String) is used.
    
    input - The input stream of the command. TODO not used yet.
    
    output - Will be filled with the output of the command.
    
    error - Will be filled with the error output of the command. Maybe null or equal output, then the error output will be written to output with the same output thread.
  - execute
```
public int execute(java.lang.String[] cmdArgs,
                   java.lang.String input,
                   java.lang.Appendable output,
                   java.lang.Appendable error)
```
    Executes a command with arguments and maybe waits for its finishing.
    
    Parameters:
    
    cmdArgs - The command and its arguments. The command is cmdArgs[0]. Any argument have to be given with one element of this String array.
    
    input - The input stream of the command. TODO not used yet.
    
    output - Will be filled with the output of the command. If output ==null then no output is expected and the end of command execution is not awaited. But in this case error should not be ==null because errors of command invocation are written there.
    
    error - Will be filled with the error output of the command. Maybe null or equal output, then the error output will be written to output with the same output thread.
    
    Returns:
    
    exit code if output !=null. If output==null the end of command execution is not awaited.
  - execute
```
public int execute(java.lang.String[] cmdArgs,
                   java.lang.String input,
                   java.util.List<java.lang.Appendable> outputs,
                   java.util.List<java.lang.Appendable> errors)
```
    Same as #execute(String[], String, Appendable, Appendable, boolean) but do not wait for finish if both outputs and errors are null.
    
    Parameters:
    
    cmdArgs -
    
    input -
    
    outputs -
    
    errors -
    
    Returns:
  - execute
```
public int execute(java.lang.String[] cmdArgs,
                   boolean donotwait,
                   java.lang.String input,
                   java.util.List<java.lang.Appendable> outputs,
                   java.util.List<java.lang.Appendable> errors,
                   CmdExecuter.ExecuteAfterFinish executeAfterCmd)
```
    Executes a command with arguments and maybe waits for its finishing.
    
    Parameters:
    
    cmdArgs - The command and its arguments. The command is cmdArgs[0]. Any argument have to be given with one element of this String array.
    
    donotwait - true and all outputs, errors and input == null, then starts the process without wait. If one of input, outputs and errors is not null, the execution should wait in this thread because the threads for input, output and error should be running to capture that data. Then this flag is not used.
    
    input - The input stream of the command. TODO not used yet.
    
    outputs - Will be filled with the output of the command. If output ==null then no output is expected and the end of command execution is not awaited. But in this case error should not be ==null because errors of command invocation are written there.
    
    errors - Will be filled with the error output of the command. Maybe null, then the error output will be written to output
    
    executeAfterCmd - maybe null, will be executing if given. If the process waits it waits on end of this method.
    
    Returns:
    
    exit code if it is waiting for execution, elsewhere 0.
  - abortCmd
```
public boolean abortCmd()
```
    Aborts the running cmd.
    
    Returns:
    
    true if any cmd is aborted.
  - abortAllCmds
```
public boolean abortAllCmds()
```
  - splitArgs
```
public static java.lang.String[] splitArgs(java.lang.String line)
```
    Splits command line arguments. See splitArgs(String, String[], String[]), without preArgs and postArgs.
  - splitArgs
```
public static java.lang.String[] splitArgs(java.lang.String line,
                                           int npreArgs,
                                           int npostArgs)
```
    Splits command line arguments. The arguments can be separated with one or more as one spaces (typical for command lines) or with white spaces. If arguments are quoted with "" or '' also maybe nested, it are taken as one argument. The line can be a text with more as one line, for example one line per argument. If a "##" is contained, the text until the end of line is ignored.
    
    Parameters:
    
    line - The line or more as one line with arguments
    
    npreArgs - maybe 0, some arguments before them from line.
    
    npostArgs - maybe 0, some arguments after them from line.
    
    Returns:
    
    Space for all arguments, the line arguments written in one String per element starting from npreArgs.
  - splitArgs
```
public static java.lang.String[] splitArgs(java.lang.String line,
                                           java.lang.String[] preArgs,
                                           java.lang.String[] postArgs)
```
    Splits command line arguments with given pre- and post arg array. See splitArgs(String, int, int).
    
    Parameters:
    
    line - The line or more as one line with arguments
    
    preArgs - maybe null, some arguments before them from line.
    
    postArgs - maybe null, some arguments after them from line.
    
    Returns:
    
    All arguments written in one String per element.
  - stop
```
void stop()
```
  - close
```
public void close()
```
    Closes the functionality, finished the threads.
    
    Specified by:
    
    close in interface java.io.Closeable
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
  - finalize
```
public void finalize()
```
    Stops the threads to get output.
    
    Overrides:
    
    finalize in class java.lang.Object
    
    See Also:
    
    Object.finalize()
  - main
```
public static final void main(java.lang.String[] args)
```
    A test main programm only for class test espesically in debug mode.
    
    Parameters:
    
    args - not used.

Class CmdExecuter

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

version

processBuilder

process

executeAfterCmd

echoCmd

charsetCmd

bRunThreads

outThread

errThread

threadExecOut

threadExecIn

threadExecError

cmdQueue

jzcmdExecuter

sConsoleInvocation

Constructor Detail

CmdExecuter

Method Detail

initJZcmdExecuter

setCurrentDir

setCharsetForOutput

environment

getRemoveEnv

setEnv

setEnvIgnoreCase

prefixEnv

prefixEnvIgnoreCase

outAllEnvironment

specifyConsoleInvocation

setEchoCmdOut

addCmd

addCmd

addCmd

addCmd

clearCmdQueue

hasEntries

executeCmdQueue

execute

execute

execute

execute

execute

abortCmd

abortAllCmds

splitArgs

splitArgs

splitArgs

stop

close

finalize

main