Update README.md

Change table of contents reference

Author: StevenCyb

README.md

@@ -11,8 +11,8 @@ I have needed an argument parser for some java projects. There are some librarie
     - [Get Argument Values ](#get_argument_values )
     - [Put All Together](#put_all_together)
  - [Further Examples](#further_examples)
-## Scope Of Functions
 <a name="scope_of_functions"></a>
+## Scope Of Functions
 - Define arguments needed for your console applications
     - Integer Arguments
     - Double Arguments
@@ -21,17 +21,17 @@ I have needed an argument parser for some java projects. There are some librarie
 - Define whether an argument is required
 - Define a default value
 - Define different rules for this argument
-## How To Use It
 <a name="how_to_use_it"></a>
+## How To Use It
 It's that simple: Import the JAR file (`from 'release/ArgParser_X.X'`) or the packages and classes into your project. Now you can create an `ArgumentParser` object and define your arguments. Finally, you call the parse method and pass the arguments and get the result. A more detailed description of how to use ArgParser can be found in the following sections.
-### Create The Main Object
 <a name="create_the_main_object"></a>
+### Create The Main Object
 Before the arguments are defined, a `ArgumentParser` object is required. Here `bool1` defines whether the program should be terminated if the user uses a help argument. `bool2` defines whether an exception should be thrown if a required argument is not given. `bool3` defines whether an exception should be thrown if the user enters an undefined argument.
 ```
 ArgumentParser argumentParser = new ArgumentParser(bool1, bool2, bool3);
 ```
-### Definition Simple Arguments
 <a name="definition_simple_arguments"></a>
+### Definition Simple Arguments
 The arguments are then defined. In the following example a `StringArgumentDefinition` is created. It could also be an `IntegerArgumentDefinition`, `DoubleArgumentDefinition` or `FlagArgumentDefinition`. The parameters are the same for all four. The respective argument is assigned one or more prefixes in the first parameter, e.g. `new String[]{"-s", "-src", "-source"}`. In `argumentDescription` a string can be set which describes the argument e.g. `"The image source."`. `isRequired` specifies whether this argument must be set by the user or is optional.  In `defaultValue` is deposited which value is valid for this argument by default.  
 ```
 StringArgumentDefinition sad = new StringArgumentDefinition(prefixes, argumentDescription, isRequired, defaultValue)
@@ -40,8 +40,8 @@ Then the argument definition can be added to the argument parser.
 ```
 argumentParser.add(sad);
 ```
-### Definition Arguments With Rules
 <a name="definition_arguments_with_rules"></a>
+### Definition Arguments With Rules
 Let's assume that we want to add rules to the previously created argument definition. In this example we want an argument for a PNG image. Then we could change the instantiation as follows. As an additional parameter we set an array with the type `StringArgumentRule`.  The first added rule checks if the image has the extension `.png | .PNG`. The second rule checks if the file exists and is really a file.
 ```
 StringArgumentDefinition sad = new StringArgumentDefinition(
@@ -56,8 +56,8 @@ StringArgumentDefinition sad = new StringArgumentDefinition(
 );
 ```
 For the `IntegerArgumentDefinition` use `IntegerArgumentRule` and for `DoubleArgumentDefinition` `DoubleArgumentRule`. There are no rules for `FlagArgumentDefinition` because it is a bit assignment (`true, false`) without variance.
-### Add Autogenerated Help Argument
 <a name="add_autogenerated_help_argument"></a>
+### Add Autogenerated Help Argument
 Now an automatically generated help argument can be created. As with the previous argument definitions, a prefix is defined for this. In addition, a title is defined for the output. The following example shows an instantiation of this help argument.
 ```
 argumentParser.addHelpArgument(new String[] {"-h", "-help"}, "This arguments are available:");
@@ -67,20 +67,20 @@ The output would look like this once the user enters `-h` or `-help`:
 This arguments are available:
 {-s,-src,-source}    Required: yes   Image source
 ```
-### Parse The Arguments
 <a name="parse_the_arguments"></a>
+### Parse The Arguments
 Now the arguments from the main `(String[] args)` can be passed to the parser.
 ```
 argumentParser.parse(args);
 ```
-### Get Argument Values 
 <a name="get_argument_values "></a>
+### Get Argument Values 
 To get the value after parsing, simply read the value from the respective definition object as follows.
 ```
 System.out.println(iad.getValue());
 ```
-### Put All Together
 <a name="put_all_together"></a>
+### Put All Together
 Now everything together and with an error handling.
 ```
 public class Main {
@@ -113,8 +113,8 @@ public class Main {
 	}
 }
 ```
-## Further Examples
 <a name="further_examples"></a>
+## Further Examples
 In the following example, a temperature is written to the database. As argument we want the username, the password and the table name of the database. Additionally we need the IP and a port. We also offer the user the option to disable encrypted communication. Last but not least we want a valid temperature. We assume that we have tempreatures in the range of -40 to 120 degrees.
 ```
 public class Main2 {
@@ -155,7 +155,7 @@ public class Main2 {
 			
 			System.out.println("Connect to " + mysqlIp.getValue() + ":" + mysqlPort.getValue() + (encryptedCommunication.getValue()?" with a secure connection":" with an unsafe connection"));
 			System.out.println("Use credentials Username:[" + mysqlUser.getValue() + "] Password:[" + mysqlPassword.getValue() + "]");
-			System.out.println("Insert [" + temperature.getValue() + "]°C into table [" + mysqlTable.getValue() + "]");
+			System.out.println("Insert [" + temperature.getValue() + "]°C into table [" + mysqlTable.getValue() + "]");
 			
 		} catch (NonUniquePrefixException e) {  // If that happens, you have a bug in the code
 			e.printStackTrace();
@@ -181,7 +181,7 @@ If the arguments are given `-u root -p Tutorial19 -ip 127.0.0.1 -c -temp 22.3`.
 ```
 Connect to 127.0.0.1:3306 with an unsafe connection
 Use credentials Username:[root] Password:[Tutorial19]
-Insert [22.3]°C into table [temperature_log]
+Insert [22.3]°C into table [temperature_log]
 ```
 If an unallowed port is specified `-u root -p Tutorial19 -ip 127.0.0.1 -port 42 -c -temp 22.3`, then the output is:
 ```
@@ -191,4 +191,4 @@ If the temperature argument is not given, the output is:
 ```
 Missing argument:
 {-temp,-temperature}	Temperature to log
-```
+```