Added new Paragraph

-Type Matches auf eigene Typen ermöglichen

CommandFramework.md

@@ -35,15 +35,45 @@ public class TestCommand extends SWCommand {
     }
 
     @Register
-    public void entry1(CommandSender sender, int argument) {
+    public void pattern1(CommandSender sender, int argument) {
         System.out.println(argument);
     }
 
     @Register
-    public void entry2(CommandSender sender, boolean argument) {
+    public void pattern2(CommandSender sender, boolean argument) {
         System.out.println(argument);
     }
 }
 
 ``` 
 Betrachten wir nun folgende Eingabe eines Users `/test true` da *true* ein `boolean`-Wert ist wird das Framework `entry2` aufrufen, da diese Methode genau ein boolean-Argument akzeptiert. Betrachten wir nun einen weiteren Aufruf: `/test 12`. Bei diesem Aufruf wurde ein Argument vom Typ `int` angegeben. Also wir `entry1` aufgerufen.
+
+## Type Matches auf eigene Typen ermöglichen ##
+Um Matchings auf einen eigenen Typen zu ermöglichen, ist es zuerst notwendig einen *TypeMapper* zu schreiben. Hierzu ist es notwendig das `TypeMapper`-Interface zu implementieren. Bei dieser Implementation ist es notwendig die `map`-Methode zu implementieren. In dieser Methode definierst du, wie der Command Input auf den gewünschten Typ gemappt wird. Zusätzlich musst du auch noch die  `tabCompletes`-Methode implementiern. In dieser bestimmst du, welche TabCompleations dem Nutzer, abhängig vom Momentanen und vorheriegen Inputs vorgeschlagen werden. Schauen wir uns dies nun einmal an einem Beispiel an:
+
+``` java
+public class BooleanMapper extends TypeMapper<Boolean>{
+       
+    @Override
+    public Boolean map(Object sender, PreviousArguments previousArguments, String s) {
+        if (s.equalsIgnoreCase("true")) return true;
+        if (s.equalsIgnoreCase("false")) return false;
+        return null;
+    }
+
+    @Override
+    public List<String> tabCompletes(Object sender, PreviousArguments previousArguments, String s) {
+        return Arrays.asList("true", "false");
+    }
+}
+```
+
+Nachdem wir nun den Mapper defeniert haben ist es noch notwendig den Mapper zu registrieren. Hierzu erstellst du  eine Methode, die eine Instanz des Mappers zurück gibt. Diese Methode annotierst du dan noch mit `@ClassMapper(value=Type.class, local=true)`. Das Atribut `value` muss hierbei auf die Klasse des zu matchenden Typen gesetzt werden. Weiterhin kanst du mit `local` defenieren, ob der Mapper nur innerhalb der Klasse, oder Global gelten soll. Der Code zu dem vorheriegen Beispiel sähe zum Beispiel so aus:
+
+``` java 
+@ClassMapper(value=Boolean.class, local=false)
+public TypeMapper<Boolean> booleanMapper(){
+    return new BooleanMapper();
+}
+
+```