diff --git a/CommandFramework-Old/build.gradle.kts b/CommandFramework-Old/build.gradle.kts
new file mode 100644
index 00000000..61fbf34e
--- /dev/null
+++ b/CommandFramework-Old/build.gradle.kts
@@ -0,0 +1,27 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024 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 {
+
+ private static final Map>, Map, Function>> EXECUTOR_MAPPER = new HashMap<>();
+
+ public static void addExecutorMapper(Class> wrapper, Class executorType, Function mapper) {
+ EXECUTOR_MAPPER.computeIfAbsent(wrapper, __ -> new HashMap<>())
+ .putIfAbsent(executorType, mapper);
+ }
+
+ protected final String command;
+ protected final String permission;
+ private final Consumer> initializer;
+ protected final String[] aliases;
+ protected final List descriptions = new ArrayList<>();
+
+ private boolean initialized = false;
+ protected final RootNode rootNode = new RootNode<>();
+
+ private final Map> localTypeMapper = new HashMap<>();
+ private final Map> localValidators = new HashMap<>();
+ private final Map> localSupplier = new HashMap<>();
+
+ protected AbstractCommand(String command, Consumer> initializer, String... aliases) {
+ this(command, null, initializer, aliases);
+ }
+
+ protected AbstractCommand(String command, String permission, Consumer> initializer, String... aliases) {
+ this.command = command;
+ this.permission = permission;
+ this.initializer = initializer;
+ this.aliases = aliases;
+ initCommand();
+ unregister();
+ register();
+ }
+
+ protected synchronized void initCommand() {
+ }
+
+ public abstract void unregister();
+
+ public abstract void register();
+
+ protected void commandSystemError(T sender, CommandFrameworkException e) {
+ Logger.getGlobal().log(Level.WARNING, "An unexpected error occurred", e);
+ }
+
+ protected void sendMessage(T sender, String message, Object[] args) {
+ }
+
+ public final void execute(T sender, String alias, String[] args) {
+ initialize();
+ List errors = new ArrayList<>();
+ try {
+ boolean executed = rootNode.execute(sender, new NodeData(alias, fixArgs(args), (s, args1) -> {
+ errors.add(() -> sendMessage(sender, s, args1));
+ }));
+ if (executed) return;
+ if (!errors.isEmpty()) {
+ errors.forEach(Runnable::run);
+ return;
+ }
+ descriptions.forEach(s -> sendMessage(sender, s, new Object[0]));
+ } catch (CommandFrameworkException e) {
+ commandSystemError(sender, e);
+ }
+ }
+
+ public final List tabComplete(T sender, String alias, String[] args) throws IllegalArgumentException {
+ initialize();
+ List> tabCompletes = new ArrayList<>();
+ rootNode.tabComplete(sender, new NodeData(alias, fixArgs(args), (s, args1) -> {}), tabCompletes);
+ return tabCompletes.stream()
+ .filter(Objects::nonNull)
+ .flatMap(Collection::stream)
+ .filter(Objects::nonNull)
+ .filter(s -> !s.isEmpty())
+ .distinct()
+ .collect(Collectors.toList());
+ }
+
+ private String[] fixArgs(String[] args) {
+ int removedCount = 0;
+ for (int i = 0; i < args.length; i++) {
+ String arg = args[i];
+ if (arg.isEmpty() && i != args.length - 1) {
+ removedCount++;
+ continue;
+ }
+ args[i] = args[i - removedCount];
+ }
+ if (removedCount != 0) {
+ args = Arrays.copyOf(args, args.length - removedCount);
+ }
+ if (args.length == 0) {
+ return new String[]{""};
+ }
+ return args;
+ }
+
+ private synchronized void initialize() {
+ if (initialized) return;
+
+ List commandObjects = new ArrayList<>();
+ initializer.accept(new CommandLoader<>() {
+ @Override
+ public AbstractCommand get() {
+ return AbstractCommand.this;
+ }
+
+ @Override
+ public void add(Object command) {
+ commandObjects.add(command);
+ }
+ });
+
+ List> methods = new ArrayList<>();
+ for (Object commandObject : commandObjects) {
+ DataImpl dataImpl = new DataImpl(this, commandObject, rootNode, EXECUTOR_MAPPER.getOrDefault(this.getClass(), Collections.emptyMap()), (Map) localTypeMapper, CommandUtils.MAPPER_FUNCTIONS, (Map) localValidators, CommandUtils.VALIDATOR_FUNCTIONS, (Map) localSupplier, CommandUtils.SUPPLIER_FUNCTIONS);
+ methods(commandObject).stream()
+ .filter(method -> Arrays.stream(method.getAnnotations()).anyMatch(anno -> anno.annotationType().isAnnotationPresent(Handler.Implementation.class)))
+ .forEach(method -> methods.add(new Pair<>(dataImpl, method)));
+ }
+
+ Map, List>>> handlerMap = new HashMap<>();
+ for (Pair commandMethod : methods) {
+ List annotations = CommandUtils.getAnnotations(commandMethod.b);
+ for (Annotation annotation : annotations) {
+ Handler.Implementation handler = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+ Handler handlerObject;
+ try {
+ handlerObject = handler.value().getConstructor().newInstance();
+ } catch (NoSuchMethodException | InstantiationException | IllegalAccessException |
+ InvocationTargetException e) {
+ throw new UnsupportedOperationException("Handler " + handler.value().getName() + " cannot be used to check the argument validity", e);
+ }
+ if (!(handlerObject instanceof Handler.HandlerMethod)) {
+ throw new UnsupportedOperationException("Handler " + handlerObject.getClass().getName() + " is not a HandlerMethod");
+ }
+ handlerMap.computeIfAbsent(((Handler.HandlerMethod) handlerObject).getRunPriority(), k -> new LinkedHashMap<>())
+ .computeIfAbsent(new Triple<>(commandMethod.a, commandMethod.b, annotation), k -> new ArrayList<>())
+ .add((Handler.HandlerMethod) handlerObject);
+ }
+ }
+
+ List runPriorities = new ArrayList<>(handlerMap.keySet());
+ runPriorities.sort(Comparator.naturalOrder());
+ for (int runPriority : runPriorities) {
+ handlerMap.get(runPriority).forEach((dataMethodAnnotationTriple, handlerMethods) -> {
+ handlerMethods.forEach(annotationHandlerMethod -> {
+ try {
+ annotationHandlerMethod.check(dataMethodAnnotationTriple.c, dataMethodAnnotationTriple.b, dataMethodAnnotationTriple.a);
+ } catch (Exception e) {
+ throw new UnsupportedOperationException("Method check failed for " + dataMethodAnnotationTriple.b.getName(), e);
+ }
+ annotationHandlerMethod.run(dataMethodAnnotationTriple.c, dataMethodAnnotationTriple.b, dataMethodAnnotationTriple.a);
+ });
+ });
+ }
+ rootNode.sort();
+ initialized = true;
+ }
+
+ // TODO: Implement this when Message System is ready
+ /*
+ public void addDefaultHelpMessage(String message) {
+ defaultHelpMessages.add(message);
+ }
+ */
+
+ private List methods(Object commandObject) {
+ List methods = new ArrayList<>();
+ Class current = commandObject.getClass();
+ while (current != null) {
+ methods.addAll(Arrays.asList(current.getDeclaredMethods()));
+ current = current.getSuperclass();
+ }
+ return methods;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeMapper.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeMapper.java
new file mode 100644
index 00000000..a9076eb1
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeMapper.java
@@ -0,0 +1,48 @@
+/*
+ * 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 {
+
+ /**
+ * The CommandSender can be null!
+ */
+ T map(K sender, PreviousArguments previousArguments, String s);
+
+ Collection tabComplete(K sender, PreviousArguments previousArguments, String s);
+
+ /**
+ * @return true if the next element should be appended to the current tab complete.
+ */
+ default boolean appendNextElementTabCompletions() {
+ return false;
+ }
+
+ /**
+ * Normalize the cache key by sender and user provided argument. {
+
+ T get(K sender, PreviousArguments previousArguments);
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeValidator.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeValidator.java
new file mode 100644
index 00000000..cb9de530
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeValidator.java
@@ -0,0 +1,62 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2022 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 {
+
+ /**
+ * Validates the given value.
+ *
+ * @param sender The sender of the command.
+ * @param value The value to validate or null if mapping returned null.
+ * @param messageSender The message sender to send messages to the player. Never send messages directly to the player.
+ * @return The result of the validation.
+ */
+ boolean validate(K sender, T value, MessageSender messageSender);
+
+ default AbstractTypeValidator and(AbstractTypeValidator other) {
+ return (sender, value, messageSender) -> validate(sender, value, messageSender) && other.validate(sender, value, messageSender);
+ }
+
+ default AbstractTypeValidator or(AbstractTypeValidator other) {
+ return (sender, value, messageSender) -> validate(sender, value, messageSender) || other.validate(sender, value, messageSender);
+ }
+
+ default AbstractTypeValidator not() {
+ return (sender, value, messageSender) -> !validate(sender, value, messageSender);
+ }
+
+ @FunctionalInterface
+ interface MessageSender {
+ void send(String s, Object... args);
+
+ default boolean send(boolean condition, String s, Object... args) {
+ if (condition) send(s, args);
+ return condition;
+ }
+
+ default boolean send(BooleanSupplier condition, String s, Object... args) {
+ return send(condition.getAsBoolean(), s, args);
+ }
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandFrameworkException.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandFrameworkException.java
new file mode 100644
index 00000000..cf8e7ee3
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandFrameworkException.java
@@ -0,0 +1,93 @@
+/*
+ * 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 CommandFrameworkException(Function causeMessage, T cause, Function> stackTraceExtractor, String extraStackTraces) {
+ super(causeMessage.apply(cause), cause);
+ this.causeMessage = causeMessage;
+ this.cause = cause;
+ this.stackTraceExtractor = stackTraceExtractor;
+ this.extraStackTraces = extraStackTraces;
+ }
+
+ public synchronized String getBuildStackTrace() {
+ if (message != null) {
+ return message;
+ }
+ StringBuilder st = new StringBuilder();
+ st.append(causeMessage.apply(cause)).append("\n");
+ ((Stream) stackTraceExtractor.apply(cause)).forEach(stackTraceElement -> {
+ st.append("\tat ").append(stackTraceElement.toString()).append("\n");
+ });
+ if (extraStackTraces != null) {
+ st.append("\tat ").append(extraStackTraces).append("\n");
+ }
+ message = st.toString();
+ return message;
+ }
+
+ @Override
+ public void printStackTrace() {
+ printStackTrace(System.err);
+ }
+
+ @Override
+ public void printStackTrace(PrintStream s) {
+ s.print(getBuildStackTrace());
+ }
+
+ @Override
+ public void printStackTrace(PrintWriter s) {
+ s.print(getBuildStackTrace());
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandLoader.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandLoader.java
new file mode 100644
index 00000000..b937eba6
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandLoader.java
@@ -0,0 +1,26 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 {
+
+ AbstractCommand get();
+ void add(Object command);
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandUtils.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandUtils.java
new file mode 100644
index 00000000..be9dc2e0
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandUtils.java
@@ -0,0 +1,148 @@
+/*
+ * 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 > MAPPER_FUNCTIONS = new HashMap<>();
+
+ final Map> VALIDATOR_FUNCTIONS = new HashMap<>();
+
+ final Map> SUPPLIER_FUNCTIONS = new HashMap<>();
+
+ static final AbstractTypeMapper STRING_MAPPER = new AbstractTypeMapper<>() {
+ @Override
+ public String map(Object sender, PreviousArguments previousArguments, String s) {
+ return s;
+ }
+
+ @Override
+ public Collection tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+ return Collections.singletonList(s);
+ }
+ };
+
+ static {
+ addMapper(boolean.class, Boolean.class, new BooleanMapper());
+ addMapper(int.class, Integer.class, new NumberMapper(Integer::parseInt, false));
+ addMapper(long.class, Long.class, new NumberMapper(Long::parseLong, false));
+ addMapper(float.class, Float.class, new NumberMapper(Float::parseFloat, true));
+ addMapper(double.class, Double.class, new NumberMapper(Double::parseDouble, true));
+ MAPPER_FUNCTIONS.put(String.class.getTypeName(), STRING_MAPPER);
+ }
+
+ private static void addMapper(Class clazz, Class alternativeClazz, AbstractTypeMapper mapper) {
+ MAPPER_FUNCTIONS.put(clazz.getTypeName(), mapper);
+ MAPPER_FUNCTIONS.put(alternativeClazz.getTypeName(), mapper);
+ }
+
+ public static void addMapper(Class clazz, AbstractTypeMapper mapper) {
+ addMapper(clazz.getTypeName(), mapper);
+ }
+
+ public static void addMapper(String name, AbstractTypeMapper mapper) {
+ MAPPER_FUNCTIONS.putIfAbsent(name, mapper);
+ }
+
+ public static void addValidator(Class clazz, AbstractTypeValidator validator) {
+ addValidator(clazz.getTypeName(), validator);
+ }
+
+ public static void addValidator(String name, AbstractTypeValidator validator) {
+ VALIDATOR_FUNCTIONS.putIfAbsent(name, validator);
+ }
+
+ public static void addSupplier(Class clazz, AbstractTypeSupplier supplier) {
+ addSupplier(clazz.getTypeName(), supplier);
+ }
+
+ public static void addSupplier(String name, AbstractTypeSupplier supplier) {
+ SUPPLIER_FUNCTIONS.putIfAbsent(name, supplier);
+ }
+
+ public static List getAnnotations(AnnotatedElement annotatedElement) {
+ List annotationList = new ArrayList<>();
+ for (Annotation annotation : annotatedElement.getAnnotations()) {
+ try {
+ Method method = annotation.annotationType().getMethod("value");
+ Class returnType = method.getReturnType();
+ if (!returnType.isArray()) {
+ annotationList.add(annotation);
+ continue;
+ }
+ Class innerReturnType = returnType.getComponentType();
+ if (!(innerReturnType.isAnnotation() && innerReturnType.isAnnotationPresent(Repeatable.class))) {
+ annotationList.add(annotation);
+ continue;
+ }
+ Repeatable repeatable = innerReturnType.getAnnotation(Repeatable.class);
+ Class containerType = repeatable.value();
+ if (containerType == returnType) {
+ throw new UnsupportedOperationException("Repeatable annotation must have a container annotation");
+ }
+ try {
+ Annotation[] innerAnnotations = (Annotation[]) method.invoke(annotation);
+ Collections.addAll(annotationList, innerAnnotations);
+ } catch (Exception e) {
+ annotationList.add(annotation);
+ }
+ } catch (NoSuchMethodException e) {
+ annotationList.add(annotation);
+ }
+ }
+ annotationList.removeIf(anno -> !anno.annotationType().isAnnotationPresent(Handler.Implementation.class));
+ return annotationList;
+ }
+
+ public static List getAnnotations(AnnotatedElement annotatedElement, Class type) {
+ List annotations = getAnnotations(annotatedElement);
+ annotations.removeIf(annotation -> {
+ Handler.Implementation implementation = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+ return implementation == null || !type.isAssignableFrom(implementation.value());
+ });
+ return annotations;
+ }
+
+ public static ToIntFunction createComparator(String type, Class clazz, int iValue, long lValue, float fValue, double dValue) {
+ if (clazz == int.class || clazz == Integer.class) {
+ return number -> Integer.compare(number.intValue(), iValue);
+ } else if (clazz == long.class || clazz == Long.class) {
+ return number -> Long.compare(number.longValue(), lValue);
+ } else if (clazz == float.class || clazz == Float.class) {
+ return number -> Float.compare(number.floatValue(), fValue);
+ } else if (clazz == double.class || clazz == Double.class) {
+ return number -> Double.compare(number.doubleValue(), dValue);
+ } else {
+ throw new IllegalArgumentException(type + " annotation is not supported for " + clazz);
+ }
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/DataImpl.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/DataImpl.java
new file mode 100644
index 00000000..ba0d8800
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/DataImpl.java
@@ -0,0 +1,186 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 , Function> executorMapper;
+ private final Map> mapper;
+ private final Map> globalMapper;
+ private final Map> validator;
+ private final Map> globalValidator;
+ private final Map> supplier;
+ private final Map> globalSupplier;
+
+ private final Map cache = new HashMap<>();
+
+ DataImpl(AbstractCommand container, Object self, RootNode node, Map, Function> executorMapper, Map> mapper, Map> globalMapper, Map> validator, Map> globalValidator, Map> supplier, Map> globalSupplier) {
+ this.container = container;
+ this.self = self;
+ this.node = node;
+ this.executorMapper = executorMapper;
+ this.mapper = mapper;
+ this.globalMapper = globalMapper;
+ this.validator = validator;
+ this.globalValidator = globalValidator;
+ this.supplier = supplier;
+ this.globalSupplier = globalSupplier;
+ }
+
+ @Override
+ public boolean hasExecutorMapper(Class clazz) {
+ return getExecutorMapper(clazz) != null;
+ }
+
+ @Override
+ public Function getExecutorMapper(Class clazz) {
+ for (Map.Entry, Function> entry : executorMapper.entrySet()) {
+ if (entry.getKey().isAssignableFrom(clazz)) {
+ return entry.getValue();
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public boolean hasMapper(String key) {
+ return mapper.containsKey(key) || globalMapper.containsKey(key);
+ }
+
+ @Override
+ public AbstractTypeMapper getMapper(String key) {
+ return (AbstractTypeMapper) mapper.getOrDefault(key, globalMapper.get(key));
+ }
+
+ @Override
+ public void addMapper(String key, boolean local, AbstractTypeMapper mapper) {
+ if (local) {
+ this.mapper.put(key, mapper);
+ } else {
+ this.globalMapper.putIfAbsent(key, mapper);
+ }
+ }
+
+ @Override
+ public boolean hasValidator(String key) {
+ return validator.containsKey(key) || globalValidator.containsKey(key);
+ }
+
+ @Override
+ public AbstractTypeValidator getValidator(String key) {
+ return (AbstractTypeValidator) validator.getOrDefault(key, globalValidator.get(key));
+ }
+
+ @Override
+ public void addValidator(String key, boolean local, AbstractTypeValidator validator) {
+ if (local) {
+ this.validator.put(key, validator);
+ } else {
+ this.globalValidator.putIfAbsent(key, validator);
+ }
+ }
+
+ @Override
+ public boolean hasSupplier(String key) {
+ return supplier.containsKey(key) || globalSupplier.containsKey(key);
+ }
+
+ @Override
+ public AbstractTypeSupplier getSupplier(String key) {
+ return (AbstractTypeSupplier) supplier.getOrDefault(key, globalSupplier.get(key));
+ }
+
+ @Override
+ public void addSupplier(String key, boolean local, AbstractTypeSupplier supplier) {
+ if (local) {
+ this.supplier.put(key, supplier);
+ } else {
+ this.globalSupplier.putIfAbsent(key, supplier);
+ }
+ }
+
+ /**
+ * Invoking the same method twice will result in the exact same result.
+ */
+ @Override
+ public T invoke(Method method) {
+ return (T) cache.computeIfAbsent(method, m -> {
+ try {
+ return m.invoke(self);
+ } catch (IllegalAccessException | InvocationTargetException e) {
+ return null;
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ });
+ }
+
+ @Override
+ public void addCommand(Method method, String[] subCommand, String[] description, boolean noTabComplete) {
+ Node temp = node;
+ container.descriptions.addAll(Arrays.asList(description));
+ if (noTabComplete) {
+ temp = temp.addChild(null, new NoTabCompleteNode<>());
+ }
+ for (int i = 0; i < subCommand.length; i++) {
+ temp = temp.addChild(null, new LiteralNode<>(subCommand[i]));
+ }
+ Parameter[] parameters = method.getParameters();
+ for (int i = 0; i < parameters.length; i++) {
+ Parameter parameter = parameters[i];
+ if (i == 0) {
+ temp = temp.addChild(parameter, new ExecutorTypeNode<>(parameter, i, this));
+ continue;
+ }
+ if (parameter.isAnnotationPresent(Supplier.class)) {
+ temp = temp.addChild(parameter, new SupplierNode<>(parameter, this));
+ continue;
+ }
+ Class type = parameter.getType();
+ boolean isArray = parameter.isVarArgs() || type.isArray();
+ if (!isArray) {
+ temp = temp.addChild(parameter, new TypeNode<>(parameter, i, this));
+ continue;
+ }
+ boolean greedy = parameter.isVarArgs() || GreedyHandler.isGreedy(parameter);
+ if (greedy) {
+ temp = temp.addChild(parameter, new GreedyArrayNode<>(parameter, i, this));
+ } else {
+ temp = temp.addChild(parameter, new NonGreedyArrayNode<>(parameter, i, this));
+ }
+ }
+ temp.addChild(null, new ExecuteNode<>(self, method));
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/Handler.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/Handler.java
new file mode 100644
index 00000000..667c0375
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/Handler.java
@@ -0,0 +1,121 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 > getGenericTypeOfReturn(Method method) {
+ Type type;
+ try {
+ type = method.getGenericReturnType();
+ } catch (Exception e) {
+ return Optional.empty();
+ }
+ if (!(type instanceof ParameterizedType)) {
+ return Optional.empty();
+ }
+ ParameterizedType parameterizedType = (ParameterizedType) type;
+ Type[] generics = parameterizedType.getActualTypeArguments();
+ if (generics.length != 1 && generics.length != 2) {
+ return Optional.empty();
+ }
+ Type genericType = generics[generics.length - 1];
+ try {
+ return Optional.of(Class.forName(genericType.getTypeName()));
+ } catch (Exception e) {
+ return Optional.empty();
+ }
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ @Target(ElementType.ANNOTATION_TYPE)
+ @interface Implementation {
+ Class value();
+ }
+
+ interface DataCheckable {
+ boolean hasExecutorMapper(Class clazz);
+ boolean hasMapper(String key);
+ boolean hasValidator(String key);
+ boolean hasSupplier(String key);
+ }
+
+ interface DataReadable {
+ Function getExecutorMapper(Class clazz);
+ AbstractTypeMapper getMapper(String key);
+ AbstractTypeValidator getValidator(String key);
+ AbstractTypeSupplier getSupplier(String key);
+ }
+
+ interface DataWritable {
+ Function getExecutorMapper(Class clazz);
+
+ void addMapper(String key, boolean local, AbstractTypeMapper mapper);
+ void addValidator(String key, boolean local, AbstractTypeValidator validator);
+ void addSupplier(String key, boolean local, AbstractTypeSupplier supplier);
+ /**
+ * Invoking the same method twice will result in the exact same result.
+ */
+ T invoke(Method method);
+ void addCommand(Method method, String[] subCommand, String[] description, boolean noTabComplete);
+ }
+
+ interface HandlerMethod extends Handler {
+ void check(T annotation, Method method, DataCheckable dataCheckable) throws Exception;
+
+ int getRunPriority();
+
+ void run(T annotation, Method method, DataWritable dataWritable);
+ }
+
+ interface HandlerParameter extends Handler {
+ void check(T annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception;
+
+ default boolean needsParentTypeMapper() {
+ return false;
+ }
+
+ /**
+ * Null values are allowed to be returned.
+ */
+ default AbstractTypeMapper getTypeMapper(T annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper parentTypeMapper) {
+ return null;
+ }
+
+ default int getValidatorPriority() {
+ return 0;
+ }
+
+ /**
+ * Null values are allowed to be returned.
+ */
+ default AbstractTypeValidator getValidator(T annotation, Parameter parameter, int index, DataReadable dataReadable) {
+ return null;
+ }
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/OptionEnum.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/OptionEnum.java
new file mode 100644
index 00000000..69c6b1b8
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/OptionEnum.java
@@ -0,0 +1,30 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 & OptionEnum> {
+ default List getTabCompletes() {
+ return Arrays.asList("-" + ((T) this).name().toLowerCase());
+ }
+ T[] getRemoved();
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/PreviousArguments.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/PreviousArguments.java
new file mode 100644
index 00000000..6458c6c1
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/PreviousArguments.java
@@ -0,0 +1,96 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2022 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 getByNameFunction;
+ private boolean usedOptionalValue = false;
+
+ public PreviousArguments(String[] userArgs, Object[] mappedArgs, boolean hasMoreArguments, Function getByNameFunction) {
+ this.userArgs = userArgs;
+ this.mappedArgs = mappedArgs;
+ this.hasMoreArguments = hasMoreArguments;
+ this.getByNameFunction = getByNameFunction;
+ }
+
+ public boolean hasUsedOptionalValue() {
+ return usedOptionalValue;
+ }
+
+ public void usedOptionalValue() {
+ this.usedOptionalValue = true;
+ }
+
+ public String getUserArg(int index) {
+ return userArgs[userArgs.length - index - 1];
+ }
+
+ public T getMappedArg(int index) {
+ return (T) mappedArgs[mappedArgs.length - index - 1];
+ }
+
+ public Optional getFirst(Class clazz) {
+ for (Object o : mappedArgs) {
+ if (clazz.isInstance(o)) {
+ return Optional.of((T) o);
+ }
+ }
+ return Optional.empty();
+ }
+
+ public List getAll(Class clazz) {
+ List list = new ArrayList<>();
+ for (Object o : mappedArgs) {
+ if (clazz.isInstance(o)) {
+ list.add((T) o);
+ }
+ if (o == null) {
+ continue;
+ }
+ if (o.getClass().isArray()) {
+ Object[] array = (Object[]) o;
+ if (array.length == 0) {
+ continue;
+ }
+ for (Object o1 : array) {
+ if (clazz.isInstance(o1)) {
+ list.add((T) o1);
+ }
+ }
+ }
+ }
+ return list;
+ }
+
+ public T getByName(@NonNull String name) {
+ return (T) getByNameFunction.apply(name);
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/TabCompletionCache.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/TabCompletionCache.java
new file mode 100644
index 00000000..231b5116
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/TabCompletionCache.java
@@ -0,0 +1,109 @@
+/*
+ * 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 tabCompletionCache = new ConcurrentHashMap<>();
+
+ Set> cached = new HashSet<>();
+ Set> global = new HashSet<>();
+ Map, Long> cacheDuration = new HashMap<>();
+
+ static {
+ Thread thread = new Thread(() -> {
+ while (true) {
+ Set toRemove = new HashSet<>();
+ for (Map.Entry tabCompletionsEntry : tabCompletionCache.entrySet()) {
+ if (System.currentTimeMillis() - tabCompletionsEntry.getValue().timestamp > cacheDuration.get(tabCompletionsEntry.getKey().typeMapper)) {
+ toRemove.add(tabCompletionsEntry.getKey());
+ }
+ }
+ for (Key key : toRemove) {
+ tabCompletionCache.remove(key);
+ }
+
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ });
+ thread.setName("TabCompletionCache Invalidator");
+ thread.setDaemon(true);
+ thread.start();
+ }
+
+ public void add(AbstractTypeMapper typeMapper, boolean global, long cacheDuration, TimeUnit timeUnit) {
+ TabCompletionCache.cached.add(typeMapper);
+ if (global) TabCompletionCache.global.add(typeMapper);
+ TabCompletionCache.cacheDuration.put(typeMapper, timeUnit.toMillis(cacheDuration));
+ }
+
+ public AbstractTypeMapper cached(AbstractTypeMapper dataMapper, AbstractTypeMapper toBeCached) {
+ if (!cached.contains(dataMapper)) return toBeCached;
+ boolean global = TabCompletionCache.global.contains(dataMapper);
+ long cacheDuration = TabCompletionCache.cacheDuration.get(dataMapper);
+
+ return new DelegatingMapper<>(toBeCached, null) {
+ @Override
+ public Collection tabComplete(A sender, PreviousArguments previousArguments, String s) {
+ String normalizedArg = dataMapper.normalize(global ? null : sender, s);
+ if (normalizedArg == null) normalizedArg = "";
+ Key key = new Key(global ? null : sender, normalizedArg, dataMapper);
+
+ TabCompletions tabCompletions = tabCompletionCache.computeIfAbsent(key, ignore -> {
+ return new TabCompletions(System.currentTimeMillis(), toBeCached.tabComplete(sender, previousArguments, s));
+ });
+
+ if (System.currentTimeMillis() - tabCompletions.timestamp > cacheDuration) {
+ tabCompletions.tabCompletions = toBeCached.tabComplete(sender, previousArguments, s);
+ }
+ tabCompletions.timestamp = System.currentTimeMillis();
+ return tabCompletions.tabCompletions;
+ }
+ };
+ }
+
+ @EqualsAndHashCode
+ @AllArgsConstructor
+ private static class Key {
+ private Object sender;
+ private String arg;
+ private AbstractTypeMapper typeMapper;
+ }
+
+ @AllArgsConstructor
+ private static class TabCompletions {
+ private long timestamp;
+ private Collection tabCompletions;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/AllowNull.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/AllowNull.java
new file mode 100644
index 00000000..944b96e8
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/AllowNull.java
@@ -0,0 +1,37 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends AbstractTypeNode {
+
+ protected final boolean unique;
+ protected final int minArrayLength;
+ protected final int maxArrayLength;
+ protected final String error;
+
+ protected AbstractArrayNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter, index, dataReadable);
+
+ this.unique = UniqueHandler.isPresent(parameter);
+ this.minArrayLength = ArrayLengthHandler.getMin(parameter);
+ this.maxArrayLength = ArrayLengthHandler.getMax(parameter);
+ this.error = ArrayLengthHandler.getError(parameter);
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ Object array = Array.newInstance(type, Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength));
+
+ int i = 0;
+ while (!nodeData.hasOneLeft()) {
+ if (i >= minArrayLength) {
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ }
+
+ nodeData.add(name, arrayCopy(array, i));
+ Triple argument = argument(executor, nodeData);
+ nodeData.remove();
+
+ if (!argument.b) {
+ for (; i > 0; i--) nodeData.unconsume();
+ return;
+ }
+ nodeData.consume();
+ Array.set(array, i, argument.a);
+ i++;
+ }
+ nodeData.add(name, arrayCopy(array, i));
+ if (i < maxArrayLength) {
+ PreviousArguments previousArguments = nodeData.toPreviousArguments();
+ if (unique) {
+ Map> mapped = new HashMap<>();
+ for (String s : typeMapper.tabComplete(executor, previousArguments, nodeData.current())) {
+ mapped.computeIfAbsent(typeMapper.map(executor, previousArguments, s), object -> new ArrayList<>())
+ .add(s);
+ }
+ for (int j = 0; j < i; j++) {
+ mapped.remove(Array.get(array, j));
+ }
+ mapped.forEach((object, strings) -> {
+ completions.add(strings);
+ });
+ } else {
+ completions.add(typeMapper.tabComplete(executor, previousArguments, nodeData.current()));
+ }
+ }
+ if (i >= minArrayLength) {
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ }
+ nodeData.remove();
+ for (; i > 0; i--) nodeData.unconsume();
+ }
+
+ protected Object arrayCopy(Object array, int newLength) {
+ Object newArray = Array.newInstance(type, newLength);
+ System.arraycopy(array, 0, newArray, 0, Math.min(Array.getLength(array), newLength));
+ return newArray;
+ }
+
+ @Override
+ public int nodeCost() {
+ return minArrayLength * 2 + super.nodeCost();
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractTypeNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractTypeNode.java
new file mode 100644
index 00000000..d9f527ab
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractTypeNode.java
@@ -0,0 +1,145 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends AbstractValidationNode {
+
+ protected Class type;
+ protected AbstractTypeMapper typeMapper;
+
+ protected AbstractTypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter, index, dataReadable);
+
+ type = parameter.getType();
+ if (type.isArray()) type = type.getComponentType();
+
+ initializeTypeMapper(handlerParameters, parameter, index, dataReadable);
+ }
+
+ private AbstractTypeMapper getTypeMapper(Handler.DataReadable dataReadable) {
+ AbstractTypeMapper typeMapper = dataReadable.getMapper(type.getTypeName());
+ if (typeMapper == null && type.isEnum()) {
+ if (OptionEnum.class.isAssignableFrom(type)) {
+ typeMapper = (AbstractTypeMapper) new OptionEnumMapper((Class) type);
+ } else {
+ typeMapper = (AbstractTypeMapper) new EnumMapper((Class) type);
+ }
+ }
+ return typeMapper;
+ }
+
+ private void initializeTypeMapper(List> pairs, Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ AbstractTypeMapper typeMapper = getTypeMapper(dataReadable);
+ boolean isStillDefault = true;
+ for (Pair pair : pairs) {
+ if (pair.b.needsParentTypeMapper()) {
+ continue;
+ }
+ if (!isStillDefault) {
+ throw new UnsupportedOperationException("Only one HandlerParameter can be used without a parent TypeMapper");
+ }
+ AbstractTypeMapper temp = pair.b.getTypeMapper(pair.a, parameter, index, dataReadable, null);
+ if (temp != null) {
+ typeMapper = temp;
+ isStillDefault = false;
+ }
+ }
+
+ AbstractTypeMapper current = typeMapper;
+ for (Pair pair : pairs) {
+ if (!pair.b.needsParentTypeMapper()) {
+ continue;
+ }
+ AbstractTypeMapper temp = pair.b.getTypeMapper(pair.a, parameter, index, dataReadable, typeMapper);
+ if (temp != null) {
+ typeMapper = temp;
+ }
+ }
+
+ current = TabCompletionCache.cached(current, typeMapper);
+
+ TabFilterType tabFilterType = TabFilterHandler.getTabFilterType(parameter);
+ switch (tabFilterType) {
+ case NONE:
+ this.typeMapper = current;
+ break;
+ case STARTS_WITH:
+ this.typeMapper = new StartsWithFilter<>(current);
+ break;
+ case CONTAINS:
+ this.typeMapper = new ContainsFilter<>(current);
+ break;
+ }
+ }
+
+ protected Triple argument(E executor, NodeData nodeData) {
+ Object value;
+ boolean usedOptional;
+ try {
+ PreviousArguments previousArguments = nodeData.toPreviousArguments();
+ value = typeMapper.map(executor, previousArguments, nodeData.current());
+ usedOptional = previousArguments.hasUsedOptionalValue();
+ } catch (Exception e) {
+ return new Triple<>(null, false, false);
+ }
+ if (validate(executor, value, nodeData)) {
+ return new Triple<>(value, true, usedOptional);
+ } else {
+ return new Triple<>(null, false, false);
+ }
+ }
+
+ protected boolean validate(E executor, Object value, NodeData nodeData) {
+ for (AbstractTypeValidator validator : validators) {
+ try {
+ if (!validator.validate(executor, value, nodeData)) {
+ return false;
+ }
+ } catch (ClassCastException e) {
+ // Ignore
+ } catch (Throwable e) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ if (!(children instanceof AbstractTypeNode)) {
+ return false;
+ }
+ return super.equals(parameter, children);
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractValidationNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractValidationNode.java
new file mode 100644
index 00000000..265e3aa9
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractValidationNode.java
@@ -0,0 +1,109 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends Node {
+
+ private static final AbstractTypeValidator NON_NULL_VALIDATOR = (AbstractTypeValidator) (sender, value, messageSender) -> value != null;
+
+ protected final List annotations;
+ protected final List> handlerParameters;
+ protected final List> validators = new ArrayList<>();
+
+ protected AbstractValidationNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter);
+ annotations = CommandUtils.getAnnotations(parameter, Handler.HandlerParameter.class);
+ List> pairs = new ArrayList<>();
+ for (Annotation annotation : annotations) {
+ Handler.Implementation implementation = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+ try {
+ pairs.add(new Pair<>(annotation, (Handler.HandlerParameter) implementation.value().getConstructor().newInstance()));
+ } catch (Exception e) {
+ throw new SecurityException(e);
+ }
+ }
+ handlerParameters = pairs;
+
+ initializeValidators(handlerParameters, parameter, index, dataReadable);
+ }
+
+ private void initializeValidators(List> pairs, Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ pairs.sort(Comparator.comparingInt(p -> p.b.getValidatorPriority()));
+ for (Pair pair : pairs) {
+ AbstractTypeValidator validator = pair.b.getValidator(pair.a, parameter, index, dataReadable);
+ if (validator != null) {
+ validators.add(validator);
+ }
+ }
+
+ if (!AllowNullHandler.isPresent(parameter)) {
+ validators.add((AbstractTypeValidator) NON_NULL_VALIDATOR);
+ }
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ if (this.parameter.getType() != parameter.getType()) {
+ return false;
+ }
+
+ Annotation[] annotations = this.parameter.getAnnotations();
+ Annotation[] currentAnnotations = parameter.getAnnotations();
+
+ if (annotations.length == 0 && currentAnnotations.length == 0) {
+ return true;
+ }
+
+ if (annotations.length != currentAnnotations.length) {
+ return false;
+ }
+
+ Map, Annotation> annotationMap = new HashMap<>();
+ boolean duplicate = false;
+ for (Annotation annotation : annotations) {
+ if (annotationMap.put(annotation.annotationType(), annotation) != null) {
+ duplicate = true;
+ break;
+ }
+ }
+ if (duplicate) {
+ return false;
+ }
+
+ for (Annotation annotation : currentAnnotations) {
+ Annotation other = annotationMap.get(annotation.annotationType());
+ if (!annotation.equals(other)) {
+ continue;
+ }
+ annotationMap.remove(annotation.annotationType());
+ }
+ return annotationMap.isEmpty();
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecuteNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecuteNode.java
new file mode 100644
index 00000000..791c3a4f
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecuteNode.java
@@ -0,0 +1,89 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends Node {
+
+ private final Object self;
+ private final Method method;
+
+ public ExecuteNode(Object self, Method method) {
+ super(null);
+ this.self = self;
+ this.method = method;
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) {
+ return true;
+ }
+ }
+
+ if (nodeData.hasMore()) {
+ return false;
+ }
+
+ try {
+ method.invoke(self, nodeData.mapped());
+ return true;
+ } catch (InvocationTargetException e) {
+ throw new CommandFrameworkException(e, nodeData.alias(), nodeData.args());
+ } catch (IllegalAccessException | RuntimeException e) {
+ return false;
+ }
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ if (children instanceof ExecuteNode) {
+ String parameters = Arrays.stream(method.getParameters()).map(par -> {
+ String annotations = Arrays.stream(par.getAnnotations())
+ .map(annotation -> "@" + annotation.getClass().getSimpleName())
+ .collect(Collectors.joining(" "));
+ if (par.isVarArgs()) {
+ return annotations + (annotations.isEmpty() ? "" : " ") + par.getType().componentType().getSimpleName() + "...";
+ } else {
+ return annotations + (annotations.isEmpty() ? "" : " ") + par.getType().getSimpleName();
+ }
+ }).collect(Collectors.joining(", "));
+ throw new UnsupportedOperationException("Command with parameters " + parameters + " is already defined in " + self.getClass().getName());
+ }
+ return children instanceof ExecuteNode;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecutorTypeNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecutorTypeNode.java
new file mode 100644
index 00000000..7bc189c1
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecutorTypeNode.java
@@ -0,0 +1,95 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends AbstractValidationNode {
+
+ protected final Function executorMapper;
+
+ public ExecutorTypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter, index, dataReadable);
+ this.executorMapper = (Function) dataReadable.getExecutorMapper(parameter.getType());
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ Object mappedExecutor = executorMapper.apply(executor);
+ if (mappedExecutor == null) return false;
+ for (AbstractTypeValidator validator : validators) {
+ try {
+ if (!validator.validate(executor, executor, nodeData)) {
+ return false;
+ }
+ } catch (ClassCastException e) {
+ // Ignore
+ } catch (Throwable e) {
+ return false;
+ }
+ }
+ nodeData.add(name, mappedExecutor);
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+ nodeData.remove();
+ return false;
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ Object mappedExecutor = executorMapper.apply(executor);
+ if (mappedExecutor == null) return;
+ for (AbstractTypeValidator validator : validators) {
+ try {
+ if (!validator.validate(executor, executor, nodeData)) {
+ return;
+ }
+ } catch (ClassCastException e) {
+ // Ignore
+ } catch (Throwable e) {
+ return;
+ }
+ }
+ nodeData.add(name, mappedExecutor);
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ nodeData.remove();
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ if (!(children instanceof ExecutorTypeNode)) {
+ return false;
+ }
+ ExecutorTypeNode other = (ExecutorTypeNode) children;
+ if (executorMapper != other.executorMapper) {
+ return false;
+ }
+ return super.equals(parameter, children);
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/GreedyArrayNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/GreedyArrayNode.java
new file mode 100644
index 00000000..2c02d480
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/GreedyArrayNode.java
@@ -0,0 +1,98 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends AbstractArrayNode {
+
+ protected final int backTrackingDepth;
+
+ public GreedyArrayNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter, index, dataReadable);
+ this.backTrackingDepth = GreedyHandler.getBackTrackingDepth(parameter);
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ int min = Math.min(nodeData.unparsedArgumentsSize(), minArrayLength);
+ int max = Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength);
+ if (max < minArrayLength) {
+ nodeData.send(error, 0, minArrayLength);
+ return false;
+ }
+
+ Object array = Array.newInstance(type, max);
+ Set seen = new HashSet<>();
+
+ int i = 0;
+ for (; i < max; i++) {
+ nodeData.add(name, arrayCopy(array, i));
+ Triple argument = argument(executor, nodeData);
+ nodeData.remove();
+
+ if (!argument.b || (unique && !seen.add(argument.a))) {
+ if (i < minArrayLength) {
+ nodeData.send(error, i, minArrayLength);
+ for (; i > 0; i--) nodeData.unconsume();
+ return false;
+ }
+ break;
+ }
+ Array.set(array, i, argument.a);
+ nodeData.consume();
+ }
+
+ int backTrackingDepth = i - this.backTrackingDepth;
+ for (; i >= min; i--) {
+ Object copiedArray = arrayCopy(array, i);
+ nodeData.add(name, copiedArray);
+ if (validate(executor, copiedArray, nodeData)) {
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) {
+ return true;
+ }
+ }
+ }
+ nodeData.remove();
+ if (i <= backTrackingDepth) {
+ break;
+ }
+ if (i > 0) {
+ nodeData.unconsume();
+ }
+ }
+ if (i < minArrayLength) nodeData.send(error, i, minArrayLength);
+ for (; i > 0; i--) nodeData.unconsume();
+ return false;
+ }
+
+ @Override
+ public int nodeCost() {
+ return -1;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/LiteralNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/LiteralNode.java
new file mode 100644
index 00000000..b00d176d
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/LiteralNode.java
@@ -0,0 +1,75 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends Node {
+
+ protected final String literal;
+
+ public LiteralNode(String literal) {
+ super(null);
+ this.literal = literal;
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ if (!nodeData.hasMore()) return false;
+ if (nodeData.current().equalsIgnoreCase(literal)) {
+ nodeData.consume();
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) {
+ return true;
+ }
+ }
+ nodeData.unconsume();
+ }
+ return false;
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ if (nodeData.hasOneLeft()) {
+ if (literal.startsWith(nodeData.current())) {
+ completions.add(List.of(literal));
+ }
+ return;
+ }
+
+ if (nodeData.current().equalsIgnoreCase(literal)) {
+ nodeData.consume();
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ nodeData.unconsume();
+ }
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ if (!(children instanceof LiteralNode)) {
+ return false;
+ }
+ return literal.equalsIgnoreCase(((LiteralNode) children).literal);
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NoTabCompleteNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NoTabCompleteNode.java
new file mode 100644
index 00000000..d59760c7
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NoTabCompleteNode.java
@@ -0,0 +1,49 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends Node {
+
+ public NoTabCompleteNode() {
+ super(null);
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+ return false;
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ // Do nothing
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ return children instanceof NoTabCompleteNode;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/Node.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/Node.java
new file mode 100644
index 00000000..7080d9f4
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/Node.java
@@ -0,0 +1,83 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 {
+
+ protected final Parameter parameter;
+ protected final String name;
+ protected final List> children = new ArrayList<>();
+
+ protected Node(Parameter parameter) {
+ this.parameter = parameter;
+ if (parameter == null) {
+ this.name = null;
+ return;
+ }
+
+ Name name = parameter.getAnnotation(Name.class);
+ if (name == null) {
+ this.name = parameter.getName();
+ } else {
+ this.name = name.value();
+ }
+ }
+
+ public abstract boolean execute(E executor, NodeData nodeData);
+ public abstract void tabComplete(E executor, NodeData nodeData, List> completions);
+
+ public final Node addChild(Parameter parameter, Node child) {
+ for (Node currentChild : children) {
+ if (currentChild.equals(parameter, child)) {
+ return currentChild;
+ }
+ }
+ children.add(child);
+ return child;
+ }
+
+ public abstract boolean equals(Parameter parameter, Node children);
+
+ public int nodeCost() {
+ return 2;
+ }
+
+ public final int sort() {
+ AtomicInteger max = new AtomicInteger(0);
+ if (children.size() == 1) {
+ return children.get(0).sort() + nodeCost();
+ }
+ children.sort(Comparator.comparingInt(value -> {
+ int sort = value.sort();
+ if (sort > max.get()) max.set(sort);
+ return -sort;
+ }));
+ return max.get() + nodeCost();
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NodeData.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NodeData.java
new file mode 100644
index 00000000..7966b25a
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NodeData.java
@@ -0,0 +1,120 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 parsedArguments = new LinkedList<>();
+ private final LinkedList unparsedArguments;
+ private final LinkedList mapped = new LinkedList<>();
+ private final LinkedList names = new LinkedList<>();
+ private final AbstractTypeValidator.MessageSender messageSender;
+
+ public NodeData(String alias, String[] args, AbstractTypeValidator.MessageSender messageSender) {
+ this.alias = alias;
+ this.unparsedArguments = new LinkedList<>(Arrays.asList(args));
+ this.messageSender = messageSender;
+ }
+
+ public String[] args() {
+ return parsedArguments.toArray(String[]::new);
+ }
+
+ public String alias() {
+ return alias;
+ }
+
+ public String current() {
+ if (unparsedArguments.isEmpty()) return null;
+ return unparsedArguments.getFirst();
+ }
+
+ public boolean hasMore() {
+ return !unparsedArguments.isEmpty();
+ }
+
+ public boolean hasOneLeft() {
+ return unparsedArguments.size() == 1;
+ }
+
+ void consume() {
+ parsedArguments.addLast(unparsedArguments.removeFirst());
+ }
+
+ void unconsume() {
+ unparsedArguments.addFirst(parsedArguments.removeLast());
+ }
+
+ void add(String name, Object mapped) {
+ this.names.addLast(name);
+ this.mapped.addLast(mapped);
+ }
+
+ void remove() {
+ this.names.removeLast();
+ this.mapped.removeLast();
+ }
+
+ public Object getByName(@NonNull String name) {
+ for (int i = mapped.size() - 1; i >= 0; i--) {
+ if (name.equals(names.get(i))) {
+ return mapped.get(i);
+ }
+ }
+ return null;
+ }
+
+ public Object[] mapped() {
+ return mapped.toArray();
+ }
+
+ public int unparsedArgumentsSize() {
+ return unparsedArguments.size();
+ }
+
+ @Override
+ public void send(String s, Object... args) {
+ if (s == null || s.isEmpty()) return;
+ messageSender.send(s, args);
+ }
+
+ PreviousArguments toPreviousArguments() {
+ return new PreviousArguments(args(), mapped(), hasMore(), this::getByName);
+ }
+
+ @Override
+ public String toString() {
+ return "NodeData{" +
+ "alias='" + alias + '\'' +
+ ", parsedArguments=" + parsedArguments + " (" + parsedArguments.size() + ")" +
+ ", unparsedArguments=" + unparsedArguments + " (" + unparsedArguments.size() + ")" +
+ ", mapped=" + mapped + " (" + mapped.size() + ")" +
+ ", names=" + names + " (" + names.size() + ")" +
+ '}';
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NonGreedyArrayNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NonGreedyArrayNode.java
new file mode 100644
index 00000000..e2bafc1c
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NonGreedyArrayNode.java
@@ -0,0 +1,83 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends AbstractArrayNode {
+
+ public NonGreedyArrayNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter, index, dataReadable);
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ int min = Math.max(nodeData.unparsedArgumentsSize(), minArrayLength);
+ int max = Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength);
+ if (max < minArrayLength) {
+ nodeData.send(error, 0, minArrayLength);
+ return false;
+ }
+ Object array = Array.newInstance(type, max);
+ Set seen = new HashSet<>();
+
+ int i = 0;
+ do {
+ Object copiedArray = arrayCopy(array, i);
+ nodeData.add(name, copiedArray);
+ if (i >= min && validate(executor, copiedArray, nodeData)) {
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+ }
+
+ Triple argument = argument(executor, nodeData);
+ nodeData.remove();
+ if (!argument.b || (unique && !seen.add(argument.a))) {
+ if (i < minArrayLength) nodeData.send(error, i, minArrayLength);
+ for (; i > 0; i--) nodeData.unconsume();
+ return false;
+ }
+ nodeData.consume();
+ Array.set(array, i, argument.a);
+ i++;
+ } while (i < max);
+
+ if (i >= min) {
+ Object copiedArray = arrayCopy(array, i);
+ nodeData.add(name, copiedArray);
+ if (validate(executor, copiedArray, nodeData)) {
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+ }
+ nodeData.remove();
+ }
+ if (i < minArrayLength) nodeData.send(error, i, minArrayLength);
+ for (; i > 0; i--) nodeData.unconsume();
+ return false;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/RootNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/RootNode.java
new file mode 100644
index 00000000..7030fbb2
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/RootNode.java
@@ -0,0 +1,51 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends Node {
+
+ public RootNode() {
+ super(null);
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+ return false;
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ return children instanceof RootNode;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/SupplierNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/SupplierNode.java
new file mode 100644
index 00000000..e1da7416
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/SupplierNode.java
@@ -0,0 +1,100 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends Node {
+
+ protected final AbstractTypeSupplier typeSupplier;
+ protected final boolean allowNull;
+
+ public SupplierNode(Parameter parameter, Handler.DataReadable dataReadable) {
+ super(parameter);
+
+ Supplier annotation = parameter.getAnnotation(Supplier.class);
+ String s = annotation.value() != null && !annotation.value().isEmpty() ? annotation.value() : parameter.getType().getTypeName();
+ typeSupplier = dataReadable.getSupplier(s);
+
+ allowNull = AllowNullHandler.isPresent(parameter);
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ PreviousArguments previousArguments = nodeData.toPreviousArguments();
+ Object value;
+ try {
+ value = typeSupplier.get(executor, previousArguments);
+ } catch (Exception e) {
+ return false;
+ }
+
+ if (!allowNull && value == null) {
+ return false;
+ }
+ nodeData.add(name, value);
+
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+
+ nodeData.remove();
+ return false;
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ PreviousArguments previousArguments = nodeData.toPreviousArguments();
+ Object value;
+ try {
+ value = typeSupplier.get(executor, previousArguments);
+ } catch (Exception e) {
+ return;
+ }
+
+ if (!allowNull && value == null) {
+ return;
+ }
+ nodeData.add(name, value);
+
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+
+ nodeData.remove();
+ }
+
+ @Override
+ public boolean equals(Parameter parameter, Node children) {
+ if (children instanceof SupplierNode) {
+ SupplierNode supplierNode = (SupplierNode) children;
+ return allowNull == supplierNode.allowNull && typeSupplier == supplierNode.typeSupplier;
+ }
+ return false;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/TypeNode.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/TypeNode.java
new file mode 100644
index 00000000..0c9fefbb
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/TypeNode.java
@@ -0,0 +1,84 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 extends AbstractTypeNode {
+
+ public TypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+ super(parameter, index, dataReadable);
+ }
+
+ @Override
+ public boolean execute(E executor, NodeData nodeData) {
+ Triple argument = argument(executor, nodeData);
+ if (!argument.b) return false;
+ nodeData.add(name, argument.a);
+ if (!argument.c) nodeData.consume();
+
+ for (Node child : children) {
+ if (child.execute(executor, nodeData)) return true;
+ }
+
+ nodeData.remove();
+ if (!argument.c) nodeData.unconsume();
+ return false;
+ }
+
+ @Override
+ public void tabComplete(E executor, NodeData nodeData, List> completions) {
+ if (nodeData.hasOneLeft()) {
+ PreviousArguments previousArguments = nodeData.toPreviousArguments();
+ Collection tabCompletions = typeMapper.tabComplete(executor, previousArguments, nodeData.current());
+ completions.add(tabCompletions);
+
+ if (typeMapper.appendNextElementTabCompletions()) {
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+ }
+ return;
+ }
+
+ Triple argument = argument(executor, nodeData);
+ if (!argument.b) return;
+ nodeData.add(name, argument.a);
+ if (!argument.c) nodeData.consume();
+
+ for (Node child : children) {
+ child.tabComplete(executor, nodeData, completions);
+ }
+
+ nodeData.remove();
+ if (!argument.c) nodeData.unconsume();
+ }
+
+ @Override
+ public int nodeCost() {
+ return type == String.class ? 1 : 2;
+ }
+}
diff --git a/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/AllowNullHandler.java b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/AllowNullHandler.java
new file mode 100644
index 00000000..dd170378
--- /dev/null
+++ b/CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/AllowNullHandler.java
@@ -0,0 +1,48 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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