SpigotCore_Main/src/de/steamwar/command/Argument.java

@@ -134,11 +134,4 @@ public class Argument<T> {
         }
     }
 
-    @Override
-    public String toString() {
-        return "Argument{" +
-                "tabCompletes=" + Arrays.toString(tabCompletes.apply("")) +
-                '}';
-    }
-
 }

SpigotCore_Main/src/de/steamwar/command/ArgumentMap.java

@@ -21,6 +21,7 @@
 package de.steamwar.command;
 
 import java.util.Arrays;
+import java.util.stream.Collectors;
 
 public class ArgumentMap {
 
@@ -56,17 +57,7 @@ public class ArgumentMap {
 
     @Override
     public String toString() {
-        StringBuilder st = new StringBuilder();
-        st.append("ArgumentMap{");
-        boolean b = false;
-        for (Object o : objects) {
-            if (b) st.append(", ");
-            b = true;
-
-            st.append(o.getClass().getSimpleName()).append("=").append(o);
-        }
-        st.append("}");
-        return st.toString();
+        return "ArgumentMap{" + Arrays.stream(objects).map(o -> o.getClass().getSimpleName() + "=" + o.toString()).collect(Collectors.joining(",")) + "}";
     }
 
 }

SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java

@@ -21,6 +21,8 @@
 package de.steamwar.command;
 
 import java.util.Arrays;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
 import java.util.function.Predicate;
 
 public class ArgumentUtils {
@@ -29,29 +31,22 @@ public class ArgumentUtils {
         throw new IllegalStateException("Utility class");
     }
 
+    private static boolean contains(String[] arguments, String string, BiPredicate<String, String> predicate) {
+        for (String arg : arguments) if (predicate.test(string, arg)) return true;
+        return false;
+    }
+
     public static Argument<String> of(String argument) {
         return new Argument<>(s -> s, string -> string.equals(argument), argument);
     }
 
     public static Argument<String> of(String... arguments) {
-        return new Argument<>(s -> s, string -> {
-            for (String arg : arguments) {
-                if (string.equals(arg)) return true;
-            }
-            return false;
-        }, arguments);
+        return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments);
     }
 
     public static Argument<String> of(String[] commands, String[] tabCompletes) {
-        return new Argument<>(s -> s, string -> {
-            for (String arg : commands) {
-                if (string.equals(arg)) return true;
-            }
-            return false;
-        }, s -> {
-            if (s.isEmpty()) {
-                return tabCompletes;
-            }
+        return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> {
+            if (s.isEmpty()) return tabCompletes;
             return commands;
         });
     }
@@ -61,24 +56,12 @@ public class ArgumentUtils {
     }
 
     public static Argument<String> ofIgnoreCase(String... arguments) {
-        return new Argument<>(s -> s, string -> {
-            for (String arg : arguments) {
-                if (string.equalsIgnoreCase(arg)) return true;
-            }
-            return false;
-        }, arguments);
+        return new Argument<>(s -> s, string -> contains(arguments, string, String::equals), arguments);
     }
 
     public static Argument<String> ofIgnoreCase(String[] commands, String[] tabCompletes) {
-        return new Argument<>(s -> s, string -> {
-            for (String arg : commands) {
-                if (string.equalsIgnoreCase(arg)) return true;
-            }
-            return false;
-        }, s -> {
-            if (s.isEmpty()) {
-                return tabCompletes;
-            }
+        return new Argument<>(s -> s, string -> contains(commands, string, String::equals), s -> {
+            if (s.isEmpty()) return tabCompletes;
             return commands;
         });
     }
@@ -93,9 +76,7 @@ public class ArgumentUtils {
 
     public static Argument<Integer> between(int minValue, int maxValue, int... tabValues) {
         Predicate<Integer> predicate = i -> i >= minValue && i <= maxValue;
-        for (int tabValue : tabValues) {
-            if (!predicate.test(tabValue)) throw new IllegalArgumentException();
-        }
+        for (int tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException();
         String[] array = Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new);
         return new Argument<>(Integer::parseInt, predicate, array);
     }
@@ -110,9 +91,7 @@ public class ArgumentUtils {
 
     public static Argument<Long> between(long minValue, long maxValue, long... tabValues) {
         Predicate<Long> predicate = l -> l >= minValue && l <= maxValue;
-        for (long tabValue : tabValues) {
-            if (!predicate.test(tabValue)) throw new IllegalArgumentException();
-        }
+        for (long tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException();
         String[] array = Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new);
         return new Argument<>(Long::parseLong, predicate, array);
     }
@@ -127,13 +106,9 @@ public class ArgumentUtils {
 
     public static Argument<Float> between(float minValue, float maxValue, float... tabValues) {
         Predicate<Float> predicate = f -> f >= minValue && f <= maxValue;
-        for (float tabValue : tabValues) {
-            if (!predicate.test(tabValue)) throw new IllegalArgumentException();
-        }
+        for (float tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException();
         String[] array = new String[tabValues.length];
-        for (int i = 0; i < tabValues.length; i++) {
-            array[i] = tabValues[i] + "";
-        }
+        for (int i = 0; i < tabValues.length; i++) array[i] = tabValues[i] + "";
         return new Argument<>(Float::parseFloat, predicate, array);
     }
 
@@ -147,9 +122,7 @@ public class ArgumentUtils {
 
     public static Argument<Double> between(double minValue, double maxValue, double... tabValues) {
         Predicate<Double> predicate = d -> d >= minValue && d <= maxValue;
-        for (double tabValue : tabValues) {
-            if (!predicate.test(tabValue)) throw new IllegalArgumentException();
-        }
+        for (double tabValue : tabValues) if (!predicate.test(tabValue)) throw new IllegalArgumentException();
         String[] array = Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new);
         return new Argument<>(Double::parseDouble, predicate, array);
     }