From b72f7b698e907cfed26b2b8df6f5d9200a948933 Mon Sep 17 00:00:00 2001 From: jojo Date: Wed, 30 Dec 2020 13:18:39 +0100 Subject: [PATCH] Simplify Argument Remove ArgumentType.java --- .../src/de/steamwar/command/Argument.java | 96 ++++++++++--------- .../src/de/steamwar/command/ArgumentType.java | 43 --------- .../de/steamwar/command/ArgumentUtils.java | 31 +++--- 3 files changed, 69 insertions(+), 101 deletions(-) delete mode 100644 SpigotCore_Main/src/de/steamwar/command/ArgumentType.java diff --git a/SpigotCore_Main/src/de/steamwar/command/Argument.java b/SpigotCore_Main/src/de/steamwar/command/Argument.java index 0a6b106..d481f12 100644 --- a/SpigotCore_Main/src/de/steamwar/command/Argument.java +++ b/SpigotCore_Main/src/de/steamwar/command/Argument.java @@ -33,75 +33,83 @@ import java.util.stream.Collectors; public class Argument { - public static final Argument BOOLEAN = new Argument<>(ArgumentType.BOOLEAN, bool -> true, "true", "false"); - public static final Argument INT = new Argument<>(ArgumentType.INT, integer -> true); - public static final Argument LONG = new Argument<>(ArgumentType.LONG, l -> true); - public static final Argument FLOAT = new Argument<>(ArgumentType.FLOAT, f -> true); - public static final Argument DOUBLE = new Argument<>(ArgumentType.DOUBLE, d -> true); - public static final Argument STRING = new Argument<>(ArgumentType.STRING, string -> true); + private static final Set> numbers = new HashSet<>(); + static { + numbers.add(Integer.class); + numbers.add(Long.class); + numbers.add(Double.class); + numbers.add(Float.class); + } - public static final Argument PLAYER = new Argument<>(ArgumentType.STRING, string -> Bukkit.getPlayer(string) == null, Bukkit::getPlayer, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); + public static final Argument BOOLEAN = new Argument<>(Boolean::parseBoolean, bool -> true, "true", "false"); + public static final Argument INT = new Argument<>(Integer::parseInt, integer -> true); + public static final Argument LONG = new Argument<>(Long::parseLong, l -> true); + public static final Argument FLOAT = new Argument<>(Float::parseFloat, f -> true); + public static final Argument DOUBLE = new Argument<>(Double::parseDouble, d -> true); + public static final Argument STRING = new Argument<>(s -> s, string -> true); - public static final Argument GAMEMODE = new Argument<>(ArgumentType.STRING, - string -> string.equalsIgnoreCase("creative") || string.equalsIgnoreCase("c") || string.equalsIgnoreCase("1") || - string.equalsIgnoreCase("survival") || string.equalsIgnoreCase("s") || string.equalsIgnoreCase("0") || - string.equalsIgnoreCase("spectator") || string.equalsIgnoreCase("sp") || string.equalsIgnoreCase("3") || - string.equalsIgnoreCase("adventure") || string.equalsIgnoreCase("a") || string.equalsIgnoreCase("2"), - s -> { - if (s.equalsIgnoreCase("creative") || s.equalsIgnoreCase("c") || s.equalsIgnoreCase("1")) return GameMode.CREATIVE; - if (s.equalsIgnoreCase("spectator") || s.equalsIgnoreCase("sp") || s.equalsIgnoreCase("3")) return GameMode.SPECTATOR; - if (s.equalsIgnoreCase("adventure") || s.equalsIgnoreCase("a") || s.equalsIgnoreCase("2")) return GameMode.ADVENTURE; - return GameMode.SURVIVAL; - }, () -> new String[]{"creative", "survival", "adventure", "spectator"}); + public static final Argument PLAYER = new Argument<>(Bukkit::getPlayer, Objects::nonNull, () -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)); + + public static final Argument GAMEMODE = new Argument<>(s -> { + switch (s) { + case "creative": + case "c": + case "1": + return GameMode.CREATIVE; + case "survival": + case "s": + case "0": + return GameMode.SURVIVAL; + case "spectator": + case "sp": + case "3": + return GameMode.SPECTATOR; + case "adventure": + case "a": + case "2": + return GameMode.ADVENTURE; + } + return null; + }, Objects::nonNull, "creative", "survival", "spectator"); private static final String[] materialArray = Arrays.stream(Material.values()).map(Enum::name).toArray(String[]::new); - public static final Argument MATERIAL = new Argument<>(ArgumentType.STRING, string -> Material.valueOf(string) != null, Material::valueOf, () -> materialArray); + public static final Argument MATERIAL = new Argument<>(Material::valueOf, Objects::nonNull, materialArray); private static final String[] particleArray = Arrays.stream(Particle.values()).map(Enum::name).toArray(String[]::new); - public static final Argument PARTICLE = new Argument<>(ArgumentType.STRING, string -> Particle.valueOf(string) != null, Particle::valueOf, () -> particleArray); + public static final Argument PARTICLE = new Argument<>(Particle::valueOf, Objects::nonNull, particleArray); private static final String[] entityArray = Arrays.stream(EntityType.values()).map(Enum::name).toArray(String[]::new); - public static final Argument ENTITY = new Argument<>(ArgumentType.STRING, string -> EntityType.valueOf(string) != null, EntityType::valueOf, () -> entityArray); + public static final Argument ENTITY = new Argument<>(EntityType::valueOf, Objects::nonNull, entityArray); private static final String[] soundArray = Arrays.stream(Sound.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND = new Argument<>(ArgumentType.STRING, string -> Sound.valueOf(string) != null, Sound::valueOf, () -> soundArray); + public static final Argument SOUND = new Argument<>(Sound::valueOf, Objects::nonNull, soundArray); private static final String[] soundCategoryArray = Arrays.stream(SoundCategory.values()).map(Enum::name).toArray(String[]::new); - public static final Argument SOUND_CATEGORY = new Argument<>(ArgumentType.STRING, string -> SoundCategory.valueOf(string) != null, SoundCategory::valueOf, () -> soundCategoryArray); + public static final Argument SOUND_CATEGORY = new Argument<>(SoundCategory::valueOf, Objects::nonNull, soundCategoryArray); - private ArgumentType argumentType; + private Function mapper; private Predicate constraint; private Function tabCompletes; - private Function valueMapper; - public Argument(ArgumentType argumentType, Predicate constraint, String... tabCompletes) { - this(argumentType, constraint, o -> o, () -> tabCompletes); + public Argument(Function mapper, Predicate constraint, String... tabCompletes) { + this(mapper, constraint, () -> tabCompletes); } - public Argument(ArgumentType argumentType, Predicate constraint, Supplier tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); + public Argument(Function mapper, Predicate constraint, Supplier tabCompletes) { + this(mapper, constraint, s -> tabCompletes.get()); } - public Argument(ArgumentType argumentType, Predicate constraint, Function tabCompletes) { - this(argumentType, constraint, o -> o, tabCompletes); - } - - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Supplier tabCompletes) { - this(argumentType, constraint, valueMapper, s -> tabCompletes.get()); - } - - public Argument(ArgumentType argumentType, Predicate constraint, Function valueMapper, Function tabCompletes) { - this.argumentType = argumentType; + public Argument(Function mapper, Predicate constraint, Function tabCompletes) { + this.mapper = mapper; this.constraint = constraint; - this.valueMapper = valueMapper; this.tabCompletes = tabCompletes; } public Optional valueSupplier(String s) { try { - T argumentMapped = argumentType.mapper.apply(s); + T argumentMapped = mapper.apply(s); if (constraint.test(argumentMapped)) { - return Optional.ofNullable(valueMapper.apply(argumentMapped)); + return Optional.ofNullable(argumentMapped); } } catch (NumberFormatException e) { return Optional.empty(); @@ -115,9 +123,9 @@ public class Argument { try { if (!s.isEmpty()) { // Check if mappable - T argumentMapped = argumentType.mapper.apply(s); + T argumentMapped = mapper.apply(s); // Check number constraints if needed - if (argumentType.number && !constraint.test(argumentMapped)) return Optional.empty(); + if (numbers.contains(argumentMapped.getClass()) && !constraint.test(argumentMapped)) return Optional.empty(); } return Optional.of(Arrays.stream(tabCompletes.apply(s)).filter(t -> t.startsWith(s)).collect(Collectors.toList())); } catch (NumberFormatException e) { diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java deleted file mode 100644 index 9927841..0000000 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentType.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - * / - */ - -package de.steamwar.command; - -import java.util.function.Function; - -public class ArgumentType { - - public static final ArgumentType BOOLEAN = new ArgumentType<>(Boolean::parseBoolean, false); - public static final ArgumentType INT = new ArgumentType<>(Integer::parseInt, true); - public static final ArgumentType LONG = new ArgumentType<>(Long::parseLong, true); - public static final ArgumentType FLOAT = new ArgumentType<>(Float::parseFloat, true); - public static final ArgumentType DOUBLE = new ArgumentType<>(Double::parseDouble, true); - public static final ArgumentType STRING = new ArgumentType<>(s -> s, false); - - Function mapper; - boolean number; - - private ArgumentType(Function mapper, boolean number) { - this.mapper = mapper; - this.number = number; - } - -} diff --git a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java index 7e325cc..6ab22dd 100644 --- a/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java +++ b/SpigotCore_Main/src/de/steamwar/command/ArgumentUtils.java @@ -31,11 +31,11 @@ public class ArgumentUtils { } public static Argument of(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equals(argument), argument); + return new Argument<>(s -> s, string -> string.equals(argument), argument); } public static Argument of(String... arguments) { - return new Argument<>(ArgumentType.STRING, string -> { + return new Argument<>(s -> s, string -> { for (String arg : arguments) { if (string.equals(arg)) return true; } @@ -44,8 +44,8 @@ public class ArgumentUtils { } public static Argument of(String[] commands, String[] tabCompletes) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : commands){ + return new Argument<>(s -> s, string -> { + for (String arg : commands) { if (string.equals(arg)) return true; } return false; @@ -58,11 +58,11 @@ public class ArgumentUtils { } public static Argument ofIgnoreCase(String argument) { - return new Argument<>(ArgumentType.STRING, string -> string.equalsIgnoreCase(argument), argument); + return new Argument<>(s -> s, string -> string.equalsIgnoreCase(argument), argument); } public static Argument ofIgnoreCase(String... arguments) { - return new Argument<>(ArgumentType.STRING, string -> { + return new Argument<>(s -> s, string -> { for (String arg : arguments) { if (string.equalsIgnoreCase(arg)) return true; } @@ -71,8 +71,8 @@ public class ArgumentUtils { } public static Argument ofIgnoreCase(String[] commands, String[] tabCompletes) { - return new Argument<>(ArgumentType.STRING, string -> { - for (String arg : commands){ + return new Argument<>(s -> s, string -> { + for (String arg : commands) { if (string.equalsIgnoreCase(arg)) return true; } return false; @@ -97,7 +97,8 @@ public class ArgumentUtils { for (int tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - return new Argument<>(ArgumentType.INT, predicate, Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new)); + String[] array = Arrays.stream(tabValues).mapToObj(i -> i + "").toArray(String[]::new); + return new Argument<>(Integer::parseInt, predicate, array); } public static Argument above(long minValue, long... tabValues) { @@ -113,7 +114,8 @@ public class ArgumentUtils { for (long tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - return new Argument<>(ArgumentType.LONG, predicate, Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new)); + String[] array = Arrays.stream(tabValues).mapToObj(l -> l + "").toArray(String[]::new); + return new Argument<>(Long::parseLong, predicate, array); } public static Argument above(float minValue, float... tabValues) { @@ -129,11 +131,11 @@ public class ArgumentUtils { for (float tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - String[] strings = new String[tabValues.length]; + String[] array = new String[tabValues.length]; for (int i = 0; i < tabValues.length; i++) { - strings[i] = tabValues[i] + ""; + array[i] = tabValues[i] + ""; } - return new Argument<>(ArgumentType.FLOAT, predicate, strings); + return new Argument<>(Float::parseFloat, predicate, array); } public static Argument above(double minValue, double... tabValues) { @@ -149,7 +151,8 @@ public class ArgumentUtils { for (double tabValue : tabValues) { if (!predicate.test(tabValue)) throw new IllegalArgumentException(); } - return new Argument<>(ArgumentType.DOUBLE, predicate, Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new)); + String[] array = Arrays.stream(tabValues).mapToObj(d -> d + "").toArray(String[]::new); + return new Argument<>(Double::parseDouble, predicate, array); } }