Arguments

java.lang.Object
- org.vishia.util.Arguments

Direct Known Subclasses:: CheckDeps.Args, FileList.Args, ReadWriteFileBase.ArgsBase, XmlJzCfgAnalyzer.CmdArgs, Zip.Args

public abstract class Arguments
extends java.lang.Object

This is a base class for simple argument handling of main(...) arguments. It substitutes the org.vishia.mainCmd.MainCmd, less dependencies. Usage example:
In your main class you should can copy this given template as sub class, change * / to end of comment and (at) to the @. :

  
  class CmdArgs extends Arguments {

    
    /**Argument is manually tested in testArgument(...) * /
    public String sTitle;

    /**Argument needs a Arguments.SetArgument(...) implementation, longer form * /
    public File fOut;
    
    public File fIn;
    
    public String sContent;
    
    /**Argument as String value defined in one definition, the value is in timestamp.val
       But it must be also added with addArg(this.timestamp), see ctor. * / 
    public Argument timestamp = new Argument("-time", ":yyyy-MM-dd+hh:mm sets a timestamp in UTC (GMT)");
    
    /**This is a single SetArgument implementation for one argument
       which should be added with {(at)link #addArg(Argument)}. Not recommended. 
 /
    Arguments.SetArgument setOutput = new Arguments.SetArgument(){ 
    (at)Override public boolean setArgument(String val){ 
      CmdArgs.this.fOut = new File(val);
      return true;
    }};
    
    
    /**All Arguments for this application.
       This is the recommended combination of all in one long array.
       use  {(at)link #addArgs(Argument[])} to add this given array.
 /
    Argument[] argsAppl =
    { new Argument("-o", ":path/to/output.file"
        , new SetArgument() { (at)Override public boolean setArgument (String val) {
          CmdArgs.this.fIn = new File(val); return CmdArgs.this.fIn.exists(); 
        } })
    , new Argument("-inZip", ":D:/path/to/file.odx:content.xml to analyze a stored XML in a zip format"
        , new SetArgument() { @Override public boolean setArgument (String val) {
          int posSep = val.indexOf(':', 3);
          if(posSep <0) { 
            return false; }
          CmdArgs.this.fIn = new File(val.substring(0, posSep));
          CmdArgs.this.sContent = val.substring(posSep+1);
          return CmdArgs.this.fIn.exists(); 
        } })
    };
    
    
    CmdArgs () {
      super.aboutInfo = "...your about info";
      super.helpInfo="obligate args: -o:...";
      //Hint: the manual tested sTitle don't need addArg(...)
      addArg(new Argument("-o", ":path/to/output.file", this.setOutput));
      addArg(this.timestamp);                    // add all single given Argument (not recommended, see next)
      addArgs(this.argsAppl);                    // add all arguments from Array
    }

    /**This operation is only necessary if arguments should be tested manually here,
       not recommended. The super.testArgument does all the work for given Argument instances.
       (at)throws FileNotFoundException * /
    (at)Override protected boolean testArgument(String arg, int nArg) throws FileNotFoundException { 
      boolean bOk = true;  //set to false if the argc is not passed
      String value;
      if( (value = checkArgVal("-title", arg)) !=null) {       
        this.sTitle = value;  //the graphic GUI-appearance
      }
      else {
        bOk = super.testArgument(arg, nArg);
      }
      return bOk;
    }

    /**This operation checks the consistence of all operations. * /
    (at)Override public boolean testConsistence(Appendable msg) throws IOException {
      boolean bOk = true;
      if(this.fOut == null) { msg.append("-o:outfile obligate\n"); bOk = false; }
      if(!bOk) {
        super.showHelp(msg);
      }
      return bOk;
    }
  }

You should instantiate in your application:

  public static int amain(Args args) {
    MyAppl thiz = new MyAppl(args);          // call with your proper prepared arguments
    int exitCode = thiz.exec();              // arguments can be given whatever it is necessary or possible
    return exitCode;
  }

It offers an amain(args) which is also usable inside another Java program, with given Args, or for example inside a JzTxtCmd script where also an exception or a error return value will be processed in a specific kind.

The amain(args) is called from:

  public static int smain ( String[] sArgs, Appendable logHelp, Appendable logError) {
    CmdArgs args = new CmdArgs();                // your inherit class of Arguments
    if(sArgs.length ==0) {                       // show help if no arguments are given.
      args.showHelp(logHelp);
      return(1);                
    }
    if(  ! args.parseArgs(sArgs, logError)       // returns true if no argument error
      || ! args.testConsistence(logError)        // returns true if all arguments are proper
      ) { 
      return(254);                               // argument error
    }
    //LogMessageStream log = new LogMessageStream(System.out);
    int exitCode = amain(args);                  // internal amain with prepared Args
    return exitCode;
  }

In the main you should call:

  public static void main ( String[] sArgs) {
    try {
      int exitCode = smain(sArgs);
      System.exit(exitCode);                     // the exit code for the cmd line script
    } catch (Exception e) {                      // last fall back, unexpected exception
      System.err.println("Unexpected: " + e.getMessage());
      e.printStackTrace(System.err);
      System.exit(255);                          // the exit code for unexpected for the cmd line script
    }
  }

This class supports

Arguments in any order
Arguments starting with a prefix, typical -x:...
Detection of arguments without prefix if no prefix matches
---comment simple comment args with three minus
--@path/to/file read arguments from a file, whereas one line is one argument.
--@path/to/file:label read arguments from a part of a file after the label, see next.

The possibility to read the arguments from any file after a label provides the possibility to write arguments in the calling file which are recognized as commented lines in that file. For example:

 java -cp classpath pkg.path.Class --@localfile.bat:myLabel
 ::myLabel ##
 ::-o:path/to/myoutput  ##That is the output file for xyz
 ::inputfile
 pause

This is an example/pattern for a batch file, which contains the arguments one per line in the argument file.

The characters before the label are used as identification for the arguments lines.
- So long lines with this start chararcters, here ".." comes, this are argument lines.
- A line without this identification ends the argument line sequence.
- proper for Windows-batch script: The identification ".." is also the designation of a comment line in Windows
- For shell script use "#" or "##" instead with the same effect.
If a space and a identification for end line comments are written, here " ##", then this end line comment and all trailing spaces before the comment are removed.
Hence, a nice possibility to comment arguments. The " ##" is usual proper except you need ## in your argument.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Arguments.Argument` Class to describe one argument.
`static interface`	`Arguments.SetArgument` Interface for implementation of setting arguments.

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.lang.String`	`aboutInfo`
`private java.util.List<Arguments.Argument[]>`	`argArrays` List of all argument arrays which are not hard coded in an derivation of `testArgument(String, int)`
`private java.util.List<Arguments.Argument>`	`argList` List of all arguments which are not hard coded in an derivation of `testArgument(String, int)`
`private java.lang.Appendable`	`errMsg`
`static int`	`exitCodeArgError` Can be used as exit from main().
`private static java.text.DateFormat`	`formatDateHHmm`
`private static java.text.DateFormat`	`formatDateYYYYMMDD`
`protected java.lang.String`	`helpInfo`
`private java.lang.Appendable`	`outMsg`
`private java.lang.String`	`sLogLevel`
`private java.lang.String`	`sLogPath`
`static java.lang.String`	`sVersion` Version, history and license.

Constructor Summary

Constructors
Constructor and Description

Arguments()

Constructors
Constructor and Description
`Arguments()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.String`	`aboutInfo()`
`protected void`	`addArg(Arguments.Argument arg)` Add one argument.
`protected void`	`addArgs(Arguments.Argument[] args)` Add all arguments given in an array.
`protected boolean`	`checkArg(java.lang.String check, java.lang.String arg)` Checks whether an option arg is given without argument value.
`protected java.lang.String`	`checkArgVal(java.lang.String check, java.lang.String arg)` Check whether an arg with value is given.
`protected boolean`	`errMsg(java.lang.String text, java.lang.Object... val)` Writes an error message especially usable in the implementation of SetArguments due to the pattern: new Argument("-dirXYZ", ": Any example directory should exists", new SetArgument() { (at)Override public boolean setArgument(String val) throws IOException { File dir = new File(val).getAbsoluteFile(); if(dir.exists() && dir.isDirectory()) { CmdArgs.this.dirXYZ = dir; return true; } else { return CmdArgs.this.errMsg("-dirXYZ:%s not found as directory", dir ); } }}}
`static java.lang.String`	`getEnv(java.lang.String nameEnv)` Operation used for environment variables in arguments, see `replaceEnv(String)`.
`java.lang.String`	`getLogLevel()` Should be return int
`java.lang.String`	`getLogPath()`
`boolean`	`parseArgs(java.lang.String[] args)` This is the user operation to process all arguments from a container as String[].
`boolean`	`parseArgs(java.lang.String[] args, java.lang.Appendable errMsg)` This is the user operation to process all arguments from a container as String[].
`private boolean`	`parseArgs(java.lang.String[] args, int recursive)`
`void`	`readArguments(java.lang.String[] cmdArgs)` Read arguments from given command line arguments.
`static void`	`readConfig(java.lang.Object data, java.io.InputStream fIn, java.lang.String sLeadingDesignation, LogMessage log)` A commonly usable operation to read any configuration data, usual given in a file given as argument file.
`static void`	`readConfig(java.lang.Object data, java.lang.String sLine, LogMessage log)` Read one config value from any String.
`static java.lang.String`	`replaceEnv(java.lang.String argval)` Replaces expressions "...
`void`	`showHelp(java.lang.Appendable out)` Writes all arguments with `Argument#arg` `Arguments.Argument.help` in its order in one in a line.
`protected boolean`	`testArgument(java.lang.String argc, int nArg)` This operation tests one argument maybe from a container as String[].
`abstract boolean`	`testConsistence(java.lang.Appendable msg)` This operation should be implemented and called by the user.
`private boolean`	`tryTestArgument(java.lang.String argc, int nArg, java.lang.Appendable errMsg, java.io.Closeable farg)` Wraps `testArgument(String, int)` in try-catch to catch a user Exception while evaluating argument strings.

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

- Field Detail
  - sVersion
```
public static final java.lang.String sVersion
```
    Version, history and license. Changes:
    - 2024-09-18 Hartmut tryTestArgument(String, int, Appendable, Closeable) calls replaceEnv(...) to see the effective argument on error message.
    - 2024-09-18 Hartmut replaceEnv(String) bugfix for "...$Identifier..."
    - 2024-06-02 Hartmut new static readConfig(Object, InputStream, String, LogMessage)
    - 2024-05-25 Hartmut planned, TODO: SetArgument#setArgument(String) should return an error String, null = no error.
    - 2024-05-25 Hartmut new errMsg(String, Object...) able to call in an non static implementation of Arguments.SetArgument.setArgument(String), see javadoc there.
    - 2024-05-25 Hartmut Arguments.SetArgument.setArgument(String) can throw now IOException instead only FileNotFoundException
    - 2024-05-22 Hartmut some docu and optimization
    - 2023-12-08 Hartmut new: now supports "--@:", then the next argument string is one line per argument. This is not for command line arguments, it is for java String given arguments for example while call with a JZtxtCmd script.
    - 2023-08-09 Hartmut new: supports --help and --version
    - 2023-08-09 Hartmut new: An exception in evaluation of the argument creates a proper message, which is output or thrown. parseArgs(String[], Appendable) is now exception free, more simple in handling. If the helpInfo starts with "!" then it will be written on emtpy arguments. With that changes the usage is more simple, see example in javadoc to the class.
    - 2023-07-14 Hartmut new in replaceEnv(String): If it starts with "/tmp/" it substitutes the TMP on windows.
    - 2023-03-17 Hartmut new readArguments(String[]) as ready to usable in main().
    - 2023-01-27 Hartmut new in sArg in a argument file: "$=" is the directory of the argument file. With this designation all arguments can be related to the argfile's directory which is given in the "--@path/to/argfile". This is an amazing feature, but similar as relative links in html.
    - 2022-11-13 Hartmut chg checkArgVal(String, String) improved, see comments in code there. Accept spaces
    - 2022-11-13 Hartmut chg rename testConsistence(Appendable) instead testArgs(...), more expressive. Adaption necessary and done in all vishia Files
    - 2022-11-13 Hartmut chg all files are created with new File(System.getProperty("user.dir"), hence the current directory comes from a maybe changed user.dir in Java, not from the original operation system's one. Important if a java program runs in a JZtxtcmd script, then cd can be used.
    - 2022-05-24 Hartmut new Arguments.Argument can now also contain the value itself, more simple for pure String arguments.
    - 2022-05-24 Hartmut new possibility of --@file:label as described.
    - 2022-04-09 Hartmut Desription of class improved, from another usage.
    - 2022-04-09 Hartmut ---commented-argument now accepted
    - 2022-01-17 Hartmut only comment for usage
    - 2022-01-17 Hartmut enhancement: replaceEnv(String) with also $identifier
    - 2020-03-20 Hartmut: created, more simple as the before used MainCmd.
    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
  - formatDateYYYYMMDD
```
private static java.text.DateFormat formatDateYYYYMMDD
```
  - formatDateHHmm
```
private static java.text.DateFormat formatDateHHmm
```
  - aboutInfo
```
protected java.lang.String aboutInfo
```
  - helpInfo
```
protected java.lang.String helpInfo
```
  - argList
```
private java.util.List<Arguments.Argument> argList
```
    List of all arguments which are not hard coded in an derivation of testArgument(String, int)
  - argArrays
```
private java.util.List<Arguments.Argument[]> argArrays
```
    List of all argument arrays which are not hard coded in an derivation of testArgument(String, int)
  - exitCodeArgError
```
public static int exitCodeArgError
```
    Can be used as exit from main().
  - sLogPath
```
private java.lang.String sLogPath
```
  - sLogLevel
```
private java.lang.String sLogLevel
```
  - outMsg
```
private java.lang.Appendable outMsg
```
  - errMsg
```
private java.lang.Appendable errMsg
```
- Constructor Detail
  - Arguments
```
public Arguments()
```
- Method Detail
  - addArg
```
protected final void addArg(Arguments.Argument arg)
```
    Add one argument. Should be called in constructor of the inherited class.
    
    Parameters:
    
    arg - Should be constant initialized given in the inherited class.
  - addArgs
```
protected final void addArgs(Arguments.Argument[] args)
```
    Add all arguments given in an array. Should be called in constructor of the inherited class.
    
    Parameters:
    
    args - Should be constant initialized given in the inherited class.
  - replaceEnv
```
public static java.lang.String replaceEnv(java.lang.String argval)
```
    Replaces expressions "...$name... or $(name)... or $$name$ with the content of the named environment variable or (since 2025-03) also a System.getProperty(String) which can be set before Java-intern, replaces also start with "/tmp/" for Windows, replaces "/tmp" with the PATH stored in TMP or TEMP.
    - $name: A java-identifier format is used as name. Since 2022-01,
    - $(name): should be used if after them other Java-identifier are following, as in shell scripts
    - $$name$: Other syntax for the same approach, may be better readable.
    Parameters:
    
    argval - String with possible environment variables to replace or starting with "/tmp/..."
    
    Returns:
    
    replaced environment and/or "/tmp/". If nothing is replaced, this is identical with argval (same instance referred) Hence with argval==returnedArgval it can be checked whether a replacement was done.
    
    Throws:
    
    java.lang.IllegalArgumentException - on faulty name of environment variable
  - getEnv
```
public static final java.lang.String getEnv(java.lang.String nameEnv)
```
    Operation used for environment variables in arguments, see replaceEnv(String). Additional "DATE" and "TIME" is supported which returns "2025-04-03" and "17_45_33" adequate with the current time on call.
    
    Parameters:
    
    nameEnv -
    
    Returns:
    
    value of the environment.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the environment variable are not found.
  - testArgument
```
protected boolean testArgument(java.lang.String argc,
                               int nArg)
                        throws java.io.IOException
```
    This operation tests one argument maybe from a container as String[]. It can be overridden by the inherit Arguments class but should unconditionally also call at least
```
   super.textArgument(argc, nArg);
 
```
    Overriding may not be recommended. Use instead addArg(Argument) to add simple test snippet wrapped in an instance of Arguments.Argument.
    This operation is only called in tryTestArgument(String, int, Appendable, Closeable), which is called in parseArgs(String[], Appendable) and nothing else. It is protected to prevent faulty calling.
    - --- The argument is ignored
    - --report:value sets sLogPath
    - --rlevel:value sets sLogLevel
    Parameters:
    
    argc - The given argument
    
    nArg - position of the argument in the container, counted from 0
    
    Returns:
    
    true if argument is accepted, false if not found in the argList given on ctor
    
    Throws:
    
    java.io.FileNotFoundException - If the argument is formally accepted but evaluation cause an exception
    
    java.io.IOException
    
    Since:
    
    2023-09-21 with possible FileNotFoundException accepted by user implementations., 2024-05-24 with possible IOException accepted by user implementations because it is possible to Appendable.append(CharSequence) a message or do anything with files etc. The Exception forces an argument error., TODO it is interesting that this operation returns null if ok and a error string as error message comes from Arguments.SetArgument.setArgument(String)
  - checkArg
```
protected final boolean checkArg(java.lang.String check,
                                 java.lang.String arg)
```
    Checks whether an option arg is given without argument value. It is an alternative to checkArgVal(String, String). The arg should be identically with check
    
    Parameters:
    
    check -
    
    arg -
    
    Returns:
  - checkArgVal
```
protected final java.lang.String checkArgVal(java.lang.String check,
                                             java.lang.String arg)
```
    Check whether an arg with value is given. Possible variants in arg, whereby check is the given check String.
    - "check" returns "", no argument value
    - "check " returns "", nor argument value, trailing spaces are ignored
    - "check:value" returns "value"
    - "check=value" returns "value"
    - "check : value" returns " value", spaces before ":" are ignored
    - "check = value" returns " value"
    - "check value more text" returns "value more text", all after spaces
    - "checkother ..." returns null, check fails, "check" must end with space or : or =
    Parameters:
    
    check - The start sequence of the arg
    
    arg - given one argument, either one line in arg file, or sequence till space in cmd line
    
    Returns:
    
    null if not matching, the value it is matching.
  - parseArgs
```
public final boolean parseArgs(java.lang.String[] args)
                        throws java.io.IOException
```
    This is the user operation to process all arguments from a container as String[]. It is especially for main(String[] args)
    
    Parameters:
    
    args - The argument string array.
    
    Throws:
    
    java.io.IOException
    
    java.lang.IllegalArgumentException - on argument error
  - parseArgs
```
public final boolean parseArgs(java.lang.String[] args,
                               java.lang.Appendable errMsg)
```
    This is the user operation to process all arguments from a container as String[]. It is especially for main(String[] args)
    
    Parameters:
    
    args - The argument string array. If the helpInfo starts with "!" the help info is shown on empty arguments.
    
    errMsg - if given then all arguments will be parsed. Errors will be output here.
    
    Returns:
    
    true if all ok, but the user should call testConsistence(Appendable) afterwards. false argument error, the application may be used though if testConsistence(Appendable) returns true.
    
    Throws:
    
    java.io.IOException - only on unexpected errors writing errMsg
    
    java.lang.IllegalArgumentException - on argument error only if errMsg == null
  - parseArgs
```
private final boolean parseArgs(java.lang.String[] args,
                                int recursive)
                         throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - tryTestArgument
```
private final boolean tryTestArgument(java.lang.String argc,
                                      int nArg,
                                      java.lang.Appendable errMsg,
                                      java.io.Closeable farg)
                               throws java.io.IOException
```
    Wraps testArgument(String, int) in try-catch to catch a user Exception while evaluating argument strings.
    
    Parameters:
    
    argc -
    
    nArg -
    
    errMsg - if given, outputs the error
    
    farg - if given, close it on error if error is not given, before an IllegalArgumentException is thrown
    
    Returns:
    
    true if all is ok, false if the argument is faulty and errM(sg is given. never if errMsg==null then throws
    
    Throws:
    
    java.io.IOException - only on formally IO error on errMsg
    
    java.lang.IllegalArgumentException - if errMsg==null and the argument is faulty.
  - errMsg
```
protected boolean errMsg(java.lang.String text,
                         java.lang.Object... val)
                  throws java.io.IOException
```
    Writes an error message especially usable in the implementation of SetArguments due to the pattern:
```
   new Argument("-dirXYZ", ":  Any example directory should exists", new SetArgument() {
     (at)Override public boolean setArgument(String val) throws IOException {  
       File dir = new File(val).getAbsoluteFile();
       if(dir.exists() && dir.isDirectory()) {
         CmdArgs.this.dirXYZ = dir;
         return true;
       } else {  
         return CmdArgs.this.errMsg("-dirXYZ:%s not found as directory", dir );
       }
   }}}
 
```
    Parameters:
    
    text -
    
    val -
    
    Returns:
    
    Throws:
    
    java.io.IOException
  - showHelp
```
public void showHelp(java.lang.Appendable out)
```
    Writes all arguments with Argument#arg Arguments.Argument.help in its order in one in a line.
    
    Parameters:
    
    out - Any output channel
    
    Throws:
    
    java.io.IOException - only on unexpected problems with out
  - aboutInfo
```
public java.lang.String aboutInfo()
```
  - testConsistence
```
public abstract boolean testConsistence(java.lang.Appendable msg)
                                 throws java.io.IOException
```
    This operation should be implemented and called by the user. It should check the consistency of the given arguments as it is need by the application and may also prepare some derived arguments, for example .
    Implementation hint: This operation may invoke #showArgs(Appendable) to output the help info on error.
    
    Parameters:
    
    msg - to write out an info as line with \n for faulty arguments. System.err can be used.
    
    Returns:
    
    true if consistent.
    
    Throws:
    
    java.io.IOException - only on unexpected problems writing msg
  - readArguments
```
public void readArguments(java.lang.String[] cmdArgs)
```
    Read arguments from given command line arguments. Can be used immediately in main(). This operation calls System.exit if arguments are wrong. Alternatively use parseArgs(String[], Appendable) and testConsistence(Appendable)
    
    Parameters:
    
    cmdArgs -
  - getLogPath
```
public java.lang.String getLogPath()
```
  - getLogLevel
```
public java.lang.String getLogLevel()
```
    Should be return int
    
    Returns:
  - readConfig
```
public static void readConfig(java.lang.Object data,
                              java.io.InputStream fIn,
                              java.lang.String sLeadingDesignation,
                              LogMessage log)
                       throws java.io.IOException
```
    A commonly usable operation to read any configuration data, usual given in a file given as argument file. The file should have the form one per line:
```
 name=value; //comment
 
```
    The name is searched as element in data, and set with the given value. It calls readConfig(Object, String, LogMessage).
    Yet, booleans can only be set.
    Parameters:
    
    data - Any data class.
    
    fIn - opened Stream to read from, also able to get with Class.getResourceAsStream(String) from inside a jar archive, or just as FileInputStream
    
    sLeadingDesignation - null, then not used, possible identifier on left side of a line as designation. With them it is possible to use any other, for example a batch or shell script which holds values.
    
    Throws:
    
    java.io.IOException
  - readConfig
```
public static void readConfig(java.lang.Object data,
                              java.lang.String sLine,
                              LogMessage log)
```
    Read one config value from any String. The line should have the form
```
 name = value; //comment
 
```
    The name is searched as element in data, and set with the given value. Internally it calls DataAccess.storeValue(Object, Object, boolean) with the name via DataAccess.DatapathElement
    Yet, booleans can only be set.
    Parameters:
    
    data -
    
    sLine -
    
    log -

Class Arguments

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sVersion

formatDateYYYYMMDD

formatDateHHmm

aboutInfo

helpInfo

argList

argArrays

exitCodeArgError

sLogPath

sLogLevel

outMsg

errMsg

Constructor Detail

Arguments

Method Detail

addArg

addArgs

replaceEnv

getEnv

testArgument

checkArg

checkArgVal

parseArgs

parseArgs

parseArgs

tryTestArgument

errMsg

showHelp

aboutInfo

testConsistence

readArguments

getLogPath

getLogLevel

readConfig

readConfig