MainCmd

java.lang.Object
- org.vishia.mainCmd.MainCmd

All Implemented Interfaces:

java.lang.Appendable, MainCmd_ifc, MainCmdLogging_ifc, Report, LogMessage

Direct Known Subclasses:

Bin2Data.CmdLine, C2DataDeps, CheckDeps_Old.Cmdline, CmdHeader2Reflection, Csv2Data.CmdHandler, DocuGen.CmdLine, Filecmd.Cmdline, GenXmlCfgJavaData.CmdLine, GenZbnfJavaData.CmdLine, JZtxtcmd.CmdLine, SampleCmdLine.CmdLine, Xsltpre.CmdLine, Zbnf2Xml.CmdLine, Zmake.CmdLine

Deprecated.
```
@Deprecated
public abstract class MainCmd
extends java.lang.Object
implements MainCmd_ifc
```
This is an abstract superclass to support cmd line applications. It was on of the first classes created in srcJava_vishiaBase (in 2004), meanwhile deprecated because over engineered with too much determination.
- The classes Arguments are used since 2020-03 for more powerful and simple command line argument parsing.
- The class LogMessage is used as interface for outputs.
- The implementation LogMessageStream supports proper also output to console and files.
Hence the necessity of this class is no more given. It is existing for older software.

Original documentation:
The class contains the following features:
- Support parsing of command line arguments.
- Management of the system output
- Provides an interface for reporting to a file.
- Gathering of the maximum of the exitErrorLevel, see setExitErrorLevel().
- Provides a method to execute external cmd lines in a simple way for the user, see executeCmdLine()
- store information about the application see #writeAboutInfo() and #writeHelpInfo().
You can find an application example in SampleCmdLine.

Output to console or to the command line pipes or?:
There are some approaches for outputs from an application:
- Simple command line invocation: The output is expected on the console respectively shell or cmd window. This kind of output is possible on Graphical Applications too if the application was started in a command line window.
- Command line invocation with redirected output: One can write cmd args >myOutput or one can use a pipe construction like cmd args | cmd2 args. In that cases the outputs written with System.out are written to the given channel (usual a file) respectively they are stored in a pipe to provide the input for the next command. In this cases usual the standard output System.out is redirected but not the error output.
- Graphical Applications: The graphical application may have an output window which can present the System.out.
What is need? It is nice to have some information while running an application and while occurring errors. But sometime detail information are need, and sometime the flood of information is not desired.
The report approach: : Therefore since the first version of this class a output dispatching system are implemented with the routines #report(int, String) etc.
- For usual output requests the routine #report(int, String) or #reportln(int, String) can be used from an application instead System.out.println(....). The first parameter controls whether the output is written to console channel or to the report file. With the command line arguments --report=FILE and --rlevel=WDR parsed as standard arguments the usage of levels and the file is controlled without additional programming effort. With that approach a output file 'report file' is created anyway in a command line application. The report file contains the same or more information than the console output. A command line application doesn't require the redirection in a file to get its output persistently. A persistent output is available anyway with the report file.
- The routines #writeInfo(String), #writeWarning(String) and #writeError(String) can be used to output some things as information, warning or error in the application. The output is categorized to one of this three levels. This information is written to the console output anyway. It depends on the 3. position 'W' of the --relevl=WDR whether this output is written in the report file.
- To output an exception message one can use writeError(String, Throwable).
This is the older system to output something. The interface MainCmdLogging_ifc (older version Report) supports this system.

The problem of the older output management system is: A simple application can distinguish between the 6 levels LogMessage.error to LogMessage.fineDebug. But in complex software a module may output something independent of the necessity of output of information of another module.

The second problem is: The modules which should output something may not know or use the MainCmdLogging_ifc because it may be realized as a special interface.

The LogMessage interface or MsgDispatcher: For embedded applications a message dispatching system is known. The message system writes messages with numbers and timeStamp. Such a message system was implemented in C-language applications too. That system uses Numbers for any output information. The output text can be determined with the identification number of a output message in different languages. Such capability is done by special software. The messages can be stored in a simple way in log archives or alarm state storages using only the number and additional measurement values without the message text.

This message output system with its identification number for any message can be used to dispatch any information to several output channels by using its number. With them any module can output its stuff with a number range. Whether it is output to display, to a log file or the output is suppressed, it can be controlled by the dispatching control file. That control file associates numbers or number ranges to output channels, see MsgDispatcher.setOutputRange(int, int, int, int, int)

The interface for this dispatcher is given with the LogMessage interface. The MainCmd implements the LogMessage interface. It is a super interface of MainCmdLogging_ifc. The implementation of the LogMessage in MainCmd can redirect the message to the message dispatcher or any other implementor given with setLogMessageDestination(LogMessage). The default behaviour is writing the message via #reportln(int, String) to console and the report file. Wherby the ident number is taken from the message indent number if it is 1..6 (LogMessage.error to LogMessage.fineDebug). All other ident numbers are written with reportln(LogMessage.info, line). The line contains the message ident number and the time of creation of the message. That is the simple adaption from the LogMessage approach without using of a message dispatching system.

Without change in the user's software the MsgDispatcher can be established. One can invoke setLogMessageDestination(LogMessage) and use the channels getLogMessageErrorConsole(), getLogMessageOutputConsole() and getLogMessageOutputFile() from this class as destination channels for the MessageDispatcher.

Message dispatching without numbers using System.out and System.err: The problem of the numbers is: Any log output or message should have a unified number. The programmer should handle this numbers in a global way. That number actuation is a pain in the neck if the programmer does not need the numbers at that time.

To simple to way of life the MsgPrintStream can be used to create numbers automatically. With them the simple System.out.printf("message text\n", parameter) is converted to a LogMessage invocation. The ident numbers of the messages are created automatically in a given number range or it can be set by a control String.

With them a simple System.out.printf("message text\n", parameter) is sufficient to output something and to work with the message dispatching and output management system. The dispatching is support with

Conversion from the report output to message outputs: See ReportWrapperLog. This is the adaption from the older report approach to the message system.

What should the user do:
1. If the user is intent to work with the MainCmd class, one should use the MainCmd_ifc or its super interface, the MainCmdLogging_ifc. One can use both, the MainCmd_ifc#report(int, String) invocation and the LogMessage#sendMsg(int, String, Object...) approach.
2. If the user should only work with the Message Dispatcher System independent of this MainCmd class, one should associate this class or the MsgDispatcher class as LogMessage reference. One should organize and use the message ident numbers.
3. As a independent common approach the user can use the System.out.print.... Therewith independent sources from any vishia classes can be written. Using a format
  System.out.printf("Module - message; text %d %f\n", value1, value2);
  is a proper format independent of any vishia approaches. That system matches to the redirection and conversion to the vishia message system with output channels of this class.
It seems to be a good choice to use the second approach, LogMessage if the software is specialized for message output, and to use the third approach, System.out for any other independent modules. The organization of both approaches to use the message system can be done at a centralized point in software. The example SampleCmdLine presents example outputs with that approaches.

Extension to GUI application:
This class is extended for example by org.vishia.gral.area9.GralArea9MainCmd to a class which implements the outputs on a GUI window. The methods supporting command line things are adapted there for a GUI (Graphical User Interface) -style application. In the GUI frame the user used the same interface MainCmd_Ifc to do something with the applications frame.

It is an old documentation: The user should write his application class in the followed way:
```
    ---|> means an inherition
    <>--> means a composition or aggregation
    ----> means a association


    +-------------+        +-------------+        +-------------+
    |             |------|>| MainCmd     |------|>| MainCmd_Ifc |
    |UserMainClass|        +-------------+        +-------------+
    |             |                                      ^
    |             |        +-------------+    main       |
    |             |<>----->| UserClasses |---------------+
    +-------------+        +-------------+

    in cmdlines:

    class UserMainClass extends MainCmd
    { final UserClasses userClasses = new UserClasses(this);  //... the user's classes
    }

    class UserClasses
    { final MainCmd_Ifc main;        //the aggregation to Main
      UserClasses(MainCmd_Ifc main)
      { this.main = main;
      }
    }
    
```
The UserMainClass based on MainCmd as superclass, MainCmd implements MainCmd_Ifc. All composite classes from UserMainclass may known the MainCmd instance respective the UserMainClass instance via the interface MainCmd_Ifc. With this interface the user can access at all capabilities of support of command line things, implemented cardinally in MainCmd, but overwriteable from the user in his UserMainClass.
The user should realized the evaluation of the command line arguments, help messages for command line etc. in the UserMainClass. But the functionality of the user's application should be realized not in the UserMainClass, but in the UserClass and the underlying classes. The functionality should be separated from the command line invoke, because this application's functionality can be invoked also from a comprising application, at example by a GUI (Graphical Users Interface).

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`MainCmd.Argument` Deprecated. the newer form is `Arguments`, use this for new development.
`private class`	`MainCmd.LogMessageImplConsole` Deprecated. Inner class to send a LogMessage to the `outConsole`.
`(package private) class`	`MainCmd.LogMessageImplErrConsole` Deprecated.
`(package private) class`	`MainCmd.LogMessageImplFile` Deprecated.
`static interface`	`MainCmd.SetArgument` Deprecated. the newer form is `Arguments.SetArgument`, use this for new development.
`private class`	`MainCmd.ShowCmdOutput` Deprecated. Class to write any readed stream to the output, running in a separate thread.

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.List<MainCmd.Argument>`	`argList` Deprecated.
`protected boolean`	`bHelpIswritten` Deprecated.
`protected java.lang.String[]`	`cmdLineArgs` Deprecated. array of arguments from command line
`java.lang.String`	`currdir` Deprecated.
`protected java.text.SimpleDateFormat`	`dateFormatMsg` Deprecated.
`java.io.PrintStream`	`errCmdline` Deprecated. Preserve the original System.out and System.err on construction.
`private java.lang.Appendable`	`errConsole` Deprecated. Channels for output and error output of the main program.
`FileWrite`	`fReport` Deprecated. The report file.
`private int`	`iArgs` Deprecated. number of the argument is parsing
`protected static short`	`kError_writeInfoDirectly` Deprecated.
`protected static short`	`kInfo_writeInfoDirectly` Deprecated. Some bits to mark the kind of output
`static short`	`kInfoln_writeInfoDirectly` Deprecated.
`protected static short`	`kWarning_writeInfoDirectly` Deprecated.
`java.util.List<java.lang.String>`	`listAboutInfo` Deprecated. List of strings contents about Info in form of lines.
`java.util.List<java.lang.String>`	`listHelpInfo` Deprecated. List of strings contents help Info in form of lines.
`(package private) MainCmd.LogMessageImplConsole`	`logMessageConsole` Deprecated.
`(package private) MainCmd.LogMessageImplErrConsole`	`logMessageErrConsole` Deprecated.
`(package private) MainCmd.LogMessageImplFile`	`logMessageFile` Deprecated.
`protected LogMessage`	`logMessageImplReport` Deprecated. Instance to send a LogMessage to the Log interface of maincmd.
`protected static short`	`mError_writeInfoDirectly` Deprecated. If this bit is setted in param kind of writeDirectly an error is to be outputted
`static short`	`mNewln_writeInfoDirectly` Deprecated. If this bit is setted in param kind of writeDirectly a newline should be inserted at begin of output
`protected MsgRedirectConsole`	`msgDisp` Deprecated. A standard variant of the `MsgDispatcher` for all application, which redirects System.out and System.err.
`protected static short`	`mWarning_writeInfoDirectly` Deprecated. If this bit is setted in param kind of writeDirectly a warning is to be outputted
`int`	`nLevelDisplayToReport` Deprecated. writeError(), writeWarning(), writeInfo() are also reported if the level is equal or greater than 1,2,3
`int`	`nLogLevel` Deprecated. All reports with a level less than or equal this level will be reported.
`private int`	`nMaxErrorLevel` Deprecated. The maximum of the value given with setExitErrorLevel
`int`	`nReportLevelDisplay` Deprecated. All reports with a level less than or equal this level will be written on display.
`java.io.PrintStream`	`outCmdline` Deprecated. Preserve the original System.out and System.err on construction.
`private java.lang.Appendable`	`outConsole` Deprecated. Channels for output and error output of the main program.
`private LogMessage`	`redirectLogMessage` Deprecated.
`private static java.lang.String`	`report_spaces` Deprecated. access to some spaces via Report.spaces.substring(0,n)
`private java.lang.String`	`sFileLog` Deprecated.
`private static MainCmd`	`singleton` Deprecated. Because this class is used as superclass for a command line Java invocation, it is possible to store the only one instance for a static getter method.
`static java.lang.String`	`sVersion` Deprecated. Version, history and license.

Fields inherited from interface org.vishia.mainCmd.MainCmdLogging_ifc
anytime, eventOrder, exitSuccessfull, exitUserAbort, exitWithArgumentError, exitWithErrors, exitWithFileProblems, exitWithNotes, exitWithWarnings, fineEventOrder, interested, version

Fields inherited from interface org.vishia.msgDispatch.LogMessage
dateFormat, debug, error, fineDebug, fineInfo, info, minSecondsFormat, mNeverOutputToDisplay, mReportLevel, warning

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`MainCmd()` Deprecated. Empty Constructor of the main class.
`protected`	`MainCmd(MainCmd.Argument[] argList)` Deprecated.
`protected`	`MainCmd(MainCmd.Argument[] argList, java.lang.String[] args)` Deprecated. Constructor of the main class.
`protected`	`MainCmd(java.lang.String[] args)` Deprecated. Constructor of the main class.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`addAboutInfo(java.lang.String sInfo)` Deprecated. Adds a about info-line to the internal list.
`void`	`addArgument(MainCmd.Argument[] list)` Deprecated. Adds arguments inclusively help info for this application.
`protected void`	`addHelpInfo(java.lang.String sInfo)` Deprecated. Adds a help info-line to the internal list.
`protected void`	`addMsgConfig(java.lang.String sFileName)` Deprecated.
`protected void`	`addStandardHelpInfo()` Deprecated. Adds the help info for standard arguments.
`java.lang.Appendable`	`append(char c)` Deprecated.
`java.lang.Appendable`	`append(java.lang.CharSequence csq)` Deprecated.
`java.lang.Appendable`	`append(java.lang.CharSequence csq, int start, int end)` Deprecated.
`protected void`	`callWithoutArguments()` Deprecated. Invoked from parseArguments if no argument is given.
`protected abstract boolean`	`checkArguments()` Deprecated. Checks the arguments after parsing from command line, test of consistence.
`void`	`close()` Deprecated. A call of this method closes the devices, which processed the message.
`java.lang.String`	`currdir()` Deprecated. Returns that current directory which is given by argument "--currdir=value" or which was `setcurrdir(String)`.
`int`	`executeCmdLine(java.lang.ProcessBuilder processBuilder, java.lang.String[] cmd, java.lang.String input, int nReportLevel, java.lang.Appendable output, java.lang.Appendable errOut)` Deprecated. Executes a command line call maybe as pipe, waiting for finishing..
`int`	`executeCmdLine(java.lang.ProcessBuilder processBuilder, java.lang.String cmd, java.lang.String input, int nReportLevel, java.lang.Appendable output, java.lang.Appendable errOut)` Deprecated. Executes a command line call maybe as pipe, waiting for finishing..
`int`	`executeCmdLine(java.lang.String[] cmd, int nReportLevel, java.lang.Appendable output, java.lang.String input)` Deprecated.
`int`	`executeCmdLine(java.lang.String[] cmd, java.lang.ProcessBuilder processBuilder, int nReportLevel, java.lang.Appendable output, java.lang.String input)` Deprecated.
`int`	`executeCmdLine(java.lang.String cmd, int nReportLevel, java.lang.Appendable output, java.lang.String input)` Deprecated. Execute a command invoke a cmdline call, implements MainCmd_Ifc.
`int`	`executeCmdLine(java.lang.String cmd, java.lang.ProcessBuilder processBuilder, int nReportLevel, java.lang.Appendable output, java.lang.String input)` Deprecated.
`void`	`exit()` Deprecated. Exits the cmdline application with the maximum of setted exit error level.
`void`	`flush()` Deprecated. A call of this method causes an activating of transmission of all messages since last flush.
`void`	`flushReport()` Deprecated. Writes the content in the physical medium.
`protected java.lang.String`	`getArgument(int pos)` Deprecated. Returns the argument contents.
`int`	`getExitErrorLevel()` Deprecated. get the maximum of errorLevel setted with setExitErrorLevel().
`static MainCmdLogging_ifc`	`getLogging_ifc()` Deprecated. Gets the singleton MainCmd instance as Logging interface or returns a `MainCmdLoggingStream` instance if this class is not instanciated.
`LogMessage`	`getLogMessageErrorConsole()` Deprecated. Gets a LogMessage error output.
`LogMessage`	`getLogMessageOutputConsole()` Deprecated. Gets a LogMessage output.
`LogMessage`	`getLogMessageOutputFile()` Deprecated. Gets a LogMessage output.
`java.lang.String`	`getReportFileName()` Deprecated. Returns the name of the report file to write out as info.
`int`	`getReportLevel()` Deprecated. Test wether the report is in the level.
`int`	`getReportLevelFromIdent(int ident)` Deprecated. gets the associated report level to a report identifier.
`boolean`	`isOnline()` Deprecated. Checks whether the message output is available.
`void`	`openReportfile(java.lang.String sFileReport, boolean bAppendReport)` Deprecated.
`boolean`	`parseArguments()` Deprecated. Parses the cmdLine-arguments.
`boolean`	`parseArguments(java.lang.String[] args)` Deprecated. Parses the cmdLine-arguments.
`java.lang.String`	`replaceEnv(java.lang.String argval)` Deprecated.
`void`	`report(java.lang.CharSequence sInfo, java.lang.Throwable exception)` Deprecated. Reports an exception.
`private void`	`report(java.lang.CharSequence sInfo, java.lang.Throwable exception, boolean bWrittenOnDisplay)` Deprecated. Internal method to write an exception to report.
`void`	`report(int nLevel, java.lang.CharSequence ss)` Deprecated. report appending on exist line.
`void`	`reportln(int nLevel, java.lang.CharSequence ss)` Deprecated. report begins at a new a line
`void`	`reportln(int nLevel, int nLeftMargin, java.lang.CharSequence ss)` Deprecated. report begins at a new a line with left margin
`boolean`	`sendMsg(int identNumber, java.lang.CharSequence text, java.lang.Object... args)` Deprecated. Sends a message.
`boolean`	`sendMsgTime(int identNumber, OS_TimeStamp creationTime, java.lang.CharSequence text, java.lang.Object... args)` Deprecated. Sends a message.
`(package private) void`	`sendMsgTimeToAppendableDst(java.lang.Appendable dst, int identNumber, int reportLevel, OS_TimeStamp creationTime, java.lang.CharSequence text, java.lang.Object... args)` Deprecated.
`boolean`	`sendMsgVaList(int identNumber, OS_TimeStamp creationTime, java.lang.CharSequence text, Va_list args)` Deprecated. Sends a message.
`java.lang.String`	`setcurrdir(java.lang.String newDir)` Deprecated. Sets the Property `currdir()` for this instance.
`void`	`setExitErrorLevel(int level)` Deprecated. set the exitErrorLevel of the maximum of given level of every call.
`void`	`setLogMessageDestination(LogMessage log)` Deprecated. Redirects the LogMessage implementation of this class to the given implementor.
`void`	`setOutputChannels(java.lang.Appendable outP, java.lang.Appendable errP)` Deprecated. Sets destinations for output and error output.
`int`	`setReportLevel(int newLevel)` Deprecated. Set another level inside programming.
`void`	`setReportLevelToIdent(int nLevel, int nLevelActive)` Deprecated. Sets a dedicated level number to the known output priorities.
`int`	`startCmdLine(java.lang.ProcessBuilder processBuilder, java.lang.String cmd)` Deprecated. Starts a command invocation for a independent window.
`int`	`startCmdLine(java.lang.ProcessBuilder processBuilder, java.lang.String[] cmd)` Deprecated. Starts a command invocation for a independent window.
`int`	`switchToWindowOrStartCmdline(java.lang.ProcessBuilder processBuilder, java.lang.String sCmd, java.lang.String sWindowTitle)` Deprecated. Searches the window for the already running process or starts the process with command invocation for a independent window.
`protected boolean`	`testArgument(java.lang.String argc, int nArg)` Deprecated. Tests one argument, called from parseArguments() on every argument excluding standard arguments -r and -rlevel.
`void`	`writeAboutInfo(java.lang.Appendable out)` Deprecated. prints the help info to the console output.
`void`	`writeDirectly(java.lang.CharSequence sInfo, short kind)` Deprecated. Writes the given sInfo to the output channels `#out` or `#err`.
`void`	`writeError(java.lang.CharSequence sInfo)` Deprecated. Writes an error line, implementation of MainCmd_Ifc.
`void`	`writeError(java.lang.String sInfo, java.lang.Throwable exception)` Deprecated. Writes an error line with exception info, implementation of MainCmd_Ifc.
`void`	`writeErrorDirectly(java.lang.CharSequence sInfo, java.lang.Throwable exception)` Deprecated. Writes an error line by console application directly to System.err.println with the String "EXCEPTION: " before and the exception message.
`void`	`writeHelpInfo(java.io.File outfile)` Deprecated. prints the help info to the console output.
`void`	`writeInfo(java.lang.CharSequence sInfo)` Deprecated. Writes an information, implementation of MainCmd_Ifc.
`void`	`writeInfoln(java.lang.CharSequence sInfo)` Deprecated. Writes an information line, implementation of MainCmd_Ifc.
`void`	`writeStackTrace(java.lang.Exception exception)` Deprecated. write out the stacktrace from a exception.
`void`	`writeWarning(java.lang.CharSequence sInfo)` Deprecated. Writes an warning line, implementation of MainCmd_Ifc.
`static void`	`XXXassertion(boolean condition)` Deprecated. Its a helper to set a breakpoint for assert

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

Methods inherited from interface org.vishia.msgDispatch.LogMessage
msgSec, timeCurr, timeMsg

- Field Detail
  - sVersion
```
public static java.lang.String sVersion
```
    Deprecated.
    Version, history and license. Changes:
    - 2019-12-05 Hartmut new: $$ENV$: replacement of environment variables able to use both in cmd line and in --@file
    - 2015-11-21 Hartmut bugfix: close() was missing after reading an --@args.file
    - 2014-05-31 Hartmut new: option --help:outfile
    - 2014-05-31 Hartmut chg: default value for nReportLevel = 0, only output if --rlevel= is given. Do not create unnecessary files.
    - 2014-05-31 Hartmut chg: writeError(String, Throwable) instead Exception etc.
    - 2014-05-28 Hartmut new: currdir() and currdir. It can be used by an application. Note that the System.setProperty("user.dir", value) affects the whole JVM. A MainCmd may be invoked only as a part of an Java application. Therefore the currdir is local valid. Note that the currdir and the System.setProperty("user.dir",...) both don't affects the operation system.
    - 2014-01-08 Hartmut new: getLogging_ifc(), usage MainCmd in any Java class without forwarded argument.
    - 2014-01-08 Hartmut bugfix: #sendMsgTimeToAppendableDst(Appendable, int, int, OS_TimeStamp, String, Object...) catches a IllegalFormatException
    - 2013-12-30 Hartmut chg: testArgument(String, int) emptyArg supported, was commented.
    - 2013-12-15 Hartmut new: Argument --msgcfg adds the MsgRedirectConsole to the main instance. Therewith the Conversion of System.out.println(...) and System.err... can be used in all applications. The first advantage: All messages have a time stamp.
    - 2013-07-14 Hartmut chg rule for the addArgument(Argument[]), see description of MainCmd.Argument
    - 2013-03-10 Hartmut chg Some adjustments in addArgument(Argument[]),especially old: setArguments(..) is renamed to addArgument(). It is prepared that an inherited class's main(...) can add some more arguments than the base class.
    - 2013-02-24 Hartmut improved getLogMessageOutputConsole() etc.
    - 2013-02-09 Hartmut new addArgument(Argument[]) as new method to bundle argument query and help text.
    - 2012-03-30 Hartmut new getLogMessageErrorConsole()
    - 2011-10-11 Hartmut new setOutputChannels(Appendable, Appendable). All outputs are redirect-able now. Used for output in a graphical text box.
    - 2011-07-10 JcHartmut bugfix: The method executeCmdLine(ProcessBuilder, String, String, int, Appendable, Appendable) has produced a problem because 2 spaces are given in the args instead of one. There was an empty argument therefore, which has had a negative effect to a called command (it was "bzr add", an empty argument forces addition of all files though the next arguments had contain some named files). The problem is solved with using a more complex algorithm to split arguments as a simple String.split(" "). See #splitArgs(String).
    - 2007..2011 JcHartmut Some changes
    - 2007-03-07 JcHartmut Method getReportFileName
    - 2007-03-07 JcHartmut callWithoutArgument do not exit but throws an exception likewise by an error of arguments.
    - 2006-04-02 JcHartmut writeInfo__ new methods write__Directly, solution of concurrency to write to report.
    - 2006-01-17 JcHartmut testArgument() may thrown an ParseException.
    - 2006-01-21 JcHartmut bugfix callWithoutArguments() should be protected, not package private.
    - 2004-06-00 JcHartmut initial revision
    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.
  - argList
```
protected final java.util.List<MainCmd.Argument> argList
```
    Deprecated.
  - singleton
```
private static MainCmd singleton
```
    Deprecated.
    
    Because this class is used as superclass for a command line Java invocation, it is possible to store the only one instance for a static getter method. In this kind any Java routine which is attempt to use the MainCmdLogging_ifc or MainCmd_ifc it can use this instance without a forwarded argument.
  - fReport
```
public FileWrite fReport
```
    Deprecated.
    
    The report file. This attribute is set to null, if no report is desired by missing the argument -r REPORTFILE
  - nLogLevel
```
public int nLogLevel
```
    Deprecated.
    
    All reports with a level less than or equal this level will be reported. Other report calls has non effect.
  - sFileLog
```
private java.lang.String sFileLog
```
    Deprecated.
  - currdir
```
public java.lang.String currdir
```
    Deprecated.
  - nReportLevelDisplay
```
public int nReportLevelDisplay
```
    Deprecated.
    
    All reports with a level less than or equal this level will be written on display. Note: using Report#writeInfo(String) etc. writes to display also if this attribute is 0.
  - nLevelDisplayToReport
```
public int nLevelDisplayToReport
```
    Deprecated.
    
    writeError(), writeWarning(), writeInfo() are also reported if the level is equal or greater than 1,2,3
  - listHelpInfo
```
public java.util.List<java.lang.String> listHelpInfo
```
    Deprecated.
    
    List of strings contents help Info in form of lines. The list should be filled with method addHelpInfo(String);
  - listAboutInfo
```
public java.util.List<java.lang.String> listAboutInfo
```
    Deprecated.
    
    List of strings contents about Info in form of lines. The list should be filled with method addHelpInfo(String);
  - nMaxErrorLevel
```
private int nMaxErrorLevel
```
    Deprecated.
    
    The maximum of the value given with setExitErrorLevel
  - cmdLineArgs
```
protected java.lang.String[] cmdLineArgs
```
    Deprecated.
    
    array of arguments from command line
  - iArgs
```
private int iArgs
```
    Deprecated.
    
    number of the argument is parsing
  - bHelpIswritten
```
protected boolean bHelpIswritten
```
    Deprecated.
  - report_spaces
```
private static final java.lang.String report_spaces
```
    Deprecated.
    
    access to some spaces via Report.spaces.substring(0,n)
    
    See Also:
    
    Constant Field Values
  - redirectLogMessage
```
private LogMessage redirectLogMessage
```
    Deprecated.
  - outCmdline
```
public final java.io.PrintStream outCmdline
```
    Deprecated.
    
    Preserve the original System.out and System.err on construction. It is the cmdline output and error output of the commmand line invocation.
  - errCmdline
```
public final java.io.PrintStream errCmdline
```
    Deprecated.
    
    Preserve the original System.out and System.err on construction. It is the cmdline output and error output of the commmand line invocation.
  - outConsole
```
private java.lang.Appendable outConsole
```
    Deprecated.
    
    Channels for output and error output of the main program.
  - errConsole
```
private java.lang.Appendable errConsole
```
    Deprecated.
    
    Channels for output and error output of the main program.
  - msgDisp
```
protected MsgRedirectConsole msgDisp
```
    Deprecated.
    
    A standard variant of the MsgDispatcher for all application, which redirects System.out and System.err.
  - dateFormatMsg
```
protected java.text.SimpleDateFormat dateFormatMsg
```
    Deprecated.
  - kInfo_writeInfoDirectly
```
protected static final short kInfo_writeInfoDirectly
```
    Deprecated.
    
    Some bits to mark the kind of output
    
    See Also:
    
    Constant Field Values
  - kInfoln_writeInfoDirectly
```
public static final short kInfoln_writeInfoDirectly
```
    Deprecated.
    
    See Also:
    
    Constant Field Values
  - kWarning_writeInfoDirectly
```
protected static final short kWarning_writeInfoDirectly
```
    Deprecated.
    
    See Also:
    
    Constant Field Values
  - kError_writeInfoDirectly
```
protected static final short kError_writeInfoDirectly
```
    Deprecated.
    
    See Also:
    
    Constant Field Values
  - mNewln_writeInfoDirectly
```
public static final short mNewln_writeInfoDirectly
```
    Deprecated.
    
    If this bit is setted in param kind of writeDirectly a newline should be inserted at begin of output
    
    See Also:
    
    Constant Field Values
  - mWarning_writeInfoDirectly
```
protected static final short mWarning_writeInfoDirectly
```
    Deprecated.
    
    If this bit is setted in param kind of writeDirectly a warning is to be outputted
    
    See Also:
    
    Constant Field Values
  - mError_writeInfoDirectly
```
protected static final short mError_writeInfoDirectly
```
    Deprecated.
    
    If this bit is setted in param kind of writeDirectly an error is to be outputted
    
    See Also:
    
    Constant Field Values
  - logMessageImplReport
```
protected LogMessage logMessageImplReport
```
    Deprecated.
    
    Instance to send a LogMessage to the Log interface of maincmd.
  - logMessageConsole
```
MainCmd.LogMessageImplConsole logMessageConsole
```
    Deprecated.
  - logMessageErrConsole
```
MainCmd.LogMessageImplErrConsole logMessageErrConsole
```
    Deprecated.
  - logMessageFile
```
MainCmd.LogMessageImplFile logMessageFile
```
    Deprecated.
- Constructor Detail
  - MainCmd
```
protected MainCmd()
```
    Deprecated.
    
    Empty Constructor of the main class. Note: One can use this constructor and #setArguments(Argument[]) and parseArguments(String[]) instead of MainCmd(Argument[], String[]).
    
    On construction the referenced Printstreams of System.out and System.err are preserved inside this class in outCmdline and errCmdline. One can redirect System.setOut(PrintStream) and ...setErr(...) without changing of the MainCmd outputs after construction of this. Especially the System.out and System.err can be redirected to the Message system using MsgPrintStream and MsgDispatcher with usage of the console outputs preserved in this class using getLogMessageErrorConsole(), getLogMessageOutputConsole() and getLogMessageOutputFile() of this class.
  - MainCmd
```
protected MainCmd(java.lang.String[] args)
```
    Deprecated.
    
    Constructor of the main class.
  - MainCmd
```
protected MainCmd(MainCmd.Argument[] argList)
```
    Deprecated.
  - MainCmd
```
protected MainCmd(MainCmd.Argument[] argList,
                  java.lang.String[] args)
```
    Deprecated.
    
    Constructor of the main class.
- Method Detail
  - setLogMessageDestination
```
public void setLogMessageDestination(LogMessage log)
```
    Deprecated.
    
    Redirects the LogMessage implementation of this class to the given implementor. Usual it may be the MsgDispatcher. By default the logmessage capability of this class is implemented in that kind that all messages with the ident numbers from 1 to 6 are output in the same form as #reportln(int, String) and all other ident numbers are written with reportln(LogMessage.info, messageString). The message dispatcher can be help to select the output channels of the messages.
    
    Parameters:
    
    log -
  - addArgument
```
public void addArgument(MainCmd.Argument[] list)
```
    Deprecated.
    
    Adds arguments inclusively help info for this application. This method should be called in order of addHelpInfo(String) to the correct sequence.
    
    Parameters:
    
    list - see MainCmd.Argument
  - addStandardHelpInfo
```
protected void addStandardHelpInfo()
```
    Deprecated.
    Adds the help info for standard arguments. The text is the followed:
```
    addHelpInfo("--about          show the about info");
    addHelpInfo("--help[=helpfile]  show the help info");
    addHelpInfo("--currdir=PATH   Set the currdir variable.");
    addHelpInfo("--log=FILE       write the report (log) into the given file, create or clear the file.");
    addHelpInfo("-+log=FILE      add to the end of given file or create the report file.");
    addHelpInfo("--loglevel=R     set the level of report, R is number from 1 to 6.");
    addHelpInfo("--loglevel=DR    also write reports upto level D on display, sample: ..-rlevel:24");
    addHelpInfo("--loglevel=WDR   write output also in report, W is nr from 1 to 3 (error, warning, info");
    
```
  - addHelpInfo
```
protected void addHelpInfo(java.lang.String sInfo)
```
    Deprecated.
    
    Adds a help info-line to the internal list. This method should be called from the user on startup to set the help info. The help info is used by writeHelpInfo() called if the argument --help is given or without arguments. .
    
    Parameters:
    
    info - String contains 1 line of a help Info.
  - addAboutInfo
```
protected void addAboutInfo(java.lang.String sInfo)
```
    Deprecated.
    
    Adds a about info-line to the internal list. This method should be called from the user on startup to set the about info.
    
    Parameters:
    
    info - String contains 1 line of a help Info.
  - writeHelpInfo
```
public void writeHelpInfo(java.io.File outfile)
```
    Deprecated.
    
    prints the help info to the console output. This Method may be overloaded in MainCmdWin to show the contents in a window.
  - writeAboutInfo
```
public void writeAboutInfo(java.lang.Appendable out)
```
    Deprecated.
    
    prints the help info to the console output. This Method may be overloaded in MainCmdWin to show the contents in a window.
  - parseArguments
```
public final boolean parseArguments()
                             throws java.text.ParseException
```
    Deprecated.
    
    Parses the cmdLine-arguments. The args should be set in constructor.
    
    Throws:
    
    java.text.ParseException
    
    See Also:
    
    parseArguments(String [] args)
  - parseArguments
```
public final boolean parseArguments(java.lang.String[] args)
                             throws java.text.ParseException
```
    Deprecated.
    Parses the cmdLine-arguments. The user should invoked this method in his static main method with the following pattern:
```
  public static void main(String[] args){
    Args argData = new Args();
    Cmdline cmd = new Cmdline(argData);
    boolean bOk;
    try{ bOk = cmd.parseArguments(args);
    } catch(ParseException exc){
      cmd.setExitErrorLevel(MainCmd.exitWithArgumentError);
      bOk = false;
    }
    if(bOk) {
      UserClass main = new UserClass(argData.x, argData.y);
      main.exec(argData.z);
    }
    cmd.exit();
  }
 
```
    Within this pattern the parsing of the arguments is independent of the user class. It may be an advantage of architecture of the user class. Some argument values can be used as initial values on construction of the user class. They can be stored there in 'final' Associations.
    
    In that pattern the Argument values are stored in an independent class Args, which is an independent mediator between the MainCmd and the UserClass.
    
    One can use the #setArguments(Argument[]) to define which arguments are used in which kind. In the older form (till 2012), the user was requested to override this method.
    
    Standard arguments See addStandardHelpInfo().
    - --about show the help infos
    - --help[=helpfile] show the help infos");
    - --currdir=PATH Set the currdir variable.
    - --log=FILE write the report (log) into the given file, create or clear the file.");
    - --log+=FILE add to the end of given file or create the report file.");
    - --loglevel=R set the level of report, R is number from 1 to 6.");
    - --loglevel=DR also write reports upto level D on display, sample: ..-rlevel:24");
    - --loglevel=WDR write output also in report, W is nr from 1 to 3 (error, warning, info");
    - --@ARGFiLE The ARGFILE contains one argument per line. Especially it is possible to use spaces in the argument values without "". For example a cmd line invocation >cmd -a arg1 --@file -x argx results in the followed arguments:
      -a arg1 arguments-from-file-lines -x argx
    What does this method:
    On every not-standard argument this method calles testArgument(String, int) inside. That method checks any argument, see there. If that method returns false, a #writeError(String) with a matched text is called and a ParseException("", N) ist thrown, N is the number of the argument. Standard arguments are parsed here, see addStandardHelpInfo(). On end the method checkArguments() is called if other then standard arguments are given. If it returns false, an ParseException("", 0) is thrown. The user should had write an output message with writeError() inside its checkArguments()
    Parameters:
    
    arg - The given arguments from command line invocation.
    
    Returns:
    
    true if other then the standard arguments are given. Only then checkArguments() was called.
    
    Throws:
    
    java.text.ParseException
    
    See Also:
    
    addArgument(Argument[])
  - openReportfile
```
public void openReportfile(java.lang.String sFileReport,
                           boolean bAppendReport)
                    throws java.io.FileNotFoundException
```
    Deprecated.
    
    Specified by:
    
    openReportfile in interface MainCmdLogging_ifc
    
    Throws:
    
    java.io.FileNotFoundException
  - checkArguments
```
protected abstract boolean checkArguments()
```
    Deprecated.
    
    Checks the arguments after parsing from command line, test of consistence. This method must overwrite from the user, may be with a return true. The method is ocalled at last inside parseArguments(). If this method returns false, parseArguments throws an exception in the same manner if on argument errors.
    
    Returns:
    
    true if all is ok. If false,
  - callWithoutArguments
```
protected void callWithoutArguments()
                             throws java.text.ParseException
```
    Deprecated.
    
    Invoked from parseArguments if no argument is given. In the default implementation a help info is written and the application is terminated. The user should overwrite this method if the call without comand line arguments is meaningfull.
    
    Throws:
    
    java.text.ParseException
  - getArgument
```
protected java.lang.String getArgument(int pos)
```
    Deprecated.
    Returns the argument contents. The user should invoke this method in his testArgument()-method. If the actually argument is longer as pos, the contents is the substring starts on pos. If the actually argument is no longer as pos( in praxis equal pos), the contents is the contents of the next argument. In this way the getArgument()-method supplies both argument methods:
    - -kcontents
    - -k contents
    In this sample -k is the key to recognize the argument and contens is the appendant content.
    Parameters:
    
    pos - position of the beginning of the information in a argument. In the sample above use the value 2.
  - testArgument
```
protected boolean testArgument(java.lang.String argc,
                               int nArg)
                        throws java.io.FileNotFoundException
```
    Deprecated.
    
    Tests one argument, called from parseArguments() on every argument excluding standard arguments -r and -rlevel. The user can overwrite this method to test the application-specific parameters. This non-overridden method uses the #setArgumentList(Argument[])
    
    Parameters:
    
    argc - The argument to test
    
    nArg - number of argument, the first argument is numbered with 1.
    
    Returns:
    
    false, if the argument doesn't match, true if ok. if the method returns false, an exception in parseArgument is thrown to abort the argument test or to abort the program. @see parseArgument().
    
    Throws:
    
    java.io.FileNotFoundException
    
    java.text.ParseException - The method may thrown this exception if a conversion error or such other is thrown.
  - replaceEnv
```
public java.lang.String replaceEnv(java.lang.String argval)
```
    Deprecated.
  - currdir
```
public java.lang.String currdir()
```
    Deprecated.
    Returns that current directory which is given by argument "--currdir=value" or which was setcurrdir(String). Note that the currdir is not checked whether it is valid and existing. It should be an existing valid normalized absolute path. The application should check it because the path may be existing and removed than. There is no guarantee possible.
    
    Use that currdir to create File instances independent of the operation system's current dir which is present on command line by start the application:
```
   File myFile = new File(currdir(), "relative/path");
 
```
    Note that the
```
   System.setProperty("user.dir", currdir);
 
```
    has a global effect for the running JVM, but it has no effect to the operation system. It means
```
   System.setProperty("user.dir", "/My/Workingplace");
   File myFile = new File("relative.path");
   String abspath = myFile.getAbsolutePath();
 
```
    Does not work proper! If the relative File is used to open anything, the open process is done on the operation system level. But the operation system does not know anything about a changed current dir. But the File.getAbsolutePath() works with the JVM-global setting of "user.dir". That is confusion, which depends on the history and technique.
    
    Therefore the only one way to work with changed current directories is: Handle it in the application. This routine is a helper of that.
    Specified by:
    
    currdir in interface MainCmd_ifc
  - setcurrdir
```
public java.lang.String setcurrdir(java.lang.String newDir)
```
    Deprecated.
    
    Sets the Property currdir() for this instance.
    
    Specified by:
    
    setcurrdir in interface MainCmd_ifc
    
    Parameters:
    
    newDir - any String which should contain an absolute normalized valid path to an existing directory. The path is not tested here, it should be tested in the user's application because it may be depending on any user's condition.
    
    Returns:
    
    The old value of currdir().
  - setExitErrorLevel
```
public void setExitErrorLevel(int level)
```
    Deprecated.
    
    set the exitErrorLevel of the maximum of given level of every call.
    
    Specified by:
    
    setExitErrorLevel in interface MainCmdLogging_ifc
    
    Parameters:
    
    level - Errorlevel how defined in Report, 0 is the lowest level (successfull), >0 is worse.
  - getExitErrorLevel
```
public int getExitErrorLevel()
```
    Deprecated.
    
    get the maximum of errorLevel setted with setExitErrorLevel().
    
    Specified by:
    
    getExitErrorLevel in interface MainCmdLogging_ifc
    
    Returns:
    
    the errorlevel
  - setOutputChannels
```
public void setOutputChannels(java.lang.Appendable outP,
                              java.lang.Appendable errP)
```
    Deprecated.
    
    Sets destinations for output and error output. Per default the PrintStreams which are referenced from System.out and System.err on construction of this class are set. That is the console output if this class is construct during processing a public main(String[] args)-routine, this routine is invoked froma cmd line call and the output and error channels of the command line are not redirected.
    
    This method allows to redirect the output and error used from #writeDirectly(String, short) and from the implementations of getLogMessageOutputConsole() and getLogMessageErrorConsole(). If the It is recommended that this channels shall be unchanged, it means this method should not used. It is reasonable to use this method only for tests.
    Carefull should be taken: If System.setOut or System.setErr is redirected using MsgPrintStream and that output is directed to this class, and then setOuputChannels(System.out, System.err) is set, it escalates in a self-calling loop with stack overflow.
    
    Specified by:
    
    setOutputChannels in interface MainCmdLogging_ifc
    
    Parameters:
    
    outP - Destination for output. If null, current output isn't change.
    
    errP - Destination for error output. If null, current output isn't change.
  - exit
```
public void exit()
```
    Deprecated.
    
    Exits the cmdline application with the maximum of setted exit error level. This method should be called only on end of the application, never inside. If the user will abort the application from inside, he should throw an exception instead. So an comprising application may catch the exception and works beyond. This method is not member of MainCmd_Ifc and is setted protected, because the users Main class (UserMain in the introcuction) only should call exit.
  - executeCmdLine
```
public int executeCmdLine(java.lang.String cmd,
                          int nReportLevel,
                          java.lang.Appendable output,
                          java.lang.String input)
```
    Deprecated.
    
    Execute a command invoke a cmdline call, implements MainCmd_Ifc.
    
    Specified by:
    
    executeCmdLine in interface MainCmd_ifc
    
    Parameters:
    
    cmd - String represents the command with all arguments. The arguments must be separated by exactly one space. The rest of paramter and return see executeCmdLine(String[], ...).
  - executeCmdLine
```
@Deprecated
public int executeCmdLine(java.lang.String[] cmd,
                                       int nReportLevel,
                                       java.lang.Appendable output,
                                       java.lang.String input)
```
    Deprecated.
    
    Execute a command invoke a cmdline call, implements MainCmd_Ifc. The call must not be needed any input. The output is written with a separate thread, using the internal (private) class ShowCmdOutput. This class use the method writeInfoln() from here. The writeInfoln-Method writes to console for MainCmd, but it may be overloaded, to example for MainCmdWin it may be writed to a box in the GUI.
    
    Specified by:
    
    executeCmdLine in interface MainCmd_ifc
    
    Parameters:
    
    cmd - String with the separeted parts of the command. cmd[0] is the command to invoke.
    
    nReportLevel - Determines the kind of writing the output. Possible values are 1..6 using Report.error to Report.fineInfo and -1..-3 using -Report.error to -report.info (with a negativ sign!). On negativ values the report is written to display with the write..()-methods of this interface, with the positive value, the report is written to Report.report..()-Methods.
    The error output is always written to the reportfile with Report.error or with writeError().
    Example: -3 detemines, that the normal output is written with writeInfoln() and the error output is written with writeError(), 3 detemines that the normal output is written with reportln(3,...) and the error output is written with Report(1, ...).
    
    output - If not null, than the stdout is written in this Buffer. If null, the stdout is written to report.
    
    input - If not null, this input is send to the cmdline process. If null, no input is send.
    
    Returns:
    
    exitErrorLevel from the command line process.
  - executeCmdLine
```
@Deprecated
public int executeCmdLine(java.lang.String cmd,
                                       java.lang.ProcessBuilder processBuilder,
                                       int nReportLevel,
                                       java.lang.Appendable output,
                                       java.lang.String input)
```
    Deprecated.
    
    Execute a command invoke a cmdline call, implements MainCmd_Ifc. The call must not be needed any input. The output is written with a separate thread, using the internal (private) class ShowCmdOutput. This class use the method writeInfoln() from here. The writeInfoln-Method writes to console for MainCmd, but it may be overloaded, to example for MainCmdWin it may be writed to a box in the GUI.
  - executeCmdLine
```
@Deprecated
public int executeCmdLine(java.lang.String[] cmd,
                                       java.lang.ProcessBuilder processBuilder,
                                       int nReportLevel,
                                       java.lang.Appendable output,
                                       java.lang.String input)
```
    Deprecated.
    
    Parameters:
    
    cmd -
    
    processBuilder -
    
    nReportLevel -
    
    output -
    
    input -
    
    Returns:
  - executeCmdLine
```
public int executeCmdLine(java.lang.ProcessBuilder processBuilder,
                          java.lang.String cmd,
                          java.lang.String input,
                          int nReportLevel,
                          java.lang.Appendable output,
                          java.lang.Appendable errOut)
```
    Deprecated.
    
    Executes a command line call maybe as pipe, waiting for finishing.. The output is written with a separate thread, using the internal (private) class ShowCmdOutput.
    
    Specified by:
    
    executeCmdLine in interface MainCmd_ifc
    
    Parameters:
    
    processBuilder - The ProcessBuilder. There may be assigned environment variables and a current directory.
    
    cmd - The cmd and arguments. If it is null, the command assigened to the processBuilder is used. The command can contain arguments separated with spaces (usual for command lines) or white spaces. The method #splitArgs(String) is used.
    
    input - Any pipe-input. It may be null.
    
    nReportLevel - The report level which is used for output. If it is 0, then the output isn't written
    
    output - The output pipe.
    
    sAnswer - The error pipe. If it is null, then errors are written in the output pipe.
    
    Returns:
  - executeCmdLine
```
public int executeCmdLine(java.lang.ProcessBuilder processBuilder,
                          java.lang.String[] cmd,
                          java.lang.String input,
                          int nReportLevel,
                          java.lang.Appendable output,
                          java.lang.Appendable errOut)
```
    Deprecated.
    
    Executes a command line call maybe as pipe, waiting for finishing.. The output is written with a separate thread, using the internal (private) class ShowCmdOutput.
    
    Specified by:
    
    executeCmdLine in interface MainCmd_ifc
    
    Parameters:
    
    processBuilder - The ProcessBuilder. There may be assigned environment variables and a current directory.
    
    cmd - The cmd and arguments. If it is null, the command assigend to the processBuilder is used.
    
    input - Any pipe-input. It may be null.
    
    nReportLevel - The report level which is used for output. If it is 0, then the output isn't written
    
    output - The output pipe.
    
    sAnswer - The error pipe. If it is null, then errors are written in the output pipe.
    
    Returns:
  - startCmdLine
```
public int startCmdLine(java.lang.ProcessBuilder processBuilder,
                        java.lang.String cmd)
```
    Deprecated.
    
    Starts a command invocation for a independent window. This command does not have any input or output. The command will be started, the finishing isn't await. This command line invocation is proper for commands, which create a new window in the operation system. The new window has its own live cycle then, independent of the invocation.
    
    Specified by:
    
    startCmdLine in interface MainCmd_ifc
    
    Parameters:
    
    cmd - The command. Some arguments are possible, they should be separated by space.
    
    processBuilder - The processBuilder.
    
    Returns:
  - startCmdLine
```
public int startCmdLine(java.lang.ProcessBuilder processBuilder,
                        java.lang.String[] cmd)
```
    Deprecated.
    
    Starts a command invocation for a independent window. This command does not have any input or output. The command will be started, the finishing isn't await. This command line invocation is proper for commands, which create a new window in the operation system. The new window has its own live cycle then, independent of the invocation.
    
    Specified by:
    
    startCmdLine in interface MainCmd_ifc
    
    Parameters:
    
    cmd - The command and some arguments.
    
    processBuilder - The processBuilder.
    
    Returns:
    
    0 on success, 255 if any start error.
  - switchToWindowOrStartCmdline
```
public int switchToWindowOrStartCmdline(java.lang.ProcessBuilder processBuilder,
                                        java.lang.String sCmd,
                                        java.lang.String sWindowTitle)
```
    Deprecated.
    
    Description copied from interface: MainCmd_ifc
    
    Searches the window for the already running process or starts the process with command invocation for a independent window. This command does not have any input or output. The command will be started, the finishing isn't await. This command line invocation is proper for commands, which create a new window in the operation system. The new window has its own live cycle then, independent of the invocation.
    
    Specified by:
    
    switchToWindowOrStartCmdline in interface MainCmd_ifc
    
    Parameters:
    
    processBuilder - The processBuilder.
    
    sWindowTitle - The title or the start of the window if the process is running already. Note: The title is depending from the application. Sometimes the title starts with the associated file, forex calling windows-notepad.
    
    Returns:
    
    0 on success, 255 if any start error.
  - writeInfo
```
public final void writeInfo(java.lang.CharSequence sInfo)
```
    Deprecated.
    
    Writes an information, implementation of MainCmd_Ifc. The info is written also to report depended on command line arguments --rlevel. If the user will overwrite the kind of output, overwrite writeInfoDirectly, it is called here.
    
    Specified by:
    
    writeInfo in interface LogMessage
    
    Parameters:
    
    sInfo - String to be written.
  - writeInfoln
```
public final void writeInfoln(java.lang.CharSequence sInfo)
```
    Deprecated.
    
    Writes an information line, implementation of MainCmd_Ifc. The info is written also to report depended on command line arguments --rlevel. If the user will overwrite the kind of output, overwrite writeInfolnDirectly, it is called here.
    
    Specified by:
    
    writeInfoln in interface LogMessage
    
    Parameters:
    
    sInfo - String to be written.
  - writeWarning
```
public final void writeWarning(java.lang.CharSequence sInfo)
```
    Deprecated.
    
    Writes an warning line, implementation of MainCmd_Ifc. The info is written also to report depended on command line arguments --rlevel. If the user will overwrite the kind of output, overwrite writeWarningDirectly, it is called here.
    
    Specified by:
    
    writeWarning in interface LogMessage
    
    Parameters:
    
    sInfo - The error text, it should be without such hot spot words line "!!!WARNING!!!", because the distinction in display should be done by the implementation of this method. A good sample is writeErrorln("file is empty: " + sFileName);
  - writeError
```
public final void writeError(java.lang.CharSequence sInfo)
```
    Deprecated.
    
    Writes an error line, implementation of MainCmd_Ifc. The info is written also to report depended on command line arguments --rlevel. If the user will overwrite the kind of output, overwrite writeErrorDirectly, it is called here.
    
    Specified by:
    
    writeError in interface LogMessage
    
    Parameters:
    
    sInfo - The error text, it should be without such hot spot words line "!!!ERROR!!!", because the distinction in display should be done by the implementation of this method. A good sample is writeErrorln("cannot create file: " + sFileName);
  - writeError
```
public final void writeError(java.lang.String sInfo,
                             java.lang.Throwable exception)
```
    Deprecated.
    
    Writes an error line with exception info, implementation of MainCmd_Ifc. The info is written also to report depended on command line arguments --rlevel. If the user will overwrite the kind of output, overwrite writeErrorDirectly, it is called here.
    
    Specified by:
    
    writeError in interface LogMessage
    
    exception - The catched Exception. The getMessage()-part of the exception is written after sError. The stacktrace of the exception is written to report.
  - writeStackTrace
```
public void writeStackTrace(java.lang.Exception exception)
```
    Deprecated.
    
    write out the stacktrace from a exception. Writes into reportfile and on screen
    
    Specified by:
    
    writeStackTrace in interface MainCmdLogging_ifc
  - writeDirectly
```
public void writeDirectly(java.lang.CharSequence sInfo,
                          short kind)
```
    Deprecated.
    
    Writes the given sInfo to the output channels #out or #err. That channels are gotten from System.out and System.err on construction of this class. Usual that channels are non-overriden, so that it is the console output.
    
    If System.setErr(PrintStream) or System.setOut(PrintStream) was invoked, this routine is not influenced.
    
    This method is overrideable espscially to redirect the output to a graphical window instead to console. Another possibility to change the output is setOutputChannels(Appendable, Appendable).
    
    Parameters:
    
    sInfo - The String to write
    
    kind - Combination of bits mWarning_writeInfoDirectly, mError_writeInfoDirectly or mNewln_writeInfoDirectly.
  - writeErrorDirectly
```
public void writeErrorDirectly(java.lang.CharSequence sInfo,
                               java.lang.Throwable exception)
```
    Deprecated.
    
    Writes an error line by console application directly to System.err.println with the String "EXCEPTION: " before and the exception message. The user can overwrite this method in the derived class of MainCmd to change to kind of output.
    
    Parameters:
    
    sInfo - Text to write in the new line after "EXCEPTION: ".
    
    exception - Its getMessage will be written.
  - report
```
public void report(int nLevel,
                   java.lang.CharSequence ss)
```
    Deprecated.
    
    report appending on exist line. If the report contains an newline char \n, a char '|' will be written. This newline is not interpreted as newline for the report file, but only as stochastic contents in the string.
    
    Specified by:
    
    report in interface LogMessage
    
    Parameters:
    
    nLevel - write the report only if the demand level is greater or equal. Use LogMessage.error etc.
    
    ss - String to write.
  - reportln
```
public void reportln(int nLevel,
                     int nLeftMargin,
                     java.lang.CharSequence ss)
```
    Deprecated.
    
    report begins at a new a line with left margin
    
    Specified by:
    
    reportln in interface LogMessage
    
    Parameters:
    
    nLevel - write the report only if the demand level is greater or equal.
    
    nLeftMargin - determins a left margin. First a new line is outputted, followed by '*' and spaces.
    
    ss - String to write.
  - reportln
```
public void reportln(int nLevel,
                     java.lang.CharSequence ss)
```
    Deprecated.
    
    Description copied from interface: LogMessage
    
    report begins at a new a line
    
    Specified by:
    
    reportln in interface LogMessage
    
    Parameters:
    
    nLevel - write the report only if the demand level is greater or equal.
    
    ss - String to write.
  - report
```
public void report(java.lang.CharSequence sInfo,
                   java.lang.Throwable exception)
```
    Deprecated.
    
    Reports an exception. This report is written unconditional, like MainCmdLogging_ifc.error. On Display, this report is only written if display output is enabled for the level MainCmdLogging_ifc.error.
    
    Specified by:
    
    report in interface LogMessage
    
    Parameters:
    
    sInfo - Text to write in the new line after "EXCEPTION: ".
    
    exception - Exception info to write
  - report
```
private void report(java.lang.CharSequence sInfo,
                    java.lang.Throwable exception,
                    boolean bWrittenOnDisplay)
```
    Deprecated.
    
    Internal method to write an exception to report. A third parameter idicates, wether or not the writing to display is always done.
    
    Parameters:
    
    sInfo - Text to write in the new line after "EXCEPTION: " and before the exception.getMessage is written.
    
    exception - Exception info to write
    
    bWrittenOnDisplay - true, than the writing to display is always done.
  - getReportLevel
```
public int getReportLevel()
```
    Deprecated.
    
    Test wether the report is in the level.
    
    Specified by:
    
    getReportLevel in interface LogMessage
    
    Returns:
    
    The report level, defined by user invoking.
  - setReportLevel
```
public int setReportLevel(int newLevel)
```
    Deprecated.
    
    Set another level inside programming. It is advisable to restore the old level after the designated operation.
    
    Specified by:
    
    setReportLevel in interface LogMessage
    
    Parameters:
    
    newLevel - The level to be set, use one of the defines MainCmdLogging_ifc.info to MainCmdLogging_ifc.fineDebug
    
    Returns:
    
    the current level, usefull to restore it.
  - flushReport
```
public void flushReport()
```
    Deprecated.
    
    Description copied from interface: LogMessage
    
    Writes the content in the physical medium. The implementation of flush is in the best way as possible. It depends on the possibilities of the output medium.
    
    Specified by:
    
    flushReport in interface LogMessage
  - setReportLevelToIdent
```
public void setReportLevelToIdent(int nLevel,
                                  int nLevelActive)
```
    Deprecated.
    
    Description copied from interface: LogMessage
    
    Sets a dedicated level number to the known output priorities. This method helps to define several levels to dispatch it.
    Specified by:
    
    setReportLevelToIdent in interface LogMessage
    nLevelActive - Ones of the known priotity levels Report.error to Report.fineDebug.
    Example of using:
    class MyModule { /**Define module-specific numbers to identify a level. * The numbers should be define regarding a band of numbers in the application. * / static final int myReportLevel1 = 3500, myReportLevel2=3501; void init() { setLevelActive(myReportLevel1, Report.info); //This reports should be outputted always setLevelActive(myReportLevel2, Report.debug); //This reports are debug infos. } void processAnything() { report.reportln( myReportLevel1, "InfoText"); //It depends on the report level settings report.reportln( myReportLevel2, "DebugText");//whether it is outputed or not. }
  - getReportLevelFromIdent
```
public int getReportLevelFromIdent(int ident)
```
    Deprecated.
    
    Description copied from interface: LogMessage
    
    gets the associated report level to a report identifier.
    
    Specified by:
    
    getReportLevelFromIdent in interface LogMessage
    
    Parameters:
    
    ident - The identifier.
    
    Returns:
    
    the level.
  - getReportFileName
```
public java.lang.String getReportFileName()
```
    Deprecated.
    
    Description copied from interface: MainCmd_ifc
    
    Returns the name of the report file to write out as info.
    
    Specified by:
    
    getReportFileName in interface MainCmd_ifc
    
    Returns:
    
    name of Reportfile.
  - addMsgConfig
```
protected void addMsgConfig(java.lang.String sFileName)
```
    Deprecated.
  - sendMsg
```
public boolean sendMsg(int identNumber,
                       java.lang.CharSequence text,
                       java.lang.Object... args)
```
    Deprecated.
    
    Sends a message. The timestamp of the message is build with the system time. All other parameter are identically see #sendMsg(int, OS_TimeStamp, String, Object...).
    
    Specified by:
    
    sendMsg in interface LogMessage
    
    Parameters:
    
    identNumber - of the message. If it is negative, it is the same message as positive number, but with information 'going state', where the positive number is 'coming state'.
    
    text - The text representation of the message, format string, see java.lang.String.format(..).
    
    args - 0, 1 or more arguments of any type. The interpretation of the arguments is controlled by param text.
    
    Returns:
    
    true if the message will be dispatched, false if it is suppressed
  - sendMsgTime
```
public boolean sendMsgTime(int identNumber,
                           OS_TimeStamp creationTime,
                           java.lang.CharSequence text,
                           java.lang.Object... args)
```
    Deprecated.
    
    Sends a message.
    
    Specified by:
    
    sendMsgTime in interface LogMessage
    
    Parameters:
    
    identNumber - of the message. If it is negative, it is the same message as positive number, but with information 'going state', where the positive number is 'coming state'.
    
    creationTime - absolute time stamp. @Java2C=perValue.
    
    text - The text representation of the message, format string, see java.lang.String.format(..).
    
    args - 0, 1 or more arguments of any type. The interpretation of the arguments is controlled by param text.
    
    Returns:
    
    true if the message will be dispatched, false if it is suppressed
  - sendMsgVaList
```
public boolean sendMsgVaList(int identNumber,
                             OS_TimeStamp creationTime,
                             java.lang.CharSequence text,
                             Va_list args)
```
    Deprecated.
    
    Sends a message. The functionality and the calling parameters are identically with #sendMsg(int, OS_TimeStamp, String, Object...), but the parameter args is varied:
    
    Specified by:
    
    sendMsgVaList in interface LogMessage
    
    Parameters:
    
    identNumber -
    
    creationTime -
    
    text -
    
    typeArgs - Type chars, ZCBSIJFD for boolean, char, byte, short, int, long, float double.
    
    args - Reference to a buffer which contains the values for a variable argument list.
    In C implementation it is a reference either to the stack, or to a buffer elsewhere, but the reference type is appropriate to provide the values in stack for calling routines with variable argument list such as vprintf(buffer, text, args). The referenced instance shouldn't accepted as persistent outside processing time of the called routine. Therefore stack content is able to provide.
    In Java it is a special class wrapping a Object[] tantamount to a Object... as variable argument list. Using of this wrapper class is only a concession to C-programming, because in Java an Object[] would adequate.
    
    Returns:
    
    true than okay. It is possible, that a destination for dispatching is not available yet. Than the routine returns false. That is for special outputs of message dispatcher. Normally the user shouldn't realize false here and react anywise. If a message isn't able to transport, it is not visible in the creating thread. It is possible that a message is lost anywhere in transportation way. In Generally, to secure a complex systems functionality, any timeouts, repeats and backup strategies are necessary in the supervise software above sending a single message.
  - append
```
public java.lang.Appendable append(java.lang.CharSequence csq)
                            throws java.io.IOException
```
    Deprecated.
    
    Specified by:
    
    append in interface java.lang.Appendable
    
    Throws:
    
    java.io.IOException
  - append
```
public java.lang.Appendable append(java.lang.CharSequence csq,
                                   int start,
                                   int end)
                            throws java.io.IOException
```
    Deprecated.
    
    Specified by:
    
    append in interface java.lang.Appendable
    
    Throws:
    
    java.io.IOException
  - append
```
public java.lang.Appendable append(char c)
                            throws java.io.IOException
```
    Deprecated.
    
    Specified by:
    
    append in interface java.lang.Appendable
    
    Throws:
    
    java.io.IOException
  - close
```
public void close()
```
    Deprecated.
    
    A call of this method closes the devices, which processed the message. It is abstract. It depends from the kind of device, what close mean. If the device is a log file writer it should be clearly. close may mean, the processing of messages is finite temporary. An open occurs automatically, if a new message is dispatched.
    
    Specified by:
    
    close in interface LogMessage
  - flush
```
public void flush()
```
    Deprecated.
    
    A call of this method causes an activating of transmission of all messages since last flush. It is abstract. It depends from the kind of device, what flush mean. If the device is a log file writer it should be clearly. flush may mean, the processing of messages is ready to transmit yet.
    
    Specified by:
    
    flush in interface LogMessage
  - isOnline
```
public boolean isOnline()
```
    Deprecated.
    
    Checks whether the message output is available.
    
    Specified by:
    
    isOnline in interface LogMessage
  - sendMsgTimeToAppendableDst
```
final void sendMsgTimeToAppendableDst(java.lang.Appendable dst,
                                      int identNumber,
                                      int reportLevel,
                                      OS_TimeStamp creationTime,
                                      java.lang.CharSequence text,
                                      java.lang.Object... args)
```
    Deprecated.
  - getLogMessageOutputConsole
```
public LogMessage getLogMessageOutputConsole()
```
    Deprecated.
    
    Description copied from interface: Report
    
    Gets a LogMessage output.
    
    Specified by:
    
    getLogMessageOutputConsole in interface Report
    
    Returns:
    
    never null.
  - getLogMessageErrorConsole
```
public LogMessage getLogMessageErrorConsole()
```
    Deprecated.
    
    Description copied from interface: Report
    
    Gets a LogMessage error output.
    
    Specified by:
    
    getLogMessageErrorConsole in interface Report
    
    Returns:
    
    never null.
  - getLogMessageOutputFile
```
public LogMessage getLogMessageOutputFile()
```
    Deprecated.
    
    Description copied from interface: Report
    
    Gets a LogMessage output.
    
    Specified by:
    
    getLogMessageOutputFile in interface Report
    
    Returns:
    
    never null.
  - getLogging_ifc
```
public static MainCmdLogging_ifc getLogging_ifc()
```
    Deprecated.
    
    Gets the singleton MainCmd instance as Logging interface or returns a MainCmdLoggingStream instance if this class is not instanciated.
  - XXXassertion
```
public static void XXXassertion(boolean condition)
```
    Deprecated.
    
    Its a helper to set a breakpoint for assert
    
    Parameters:
    
    condition -

Class MainCmd

Nested Class Summary

Field Summary

Fields inherited from interface org.vishia.mainCmd.MainCmdLogging_ifc

Fields inherited from interface org.vishia.msgDispatch.LogMessage

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.vishia.msgDispatch.LogMessage

Field Detail

sVersion

argList

singleton

fReport

nLogLevel

sFileLog

currdir

nReportLevelDisplay

nLevelDisplayToReport

listHelpInfo

listAboutInfo

nMaxErrorLevel

cmdLineArgs

iArgs

bHelpIswritten

report_spaces

redirectLogMessage

outCmdline

errCmdline

outConsole

errConsole

msgDisp

dateFormatMsg

kInfo_writeInfoDirectly

kInfoln_writeInfoDirectly

kWarning_writeInfoDirectly

kError_writeInfoDirectly

mNewln_writeInfoDirectly

mWarning_writeInfoDirectly

mError_writeInfoDirectly

logMessageImplReport

logMessageConsole

logMessageErrConsole

logMessageFile

Constructor Detail

MainCmd

MainCmd

MainCmd

MainCmd

Method Detail

setLogMessageDestination

addArgument

addStandardHelpInfo

addHelpInfo

addAboutInfo

writeHelpInfo

writeAboutInfo

parseArguments

parseArguments

openReportfile

checkArguments

callWithoutArguments

getArgument

testArgument

replaceEnv

currdir

setcurrdir

setExitErrorLevel

getExitErrorLevel

setOutputChannels

exit

executeCmdLine

executeCmdLine

executeCmdLine

executeCmdLine

executeCmdLine

executeCmdLine

startCmdLine

startCmdLine

switchToWindowOrStartCmdline