With EndsWithHandler

Improve HandlerForVariableElement.getAnnotations()
Improve HandlerForTypeMirror.isEnum
Add HandlerForTypeMirror.getTypeName

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 <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+dependencies {
+    testImplementation(libs.junit)
+    testImplementation(libs.hamcrest)
+}

CommandFramework/CommandFrameworkAnnotationProcessor/build.gradle.kts

@@ -0,0 +1,32 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+dependencies {
+    implementation(project(":CommandFramework:CommandFrameworkBase", "default"))
+    annotationProcessor(project(":CommandFramework:CommandFrameworkBase", "default"))
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/META-INF/services/javax.annotation.processing.Processor

@@ -0,0 +1,5 @@
+de.steamwar.command.annotationprocessor.impl.CachedAnnotationProcessor
+de.steamwar.command.annotationprocessor.impl.MapperAnnotationProcessor
+de.steamwar.command.annotationprocessor.impl.RegisterAnnotationProcessor
+de.steamwar.command.annotationprocessor.impl.SupplierAnnotationProcessor
+de.steamwar.command.annotationprocessor.impl.ValidatorAnnotationProcessor

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/HandlerForAnnotationMirror.java

@@ -0,0 +1,43 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import lombok.Getter;
+
+import javax.lang.model.element.AnnotationMirror;
+import java.lang.annotation.Annotation;
+
+public class HandlerForAnnotationMirror<A extends Annotation> implements Handler.AnnotationWrapper<A> {
+
+    private A annotation;
+
+    @Getter
+    private AnnotationMirror annotationMirror;
+
+    public HandlerForAnnotationMirror(A annotation, AnnotationMirror annotationMirror) {
+        this.annotation = annotation;
+        this.annotationMirror = annotationMirror;
+    }
+
+    @Override
+    public A getAnnotation() {
+        return annotation;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/HandlerForExecutableElement.java

@@ -0,0 +1,68 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import lombok.Getter;
+
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import java.util.List;
+
+public class HandlerForExecutableElement implements Handler.MethodWrapper {
+
+    @Getter
+    private final ExecutableElement method;
+    private final Types types;
+    private final Elements elements;
+
+    public HandlerForExecutableElement(ExecutableElement method, Types types, Elements elements) {
+        this.method = method;
+        this.types = types;
+        this.elements = elements;
+    }
+
+    @Override
+    public String getName() {
+        return method.getSimpleName().toString();
+    }
+
+    @Override
+    public int getParameterCount() {
+        return method.getParameters().size();
+    }
+
+    @Override
+    public Handler.TypeWrapper getReturnType() {
+        return new HandlerForTypeMirror(method.getReturnType(), types, elements);
+    }
+
+    @Override
+    public Handler.ParameterWrapper[] getParameters() {
+        Handler.ParameterWrapper[] parameters = new Handler.ParameterWrapper[method.getParameters().size()];
+        List<? extends VariableElement> variableElements = method.getParameters();
+        for (int i = 0; i < parameters.length; i++) {
+            VariableElement variableElement = variableElements.get(i);
+            parameters[i] = new HandlerForVariableElement(variableElement, types, elements, i == parameters.length - 1 && method.isVarArgs());
+        }
+        return parameters;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/HandlerForTypeMirror.java

@@ -0,0 +1,121 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+
+public class HandlerForTypeMirror implements Handler.TypeWrapper {
+
+    private final TypeMirror type;
+    private final Types types;
+    private final Elements elements;
+
+    public HandlerForTypeMirror(TypeMirror type, Types types, Elements elements) {
+        this.type = type;
+        this.types = types;
+        this.elements = elements;
+    }
+
+    @Override
+    public boolean isAssignableTo(Class<?> clazz) {
+        return types.isAssignable(types.erasure(type), types.erasure(elements.getTypeElement(clazz.getTypeName()).asType()));
+    }
+
+    @Override
+    public boolean isAssignableTo(Handler.TypeWrapper type) {
+        if (type instanceof ForClass) {
+            return isAssignableTo(((ForClass) type).getClazz());
+        } else if (type instanceof HandlerForTypeMirror) {
+            return types.isAssignable(types.erasure(this.type), types.erasure(((HandlerForTypeMirror) type).type));
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isPrimitive() {
+        return type.getKind().isPrimitive();
+    }
+
+    @Override
+    public boolean isArray() {
+        return type instanceof ArrayType;
+    }
+
+    @Override
+    public boolean isEnum() {
+        if (type.getKind() != TypeKind.DECLARED) {
+            return false;
+        }
+
+        DeclaredType declaredType = (DeclaredType) type;
+        Element element = declaredType.asElement();
+
+        return element.getKind() == ElementKind.ENUM;
+    }
+
+    @Override
+    public boolean is(Class<?> clazz) {
+        if (type.getKind() == TypeKind.VOID && clazz == Void.TYPE) {
+            return true;
+        } else if (type.getKind().isPrimitive() && clazz.isPrimitive()) {
+            return type.toString().equals(clazz.getTypeName());
+        } else if (!type.getKind().isPrimitive() && !clazz.isPrimitive()) {
+            return types.isSameType(types.erasure(type), types.erasure(elements.getTypeElement(clazz.getTypeName()).asType()));
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean is(Handler.TypeWrapper type) {
+        if (type instanceof ForClass) {
+            return is(((ForClass) type).getClazz());
+        } else if (type instanceof HandlerForTypeMirror) {
+            return types.isSameType(types.erasure(this.type),  types.erasure(((HandlerForTypeMirror) type).type));
+        }
+        return false;
+    }
+
+    @Override
+    public Handler.TypeWrapper getComponentType() {
+        if (type instanceof ArrayType) {
+            return new HandlerForTypeMirror(((ArrayType) type).getComponentType(), types, elements);
+        } else {
+            return new HandlerForTypeMirror(null, types, elements);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return type.toString();
+    }
+
+    @Override
+    public String getTypeName() {
+        return type.toString();
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/HandlerForVariableElement.java

@@ -0,0 +1,151 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.utils.Pair;
+import lombok.Getter;
+
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Repeatable;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class HandlerForVariableElement implements Handler.ParameterWrapper {
+
+    @Getter
+    private final VariableElement parameter;
+    private final Types types;
+    private final Elements elements;
+    private final boolean varArgs;
+
+    public HandlerForVariableElement(VariableElement variableElement, Types types, Elements elements, boolean varArgs) {
+        this.parameter = variableElement;
+        this.types = types;
+        this.elements = elements;
+        this.varArgs = varArgs;
+    }
+
+    @Override
+    public Handler.TypeWrapper getType() {
+        return new HandlerForTypeMirror(parameter.asType(), types, elements);
+    }
+
+    @Override
+    public boolean isVarArgs() {
+        return varArgs;
+    }
+
+    @Override
+    public boolean isAnnotationPresent(Class<? extends Annotation> annotation) {
+        return parameter.getAnnotation(annotation) != null;
+    }
+
+    @Override
+    public <A extends Annotation> Handler.AnnotationWrapper<A> getAnnotation(Class<A> annotation) {
+        A ann = parameter.getAnnotation(annotation);
+        AnnotationMirror annMirror = parameter.getAnnotationMirrors()
+                .stream()
+                .filter(am -> new HandlerForTypeMirror(am.getAnnotationType(), types, elements).is(annotation))
+                .findFirst()
+                .orElse(null);
+        return new HandlerForAnnotationMirror<>(ann, annMirror);
+    }
+
+    @Override
+    public String getName() {
+        return parameter.getSimpleName().toString();
+    }
+
+    @Override
+    public List<Handler.AnnotationWrapper<?>> getAnnotations() {
+        return parameter.getAnnotationMirrors()
+                .stream()
+                .collect(Collectors.toMap(Function.identity(), annotationMirror -> {
+                    Class<?> clazz = getClass(annotationMirror.getAnnotationType().toString());
+                    if (clazz == null) return null;
+                    return parameter.getAnnotation((Class<? extends Annotation>) clazz);
+                }))
+                .entrySet()
+                .stream()
+                .filter(entry -> entry.getValue() != null)
+                .collect(Collectors.toMap(Map.Entry::getKey, entry -> {
+                    Annotation annotation = entry.getValue();
+                    try {
+                        Method method = annotation.annotationType().getMethod("value");
+                        Class<?> returnType = method.getReturnType();
+                        if (!returnType.isArray()) {
+                            return List.of(annotation);
+                        }
+                        Class<?> innerReturnType = returnType.getComponentType();
+                        if (!(innerReturnType.isAnnotation() && innerReturnType.isAnnotationPresent(Repeatable.class))) {
+                            return List.of(annotation);
+                        }
+                        Repeatable repeatable = innerReturnType.getAnnotation(Repeatable.class);
+                        Class<? extends Annotation> containerType = repeatable.value();
+                        if (containerType == returnType) {
+                            throw new UnsupportedOperationException("Repeatable annotation must have a container annotation");
+                        }
+                        try {
+                            return Arrays.asList((Annotation[]) method.invoke(annotation));
+                        } catch (Exception e) {
+                            return List.of(annotation);
+                        }
+                    } catch (NoSuchMethodException e) {
+                        return List.of(annotation);
+                    }
+                }))
+                .entrySet()
+                .stream()
+                .flatMap(entry -> {
+                    return entry.getValue()
+                            .stream()
+                            .map(annotation -> new Pair<AnnotationMirror, Annotation>(entry.getKey(), annotation));
+                })
+                .filter(pair -> pair.b.annotationType().isAnnotationPresent(Handler.Implementation.class))
+                .map(pair -> new HandlerForAnnotationMirror<>(pair.b, pair.a))
+                .collect(Collectors.toList());
+    }
+
+    private Class<?> getClass(String name) {
+        try {
+            return Class.forName(name);
+        } catch (ClassNotFoundException e) {
+            // Ignore
+        }
+        if (!name.contains(".")) return null;
+        Class<?> outerClass = getClass(name.substring(0, name.lastIndexOf('.')));
+        if (outerClass == null) return null;
+        name = name.substring(name.lastIndexOf('.') + 1);
+        for (Class<?> declaredClass : outerClass.getDeclaredClasses()) {
+            if (declaredClass.getSimpleName().equals(name)) {
+                return declaredClass;
+            }
+        }
+        return null;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/annotationprocessor/AbstractAnnotationProcessor.java

@@ -0,0 +1,156 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotationprocessor;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.HandlerForAnnotationMirror;
+import de.steamwar.command.HandlerForExecutableElement;
+import de.steamwar.command.HandlerForVariableElement;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.*;
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Types;
+import javax.tools.Diagnostic;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public abstract class AbstractAnnotationProcessor extends AbstractProcessor {
+
+    private Messager messager;
+    private Types types;
+    private Elements elements;
+
+    public abstract Class<? extends Annotation> getAnnotationClass();
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+        super.init(processingEnv);
+        this.messager = processingEnv.getMessager();
+        this.types = processingEnv.getTypeUtils();
+        this.elements = processingEnv.getElementUtils();
+    }
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+        return Collections.singleton(this.getAnnotationClass().getCanonicalName());
+    }
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+        List<ExecutableElement> elements = roundEnv.getElementsAnnotatedWith(getAnnotationClass())
+                .stream()
+                .filter(element -> element.getKind() == ElementKind.METHOD)
+                .map(ExecutableElement.class::cast)
+                .collect(Collectors.toList());
+        if (elements.isEmpty()) return false;
+        elements.forEach(element -> {
+            checkMethodAnnotation(element, element.getAnnotation(getAnnotationClass()));
+        });
+        return false;
+    }
+
+    private Handler getHandler(Annotation annotation, Element element) {
+        Handler.Implementation implementation = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+        if (implementation == null) return null;
+        try {
+            return implementation.value().getConstructor().newInstance();
+        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException |
+                 InvocationTargetException e) {
+            messager.printMessage(Diagnostic.Kind.ERROR, "Handler " + implementation.value().getName() + " cannot be used to check the argument validity", element);
+            return null;
+        }
+    }
+
+    private void checkMethodAnnotation(ExecutableElement method, Annotation annotation) {
+        Handler handler = getHandler(annotation, method);
+        if (handler == null) return;
+        if (!(handler instanceof Handler.HandlerMethod)) {
+            messager.printMessage(Diagnostic.Kind.ERROR, "Handler " + handler.getClass().getName() + " is not a HandlerMethod", method);
+            return;
+        }
+        Handler.HandlerMethod handlerMethod = (Handler.HandlerMethod) handler;
+        try {
+            handlerMethod.check(new HandlerForAnnotationMirror(annotation, null), new HandlerForExecutableElement(method, types, elements), DataCheckableImpl.INSTANCE);
+        } catch (Handler.HandlerException e) {
+            Handler.CodePlace codePlace = e.getCodePlace();
+            AnnotationMirror[] annotationMirrors = new AnnotationMirror[0];
+            if (codePlace.getAnnotations().length > 0) {
+                annotationMirrors = Arrays.stream(codePlace.getAnnotations())
+                        .map(annotationWrapper -> (HandlerForAnnotationMirror) annotationWrapper)
+                        .map(HandlerForAnnotationMirror::getAnnotationMirror)
+                        .toArray(AnnotationMirror[]::new);
+            }
+            Element element = null;
+            if (codePlace.getMethod() != null) {
+                element = ((HandlerForExecutableElement) codePlace.getMethod()).getMethod();
+            } else if (codePlace.getParameter() != null) {
+                element = ((HandlerForVariableElement) codePlace.getParameter()).getParameter();
+            }
+
+            if (annotationMirrors.length > 0) {
+                for  (int i = 0; i < annotationMirrors.length; i++) {
+                    messager.printMessage(Diagnostic.Kind.ERROR, e.getMessage(), element, annotationMirrors[i]);
+                }
+            } else {
+                messager.printMessage(Diagnostic.Kind.ERROR, e.getMessage(), element);
+            }
+        }
+    }
+
+    private static final class DataCheckableImpl implements Handler.DataCheckable {
+
+        private static final DataCheckableImpl INSTANCE = new DataCheckableImpl();
+
+        @Override
+        public boolean hasExecutorMapper(Class<?> clazz) {
+            return true;
+        }
+
+        @Override
+        public boolean hasMapper(String key) {
+            return true;
+        }
+
+        @Override
+        public boolean hasValidator(String key) {
+            return true;
+        }
+
+        @Override
+        public boolean hasSupplier(String key) {
+            return true;
+        }
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/annotationprocessor/impl/CachedAnnotationProcessor.java

@@ -0,0 +1,33 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotationprocessor.impl;
+
+import de.steamwar.command.annotationprocessor.AbstractAnnotationProcessor;
+import de.steamwar.command.annotations.Cached;
+
+import java.lang.annotation.Annotation;
+
+public class CachedAnnotationProcessor extends AbstractAnnotationProcessor {
+
+    @Override
+    public Class<? extends Annotation> getAnnotationClass() {
+        return Cached.class;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/annotationprocessor/impl/MapperAnnotationProcessor.java

@@ -0,0 +1,33 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotationprocessor.impl;
+
+import de.steamwar.command.annotationprocessor.AbstractAnnotationProcessor;
+import de.steamwar.command.annotations.Mapper;
+
+import java.lang.annotation.Annotation;
+
+public class MapperAnnotationProcessor extends AbstractAnnotationProcessor {
+
+    @Override
+    public Class<? extends Annotation> getAnnotationClass() {
+        return Mapper.class;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/annotationprocessor/impl/RegisterAnnotationProcessor.java

@@ -0,0 +1,33 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotationprocessor.impl;
+
+import de.steamwar.command.annotationprocessor.AbstractAnnotationProcessor;
+import de.steamwar.command.annotations.Register;
+
+import java.lang.annotation.Annotation;
+
+public class RegisterAnnotationProcessor extends AbstractAnnotationProcessor {
+
+    @Override
+    public Class<? extends Annotation> getAnnotationClass() {
+        return Register.class;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/annotationprocessor/impl/SupplierAnnotationProcessor.java

@@ -0,0 +1,33 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotationprocessor.impl;
+
+import de.steamwar.command.annotationprocessor.AbstractAnnotationProcessor;
+import de.steamwar.command.annotations.Supplier;
+
+import java.lang.annotation.Annotation;
+
+public class SupplierAnnotationProcessor extends AbstractAnnotationProcessor {
+
+    @Override
+    public Class<? extends Annotation> getAnnotationClass() {
+        return Supplier.class;
+    }
+}

CommandFramework/CommandFrameworkAnnotationProcessor/src/de/steamwar/command/annotationprocessor/impl/ValidatorAnnotationProcessor.java

@@ -0,0 +1,33 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotationprocessor.impl;
+
+import de.steamwar.command.annotationprocessor.AbstractAnnotationProcessor;
+import de.steamwar.command.annotations.Validator;
+
+import java.lang.annotation.Annotation;
+
+public class ValidatorAnnotationProcessor extends AbstractAnnotationProcessor {
+
+    @Override
+    public Class<? extends Annotation> getAnnotationClass() {
+        return Validator.class;
+    }
+}

CommandFramework/CommandFrameworkBase/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 <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractCommand.java

@@ -0,0 +1,216 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.graph.NodeData;
+import de.steamwar.command.graph.RootNode;
+import de.steamwar.command.utils.Pair;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public abstract class AbstractCommand<T> {
+
+    private static final Map<Class<? extends AbstractCommand<?>>, Map<Class<?>, Function<?, ?>>> EXECUTOR_MAPPER = new HashMap<>();
+
+    public static <E, T> void addExecutorMapper(Class<? extends AbstractCommand<E>> wrapper, Class<T> executorType, Function<E, T> mapper) {
+        EXECUTOR_MAPPER.computeIfAbsent(wrapper, __ -> new HashMap<>())
+                .putIfAbsent(executorType, mapper);
+    }
+
+    protected final String command;
+    protected final String permission;
+    private final Consumer<CommandLoader<T>> initializer;
+    protected final String[] aliases;
+    protected final List<String> descriptions = new ArrayList<>();
+
+    private boolean initialized = false;
+    protected final RootNode<T> rootNode = new RootNode<>();
+
+    private final Map<String, AbstractTypeMapper<T, ?>> localTypeMapper = new HashMap<>();
+    private final Map<String, AbstractTypeValidator<T, ?>> localValidators = new HashMap<>();
+    private final Map<String, AbstractTypeSupplier<T, ?>> localSupplier = new HashMap<>();
+
+    protected AbstractCommand(String command, Consumer<CommandLoader<T>> initializer, String... aliases) {
+        this(command, null, initializer, aliases);
+    }
+
+    protected AbstractCommand(String command, String permission, Consumer<CommandLoader<T>> 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<Runnable> errors = new ArrayList<>();
+        try {
+            boolean executed = rootNode.execute(sender, new NodeData(alias, fixArgs(args, true), (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<String> tabComplete(T sender, String alias, String[] args) throws IllegalArgumentException {
+        initialize();
+        List<Collection<String>> tabCompletes = new ArrayList<>();
+        rootNode.tabComplete(sender, new NodeData(alias, fixArgs(args, false), (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, boolean allowEmpty) {
+        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 && !allowEmpty) {
+            return new String[]{""};
+        }
+        return args;
+    }
+
+    private synchronized void initialize() {
+        if (initialized) return;
+
+        List<Object> commandObjects = new ArrayList<>();
+        initializer.accept(new CommandLoader<>() {
+            @Override
+            public AbstractCommand<T> get() {
+                return AbstractCommand.this;
+            }
+
+            @Override
+            public void add(Object command) {
+                commandObjects.add(command);
+            }
+        });
+
+        List<Pair<DataImpl, Method>> 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<Integer, Map<Triple<DataImpl, Method, Annotation>, List<Handler.HandlerMethod<Annotation>>>> handlerMap = new HashMap<>();
+        for (Pair<DataImpl, Method> commandMethod : methods) {
+            List<Annotation> 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<Annotation>) handlerObject);
+            }
+        }
+
+        List<Integer> 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(new Handler.AnnotationWrapper.ForAnnotation<>(dataMethodAnnotationTriple.c), new Handler.MethodWrapper.ForMethod(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<Method> methods(Object commandObject) {
+        List<Method> methods = new ArrayList<>();
+        Class<?> current = commandObject.getClass();
+        while (current != null) {
+            methods.addAll(Arrays.asList(current.getDeclaredMethods()));
+            current = current.getSuperclass();
+        }
+        return methods;
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.util.Collection;
+
+public interface AbstractTypeMapper<K, T> {
+
+    /**
+     * The CommandSender can be null!
+     */
+    T map(K sender, PreviousArguments previousArguments, String s);
+
+    Collection<String> 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. <br>
+     * Note: The CommandSender can be null if the cache is defined as a global cache!<br>
+     * Returning null and the empty string are equivalent.
+     */
+    default String normalize(K sender, String s) {
+        return null;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeSupplier.java

@@ -0,0 +1,25 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+public interface AbstractTypeSupplier<K, T> {
+
+    T get(K sender, PreviousArguments previousArguments);
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.util.function.BooleanSupplier;
+
+@FunctionalInterface
+public interface AbstractTypeValidator<K, T> {
+
+    /**
+     * 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<K, T> and(AbstractTypeValidator<K, T> other) {
+        return (sender, value, messageSender) -> validate(sender, value, messageSender) && other.validate(sender, value, messageSender);
+    }
+
+    default AbstractTypeValidator<K, T> or(AbstractTypeValidator<K, T> other) {
+        return (sender, value, messageSender) -> validate(sender, value, messageSender) || other.validate(sender, value, messageSender);
+    }
+
+    default AbstractTypeValidator<K, T> 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);
+        }
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class CommandFrameworkException extends RuntimeException {
+
+    private Function causeMessage;
+    private Throwable cause;
+    private Function stackTraceExtractor;
+    private String extraStackTraces;
+
+    private String message;
+
+    public CommandFrameworkException(InvocationTargetException invocationTargetException, String alias, String[] args) {
+        this(e -> {
+            StringBuilder st = new StringBuilder();
+            st.append(e.getCause().getClass().getTypeName());
+            if (e.getCause().getMessage() != null) {
+                st.append(": ").append(e.getCause().getMessage());
+            }
+            if (alias != null && !alias.isEmpty()) {
+                st.append("\n").append("Performed command: " + alias + " " + String.join(" ", args));
+            }
+            return st.toString();
+        }, invocationTargetException, e -> {
+            StackTraceElement[] stackTraceElements = e.getCause().getStackTrace();
+            return Arrays.stream(stackTraceElements).limit(stackTraceElements.length - e.getStackTrace().length);
+        }, null);
+    }
+
+    private <T extends Throwable> CommandFrameworkException(Function<T, String> causeMessage, T cause, Function<T, Stream<StackTraceElement>> 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<StackTraceElement>) 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());
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+public interface CommandLoader<T> {
+
+    AbstractCommand<T> get();
+    void add(Object command);
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.mapper.BooleanMapper;
+import de.steamwar.command.mapper.NumberMapper;
+import lombok.experimental.UtilityClass;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Repeatable;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.function.ToIntFunction;
+
+@UtilityClass
+public class CommandUtils {
+
+    final Map<String, AbstractTypeMapper<?, ?>> MAPPER_FUNCTIONS = new HashMap<>();
+
+    final Map<String, AbstractTypeValidator<?, ?>> VALIDATOR_FUNCTIONS = new HashMap<>();
+
+    final Map<String, AbstractTypeSupplier<?, ?>> SUPPLIER_FUNCTIONS = new HashMap<>();
+
+    static final AbstractTypeMapper<Object, String> STRING_MAPPER = new AbstractTypeMapper<>() {
+        @Override
+        public String map(Object sender, PreviousArguments previousArguments, String s) {
+            return s;
+        }
+
+        @Override
+        public Collection<String> 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 <K, T> void addMapper(Class<T> clazz, AbstractTypeMapper<K, T> mapper) {
+        addMapper(clazz.getTypeName(), mapper);
+    }
+
+    public static <T> void addMapper(String name, AbstractTypeMapper<T, ?> mapper) {
+        MAPPER_FUNCTIONS.putIfAbsent(name, mapper);
+    }
+
+    public static <T> void addValidator(Class<T> clazz, AbstractTypeValidator<T, ?> validator) {
+        addValidator(clazz.getTypeName(), validator);
+    }
+
+    public static <T> void addValidator(String name, AbstractTypeValidator<T, ?> validator) {
+        VALIDATOR_FUNCTIONS.putIfAbsent(name, validator);
+    }
+
+    public static <T> void addSupplier(Class<T> clazz, AbstractTypeSupplier<T, ?> supplier) {
+        addSupplier(clazz.getTypeName(), supplier);
+    }
+
+    public static <T> void addSupplier(String name, AbstractTypeSupplier<T, ?> supplier) {
+        SUPPLIER_FUNCTIONS.putIfAbsent(name, supplier);
+    }
+
+    public static List<Annotation> getAnnotations(AnnotatedElement annotatedElement) {
+        List<Annotation> 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<? extends Annotation> 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 <T extends Handler> List<Annotation> getAnnotations(AnnotatedElement annotatedElement, Class<T> type) {
+        List<Annotation> 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<Number> createComparator(String type, Handler.TypeWrapper clazz, int iValue, long lValue, float fValue, double dValue) {
+        if (clazz.is(int.class) || clazz.is(Integer.class)) {
+            return number -> Integer.compare(number.intValue(), iValue);
+        } else if (clazz.is(long.class) || clazz.is(Long.class)) {
+            return number -> Long.compare(number.longValue(), lValue);
+        } else if (clazz.is(float.class) || clazz.is(Float.class)) {
+            return number -> Float.compare(number.floatValue(), fValue);
+        } else if (clazz.is(double.class) || clazz.is(Double.class)) {
+            return number -> Double.compare(number.doubleValue(), dValue);
+        } else {
+            throw new IllegalArgumentException(type + " annotation is not supported for " + clazz);
+        }
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.annotations.Supplier;
+import de.steamwar.command.graph.*;
+import de.steamwar.command.handler.GreedyHandler;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+class DataImpl implements Handler.DataCheckable, Handler.DataReadable, Handler.DataWritable {
+
+    private final AbstractCommand<?> container;
+    private final Object self;
+    private final RootNode<?> node;
+    private final Map<Class<?>, Function<?, ?>> executorMapper;
+    private final Map<String, AbstractTypeMapper<?, ?>> mapper;
+    private final Map<String, AbstractTypeMapper<?, ?>> globalMapper;
+    private final Map<String, AbstractTypeValidator<?, ?>> validator;
+    private final Map<String, AbstractTypeValidator<?, ?>> globalValidator;
+    private final Map<String, AbstractTypeSupplier<?, ?>> supplier;
+    private final Map<String, AbstractTypeSupplier<?, ?>> globalSupplier;
+
+    private final Map<Method, Object> cache = new HashMap<>();
+
+    DataImpl(AbstractCommand<?> container, Object self, RootNode<?> node, Map<Class<?>, Function<?, ?>> executorMapper, Map<String, AbstractTypeMapper<?, ?>> mapper, Map<String, AbstractTypeMapper<?, ?>> globalMapper, Map<String, AbstractTypeValidator<?, ?>> validator, Map<String, AbstractTypeValidator<?, ?>> globalValidator, Map<String, AbstractTypeSupplier<?, ?>> supplier, Map<String, AbstractTypeSupplier<?, ?>> 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<Class<?>, 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 <A, B> AbstractTypeMapper<A, B> getMapper(String key) {
+        return (AbstractTypeMapper<A, B>) mapper.getOrDefault(key, globalMapper.get(key));
+    }
+
+    @Override
+    public <A, B> void addMapper(String key, boolean local, AbstractTypeMapper<A, B> 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 <A, B> AbstractTypeValidator<A, B> getValidator(String key) {
+        return (AbstractTypeValidator<A, B>) validator.getOrDefault(key, globalValidator.get(key));
+    }
+
+    @Override
+    public <A, B> void addValidator(String key, boolean local, AbstractTypeValidator<A, B> 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 <A, B> AbstractTypeSupplier<A, B> getSupplier(String key) {
+        return (AbstractTypeSupplier<A, B>) supplier.getOrDefault(key, globalSupplier.get(key));
+    }
+
+    @Override
+    public <A, B> void addSupplier(String key, boolean local, AbstractTypeSupplier<A, B> 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> 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));
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/Handler.java

@@ -0,0 +1,370 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import lombok.Getter;
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public interface Handler {
+
+    default Optional<Class<?>> 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<? extends Handler> value();
+    }
+
+    class HandlerException extends Exception {
+        @Getter
+        private final CodePlace codePlace;
+
+        public HandlerException(String message, CodePlace codePlace) {
+            super(message);
+            this.codePlace = codePlace;
+        }
+    }
+
+    interface DataCheckable {
+        boolean hasExecutorMapper(Class<?> clazz);
+
+        boolean hasMapper(String key);
+
+        boolean hasValidator(String key);
+
+        boolean hasSupplier(String key);
+    }
+
+    interface DataReadable {
+        Function<?, ?> getExecutorMapper(Class<?> clazz);
+
+        <A, B> AbstractTypeMapper<A, B> getMapper(String key);
+
+        <A, B> AbstractTypeValidator<A, B> getValidator(String key);
+
+        <A, B> AbstractTypeSupplier<A, B> getSupplier(String key);
+    }
+
+    interface DataWritable {
+        Function<?, ?> getExecutorMapper(Class<?> clazz);
+
+        <A, B> void addMapper(String key, boolean local, AbstractTypeMapper<A, B> mapper);
+
+        <A, B> void addValidator(String key, boolean local, AbstractTypeValidator<A, B> validator);
+
+        <A, B> void addSupplier(String key, boolean local, AbstractTypeSupplier<A, B> supplier);
+
+        /**
+         * Invoking the same method twice will result in the exact same result.
+         */
+        <T> T invoke(Method method);
+
+        void addCommand(Method method, String[] subCommand, String[] description, boolean noTabComplete);
+    }
+
+    interface HandlerMethod<T extends Annotation> extends Handler {
+        void check(AnnotationWrapper<T> annotation, MethodWrapper method, DataCheckable dataCheckable) throws HandlerException;
+
+        int getRunPriority();
+
+        void run(T annotation, Method method, DataWritable dataWritable);
+    }
+
+    interface HandlerParameter<T extends Annotation, A, B> extends Handler {
+        void check(AnnotationWrapper<T> annotation, MethodWrapper methodWrapper, ParameterWrapper parameter, int index, DataCheckable dataCheckable) throws HandlerException;
+
+        default boolean needsParentTypeMapper() {
+            return false;
+        }
+
+        /**
+         * Null values are allowed to be returned.
+         */
+        default AbstractTypeMapper<A, B> getTypeMapper(T annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<A, B> parentTypeMapper) {
+            return null;
+        }
+
+        default int getValidatorPriority() {
+            return 0;
+        }
+
+        /**
+         * Null values are allowed to be returned.
+         */
+        default AbstractTypeValidator<A, B> getValidator(T annotation, Parameter parameter, int index, DataReadable dataReadable) {
+            return null;
+        }
+    }
+
+    @Getter
+    class CodePlace {
+
+        private final MethodWrapper method;
+        private final ParameterWrapper parameter;
+        private final AnnotationWrapper<?>[] annotations;
+
+        public CodePlace(MethodWrapper method, AnnotationWrapper<?>... annotations) {
+            this.method = method;
+            this.parameter = null;
+            this.annotations = annotations;
+        }
+
+        public CodePlace(ParameterWrapper parameter, AnnotationWrapper<?>... annotations) {
+            this.method = null;
+            this.parameter = parameter;
+            this.annotations = annotations;
+        }
+    }
+
+    interface MethodWrapper {
+        String getName();
+
+        int getParameterCount();
+
+        TypeWrapper getReturnType();
+
+        ParameterWrapper[] getParameters();
+
+        class ForMethod implements MethodWrapper {
+
+            @Getter
+            private final Method method;
+
+            public ForMethod(Method method) {
+                this.method = method;
+            }
+
+            @Override
+            public String getName() {
+                return method.getName();
+            }
+
+            @Override
+            public int getParameterCount() {
+                return method.getParameterCount();
+            }
+
+            @Override
+            public TypeWrapper getReturnType() {
+                return new TypeWrapper.ForClass(method.getReturnType());
+            }
+
+            @Override
+            public ParameterWrapper[] getParameters() {
+                return Arrays.stream(method.getParameters()).map(ParameterWrapper.ForParameter::new).toArray(ParameterWrapper[]::new);
+            }
+        }
+    }
+
+    interface ParameterWrapper {
+        TypeWrapper getType();
+
+        boolean isVarArgs();
+
+        boolean isAnnotationPresent(Class<? extends Annotation> annotation);
+
+        <A extends Annotation> AnnotationWrapper<A> getAnnotation(Class<A> annotation);
+
+        String getName();
+
+        List<AnnotationWrapper<?>> getAnnotations();
+
+        class ForParameter implements ParameterWrapper {
+
+            @Getter
+            private final Parameter parameter;
+
+            public ForParameter(Parameter parameter) {
+                this.parameter = parameter;
+            }
+
+            @Override
+            public TypeWrapper getType() {
+                return new TypeWrapper.ForClass(this.parameter.getType());
+            }
+
+            @Override
+            public boolean isVarArgs() {
+                return parameter.isVarArgs();
+            }
+
+            @Override
+            public boolean isAnnotationPresent(Class<? extends Annotation> annotation) {
+                return parameter.isAnnotationPresent(annotation);
+            }
+
+            @Override
+            public <A extends Annotation> AnnotationWrapper<A> getAnnotation(Class<A> annotation) {
+                return new AnnotationWrapper.ForAnnotation<>(parameter.getAnnotation(annotation));
+            }
+
+            @Override
+            public String getName() {
+                return parameter.getName();
+            }
+
+            @Override
+            public List<AnnotationWrapper<?>> getAnnotations() {
+                return CommandUtils.getAnnotations(parameter)
+                        .stream()
+                        .map(AnnotationWrapper.ForAnnotation::new)
+                        .collect(Collectors.toList());
+            }
+        }
+    }
+
+    interface TypeWrapper {
+
+        boolean isAssignableTo(Class<?> clazz);
+
+        boolean isAssignableTo(TypeWrapper type);
+
+        boolean isPrimitive();
+
+        boolean isArray();
+
+        boolean isEnum();
+
+        boolean is(Class<?> clazz);
+
+        boolean is(TypeWrapper type);
+
+        TypeWrapper getComponentType();
+
+        String getName();
+
+        String getTypeName();
+
+        class ForClass implements TypeWrapper {
+            @Getter
+            private final Class<?> clazz;
+
+            public ForClass(Class<?> clazz) {
+                this.clazz = clazz;
+            }
+
+            @Override
+            public boolean isAssignableTo(Class<?> clazz) {
+                return clazz.isAssignableFrom(this.clazz);
+            }
+
+            @Override
+            public boolean isAssignableTo(TypeWrapper type) {
+                if (type instanceof ForClass) {
+                    return ((ForClass) type).getClazz().isAssignableFrom(clazz);
+                }
+                return false;
+            }
+
+            @Override
+            public boolean isPrimitive() {
+                return clazz.isPrimitive();
+            }
+
+            @Override
+            public boolean isArray() {
+                return clazz.isArray();
+            }
+
+            @Override
+            public boolean isEnum() {
+                return clazz.isEnum();
+            }
+
+            @Override
+            public boolean is(Class<?> clazz) {
+                return this.clazz == clazz;
+            }
+
+            @Override
+            public boolean is(TypeWrapper type) {
+                if (type instanceof ForClass) {
+                    return ((ForClass) type).getClazz() == this.clazz;
+                }
+                return false;
+            }
+
+            @Override
+            public TypeWrapper getComponentType() {
+                return new TypeWrapper.ForClass(this.clazz.getComponentType());
+            }
+
+            @Override
+            public String getName() {
+                return this.clazz.getName();
+            }
+
+            @Override
+            public String getTypeName() {
+                return this.clazz.getTypeName();
+            }
+        }
+    }
+
+    interface AnnotationWrapper<A extends Annotation> {
+
+        A getAnnotation();
+
+        class ForAnnotation<A extends Annotation> implements AnnotationWrapper<A> {
+
+            private A annotation;
+
+            public ForAnnotation(A annotation) {
+                this.annotation = annotation;
+            }
+
+            @Override
+            public A getAnnotation() {
+                return this.annotation;
+            }
+        }
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.util.Arrays;
+import java.util.List;
+
+public interface OptionEnum<T extends Enum<T> & OptionEnum<T>> {
+    default List<String> getTabCompletes() {
+        return Arrays.asList("-" + ((T) this).name().toLowerCase());
+    }
+    T[] getRemoved();
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import lombok.NonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class PreviousArguments {
+
+    public final String[] userArgs;
+    public final Object[] mappedArgs;
+    public final boolean hasMoreArguments;
+    private final Function<String, Object> getByNameFunction;
+    private boolean usedOptionalValue = false;
+
+    public PreviousArguments(String[] userArgs, Object[] mappedArgs, boolean hasMoreArguments, Function<String, Object> 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> T getMappedArg(int index) {
+        return (T) mappedArgs[mappedArgs.length - index - 1];
+    }
+
+    public <T> Optional<T> getFirst(Class<T> clazz) {
+        for (Object o : mappedArgs) {
+            if (clazz.isInstance(o)) {
+                return Optional.of((T) o);
+            }
+        }
+        return Optional.empty();
+    }
+
+    public <T> List<T> getAll(Class<T> clazz) {
+        List<T> 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> T getByName(@NonNull String name) {
+        return (T) getByNameFunction.apply(name);
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.UtilityClass;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+@UtilityClass
+public class TabCompletionCache {
+
+    private final Map<Key, TabCompletions> tabCompletionCache = new ConcurrentHashMap<>();
+
+    Set<AbstractTypeMapper<?, ?>> cached = new HashSet<>();
+    Set<AbstractTypeMapper<?, ?>> global = new HashSet<>();
+    Map<AbstractTypeMapper<?, ?>, Long> cacheDuration = new HashMap<>();
+
+    static {
+        Thread thread = new Thread(() -> {
+            while (true) {
+                Set<Key> toRemove = new HashSet<>();
+                for (Map.Entry<Key, TabCompletions> 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 <A, B> AbstractTypeMapper<A, B> cached(AbstractTypeMapper<A, B> dataMapper, AbstractTypeMapper<A, B> 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<String> 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<String> tabCompletions;
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.AllowNullHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to allow null values passed to the command.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(AllowNullHandler.Impl.class)
+public @interface AllowNull {
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ArrayLength.java

@@ -0,0 +1,53 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ArrayLengthHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a minimum and maximum length the supplied array can have.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(ArrayLengthHandler.Impl.class)
+public @interface ArrayLength {
+    /**
+     * Inclusive
+     */
+    int min() default 0;
+
+    /**
+     * Inclusive
+     */
+    int max() default Integer.MAX_VALUE;
+
+    /**
+     * Error message if too few Elements got parsed. There are 2 arguments provided to the message.
+     * The first is the number of elements that got parsed as a number and the second one is how many
+     * should have been parsed, so the min number of elements expected.
+     */
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Cached.java

@@ -0,0 +1,52 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.CachedHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * This annotation is used to register a or {@link Mapper}
+ * on registration as being cached. Only TabCompletions are cached for the duration
+ * denoted by {@link #timeUnit()} and {@link #cacheDuration()} using
+ * {@link TimeUnit#toMillis(long)}. If {@link #global()} is {@code true}, the
+ * cache will not be created per player but for everyone. This is useful for
+ * commands that are not player specific.
+ * <br><br>
+ * To calculate the cache key for a {@link AbstractTypeMapper} the
+ * {@link AbstractTypeMapper#normalize(Object, String)} method is called.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Handler.Implementation(CachedHandler.Impl.class)
+public @interface Cached {
+    long cacheDuration() default 5;
+
+    TimeUnit timeUnit() default TimeUnit.SECONDS;
+
+    boolean global() default false;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ClassMapper.java

@@ -0,0 +1,56 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ClassMapperHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for registering a method as a class mapper.
+ * The annotated method will be executed while {@link #initialize()}
+ * is evaluated. The result of this method will be cached under the
+ * name {@link ClassMapper#value()} converted to a {@link String} using
+ * {@link Class#getTypeName()}. {@link AbstractTypeMapper} will be used
+ * as the default mapper if the type this mapper is registered for is
+ * found as a parameter of any command method annotated with {@link Register}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Handler.Implementation(ClassMapperHandler.Impl.class)
+@Deprecated
+@DeprecationInfo("Use @Mapper instead")
+public @interface ClassMapper {
+
+    /**
+     * The type this mapper is registered for.
+     */
+    Class<?> value();
+
+    /**
+     * If {@code true}, the mapper will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ClassValidator.java

@@ -0,0 +1,53 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ClassValidatorHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for registering a method as a class validator.
+ * The annotated method will be executed while {@link #initialize()}
+ * is evaluated. The result of this method will be cached under the
+ * name {@link ClassValidator#value()} converted to a {@link String} using
+ * {@link Class#getTypeName()}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Handler.Implementation(ClassValidatorHandler.Impl.class)
+@Deprecated
+@DeprecationInfo("Use @Validator instead")
+public @interface ClassValidator {
+
+    /**
+     * The type this validator is registered for.
+     */
+    Class<?> value();
+
+    /**
+     * If {@code true}, the validator will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/DeprecationInfo.java

@@ -0,0 +1,28 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DeprecationInfo {
+    String value();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/EndsWith.java

@@ -0,0 +1,38 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.EndsWithHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(EndsWithHandler.Impl.class)
+public @interface EndsWith {
+
+    String value();
+
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ErrorMessage.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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ErrorMessageHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define an error message for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(ErrorMessageHandler.Impl.class)
+public @interface ErrorMessage {
+    /**
+     * Error message to be displayed when the parameter is invalid.
+     */
+    String value();
+
+    /**
+     * This is the short form for 'allowEmptyArrays'.
+     */
+    @Deprecated
+    @DeprecationInfo("Use @ArrayLength instead of this flag")
+    boolean allowEAs() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Greedy.java

@@ -0,0 +1,46 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.GreedyHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation can have a huge performance impact. Both positive and negative.
+ * You can design your command to be more flexible and allow performance improvements if used correctly.
+ * <br><br>
+ * The more restrictive the underlying array type is, the more performance can be gained.
+ * <br><br>
+ * Using this annotation on the varargs parameter of a command will not have any effect, since they are already treated as greedy arrays.
+ * <br><br>
+ * The {@link #backTrackingDepth()} can be used to limit the amount of backtracking that is done. This can be used to improve performance.
+ * For varargs parameters, this value is defaulted to 0, since they are at the end of the parameter list.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(GreedyHandler.Impl.class)
+public @interface Greedy {
+    int backTrackingDepth() default Integer.MAX_VALUE;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Length.java

@@ -0,0 +1,46 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.LengthHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a minimum and maximum length the supplied string can have.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(LengthHandler.Impl.class)
+public @interface Length {
+    /**
+     * Inclusive
+     */
+    int min() default 0;
+
+    /**
+     * Inclusive
+     */
+    int max() default Integer.MAX_VALUE;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Mapper.java

@@ -0,0 +1,58 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.MapperHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for registering a method as a mapper. The annotated method will
+ * be executed while {@link #initialize()} is evaluated. The result of this
+ * method will be cached under either {@link Mapper#value()} or {@link Mapper#value()}.
+ * If {@link Mapper#type()} is used any parameter using that type will be using
+ * this {@link AbstractTypeMapper} implicitly. While using this annotation on
+ * a method it can be possible to not supply any type. On a parameter you can
+ * only use this annotation using the {@link Mapper#value()} value.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Handler.Implementation(MapperHandler.Impl.class)
+public @interface Mapper {
+    /**
+     * The name this mapper is registered for.
+     */
+    String value() default "";
+
+    /**
+     * The type this mapper is registered for.
+     */
+    Class<?> type() default void.class;
+
+    /**
+     * If {@code true}, the mapper will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Max.java

@@ -0,0 +1,70 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.MaxHandler;
+import de.steamwar.command.handler.MaxReferenceHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a maximum number value for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(MaxHandler.Impl.class)
+public @interface Max {
+    int intValue() default Integer.MAX_VALUE;
+
+    long longValue() default Long.MAX_VALUE;
+
+    float floatValue() default Float.MAX_VALUE;
+
+    double doubleValue() default Double.MAX_VALUE;
+
+    boolean inclusive() default true;
+
+    /**
+     * Error message to be displayed when the argument supplied is bigger than this allows.
+     * Two arguments are supplied to the error message. The first is the number that got parsed
+     * and the second is the max this annotation allows.
+     */
+    String error() default "";
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(MaxReferenceHandler.Impl.class)
+    @interface Reference {
+        String value();
+
+        boolean inclusive() default true;
+
+        /**
+         * Error message to be displayed when the argument supplied is smaller than this allows.
+         * Two arguments are supplied to the error message. The first is the number that got parsed
+         * and the second is the min this annotation allows.
+         */
+        String error() default "";
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Min.java

@@ -0,0 +1,70 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.MinHandler;
+import de.steamwar.command.handler.MinReferenceHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a minimum number value for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(MinHandler.Impl.class)
+public @interface Min {
+    int intValue() default Integer.MIN_VALUE;
+
+    long longValue() default Long.MIN_VALUE;
+
+    float floatValue() default Float.MIN_VALUE;
+
+    double doubleValue() default Double.MIN_VALUE;
+
+    boolean inclusive() default true;
+
+    /**
+     * Error message to be displayed when the argument supplied is smaller than this allows.
+     * Two arguments are supplied to the error message. The first is the number that got parsed
+     * and the second is the min this annotation allows.
+     */
+    String error() default "";
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(MinReferenceHandler.Impl.class)
+    @interface Reference {
+        String value();
+
+        boolean inclusive() default true;
+
+        /**
+         * Error message to be displayed when the argument supplied is smaller than this allows.
+         * Two arguments are supplied to the error message. The first is the number that got parsed
+         * and the second is the min this annotation allows.
+         */
+        String error() default "";
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Name.java

@@ -0,0 +1,31 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+public @interface Name {
+    String value();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/OptionalValue.java

@@ -0,0 +1,46 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.OptionalValueHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a default value for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(OptionalValueHandler.Impl.class)
+public @interface OptionalValue {
+    /**
+     * Will pe parsed against the TypeMapper specified by the parameter or annotation.
+     */
+    String value();
+
+    /**
+     * The method name stands for 'onlyUseIfNoneIsGiven'.
+     */
+    boolean onlyUINIG() default false;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Regex.java

@@ -0,0 +1,38 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.RegexHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(RegexHandler.Impl.class)
+public @interface Regex {
+
+    String value();
+
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Register.java

@@ -0,0 +1,57 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.RegisterHandler;
+
+import java.lang.annotation.*;
+
+/**
+ * Annotation for registering a method as a command.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Repeatable(Register.Registers.class)
+@Handler.Implementation(RegisterHandler.Impl.class)
+public @interface Register {
+
+    /**
+     * Identifier of subcommand.
+     */
+    String[] value() default {};
+
+    /**
+     * Description of subcommand.
+     */
+    String[] description() default {};
+
+    /**
+     * If {@code true}, the command will not be tab completed.
+     */
+    boolean noTabComplete() default false;
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.METHOD})
+    @Handler.Implementation(RegisterHandler.Impl.class)
+    @interface Registers {
+        Register[] value();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/StartsWith.java

@@ -0,0 +1,38 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.StartsWithHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(StartsWithHandler.Impl.class)
+public @interface StartsWith {
+
+    String value();
+
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/StaticValue.java

@@ -0,0 +1,58 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.StaticValueHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define static values for a parameter like an enum just without the enum.
+ * You can use this annotation on a parameter of type {@link String} or {@link int}, {@link long} and
+ * {@link boolean}. While using an int, the value will represent the index into the value array. While
+ * using a boolean, the {@link #falseValues()} defines which indices are considered {@code false} or
+ * {@code true}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(StaticValueHandler.Impl.class)
+@Deprecated
+@DeprecationInfo("Use @Values instead")
+public @interface StaticValue {
+    String[] value();
+
+    /**
+     * This is the short form for 'allowImplicitSwitchExpressions'
+     * and can be set to true if you want to allow int as well as boolean as annotated parameter types.
+     * The value array needs to be at least 2 long for this flag to be considered.
+     * While using an int, the value will represent the index into the value array.
+     * While using a boolean, the {@link #falseValues()} defines which indices are
+     * considered {@code false} or {@code true}.
+     */
+    @Deprecated
+    @DeprecationInfo("Dont need to set this to true")
+    boolean allowISE() default false;
+
+    int[] falseValues() default {0};
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Supplier.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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.SupplierHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Handler.Implementation(SupplierHandler.Impl.class)
+public @interface Supplier {
+    /**
+     * The name this supplier is registered for.
+     */
+    String value() default "";
+
+    /**
+     * The type this supplier is registered for.
+     */
+    Class<?> type() default void.class;
+
+    /**
+     * If {@code true}, the supplier will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/TabFilter.java

@@ -0,0 +1,40 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.TabFilterHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation defines per Parameter how the TabCompletions should be filtered and displayed by the client.
+ * There are 3 modes further described by {@link TabFilterType}. If this annotation is not present the default
+ * {@link TabFilterType#STARTS_WITH} is used.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(TabFilterHandler.Impl.class)
+public @interface TabFilter {
+    TabFilterType value();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/TabFilterType.java

@@ -0,0 +1,41 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+public enum TabFilterType {
+
+    /**
+     * This value defines that, the starts with tab-completion filter is used.<br>
+     * see: {@link de.steamwar.command.mapper.internal.StartsWithFilter} for more.
+     */
+    STARTS_WITH,
+
+    /**
+     * This value defines that, the contains tab-completions filter is used.
+     * see: {@link de.steamwar.command.mapper.internal.ContainsFilter} for more.
+     */
+    CONTAINS,
+
+    /**
+     * This value disables any tab-completion filters and just returns anything you
+     * specified inside the TypeMapper.
+     */
+    NONE
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Unique.java

@@ -0,0 +1,37 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.UniqueHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define an array with unique values.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(UniqueHandler.Impl.class)
+public @interface Unique {
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Validator.java

@@ -0,0 +1,68 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ValidatorHandler;
+
+import java.lang.annotation.*;
+
+/**
+ * Annotation for registering a method as a validator.
+ * The annotated method will be executed while {@link #initialize()}
+ * is evaluated. The result of this method will be cached under the
+ * name {@link ClassValidator#value()} converted to a {@link String} using
+ * {@link Class#getTypeName()}.
+ * This annotation can also be used on parameters to apply a validator to them.
+ * You can leave the {@link #value()} empty here to use the type of the parameter.
+ * For registering you should never leave {@link #value()} empty.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Handler.Implementation(ValidatorHandler.Impl.class)
+@Repeatable(Validator.Validators.class)
+public @interface Validator {
+    /**
+     * The name this validator is registered for.
+     */
+    String value() default "";
+
+    /**
+     * The type this validator is registered for.
+     */
+    Class<?> type() default void.class;
+
+    /**
+     * If {@code true}, the validator will only be used in the current command class.
+     */
+    boolean local() default true;
+
+    /**
+     * If {@code true}, the validator will be inverted for parameter usage.
+     */
+    boolean invert() default false;
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(ValidatorHandler.Impl.class)
+    @interface Validators {
+        Validator[] value();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Values.java

@@ -0,0 +1,52 @@
+/*
+ *   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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ValuesHandler;
+import de.steamwar.command.handler.ValuesReferenceHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define static values for a parameter like an enum just without the enum.
+ * You can use this annotation on a parameter of type {@link String} or {@link int}, {@link long} and
+ * {@link boolean}. While using an int, the value will represent the index into the value array. While
+ * using a boolean, the {@link #falseValues()} defines which indices are considered {@code false} or
+ * {@code true}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(ValuesHandler.Impl.class)
+public @interface Values {
+    String[] value();
+
+    int[] falseValues() default {0};
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(ValuesReferenceHandler.Impl.class)
+    @interface Reference {
+        String value();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractArrayNode.java

@@ -0,0 +1,110 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.handler.ArrayLengthHandler;
+import de.steamwar.command.handler.UniqueHandler;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+public abstract class AbstractArrayNode<E> extends AbstractTypeNode<E> {
+
+    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<Collection<String>> completions) {
+        Object array = Array.newInstance(type, Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength));
+
+        int i = 0;
+        while (!nodeData.hasOneLeft()) {
+            if (i >= minArrayLength) {
+                for (Node<E> child : children) {
+                    child.tabComplete(executor, nodeData, completions);
+                }
+            }
+
+            nodeData.add(name, arrayCopy(array, i));
+            Triple<Object, Boolean, Boolean> 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<Object, List<String>> 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<E> 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();
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.*;
+import de.steamwar.command.annotations.TabFilterType;
+import de.steamwar.command.handler.TabFilterHandler;
+import de.steamwar.command.mapper.EnumMapper;
+import de.steamwar.command.mapper.OptionEnumMapper;
+import de.steamwar.command.mapper.internal.ContainsFilter;
+import de.steamwar.command.mapper.internal.StartsWithFilter;
+import de.steamwar.command.utils.Pair;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.List;
+
+public abstract class AbstractTypeNode<E> extends AbstractValidationNode<E> {
+
+    protected Class<?> type;
+    protected AbstractTypeMapper<E, Object> 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<E, Object> getTypeMapper(Handler.DataReadable dataReadable) {
+        AbstractTypeMapper<E, Object> 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<Pair<Annotation, Handler.HandlerParameter>> pairs, Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        AbstractTypeMapper<E, Object> typeMapper = getTypeMapper(dataReadable);
+        boolean isStillDefault = true;
+        for (Pair<Annotation, Handler.HandlerParameter> pair : pairs) {
+            if (pair.b.needsParentTypeMapper()) {
+                continue;
+            }
+            if (!isStillDefault) {
+                throw new UnsupportedOperationException("Only one HandlerParameter can be used without a parent TypeMapper");
+            }
+            AbstractTypeMapper<E, Object> temp = pair.b.getTypeMapper(pair.a, parameter, index, dataReadable, null);
+            if (temp != null) {
+                typeMapper = temp;
+                isStillDefault = false;
+            }
+        }
+
+        AbstractTypeMapper<E, Object> current = typeMapper;
+        for (Pair<Annotation, Handler.HandlerParameter> pair : pairs) {
+            if (!pair.b.needsParentTypeMapper()) {
+                continue;
+            }
+            AbstractTypeMapper<E, Object> 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<Object, Boolean, Boolean> 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<E, Object> 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<E> children) {
+        if (!(children instanceof AbstractTypeNode)) {
+            return false;
+        }
+        return super.equals(parameter, children);
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.CommandUtils;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.AllowNullHandler;
+import de.steamwar.command.utils.Pair;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+public abstract class AbstractValidationNode<E> extends Node<E> {
+
+    private static final AbstractTypeValidator<?, ?> NON_NULL_VALIDATOR = (AbstractTypeValidator<Object, Object>) (sender, value, messageSender) -> value != null;
+
+    protected final List<Annotation> annotations;
+    protected final List<Pair<Annotation, Handler.HandlerParameter>> handlerParameters;
+    protected final List<AbstractTypeValidator<E, Object>> validators = new ArrayList<>();
+
+    protected AbstractValidationNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter);
+        annotations = CommandUtils.getAnnotations(parameter, Handler.HandlerParameter.class);
+        List<Pair<Annotation, Handler.HandlerParameter>> 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<Pair<Annotation, Handler.HandlerParameter>> pairs, Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        pairs.sort(Comparator.comparingInt(p -> p.b.getValidatorPriority()));
+        for (Pair<Annotation, Handler.HandlerParameter> pair : pairs) {
+            AbstractTypeValidator<E, Object> validator = pair.b.getValidator(pair.a, parameter, index, dataReadable);
+            if (validator != null) {
+                validators.add(validator);
+            }
+        }
+
+        if (!AllowNullHandler.isPresent(parameter)) {
+            validators.add((AbstractTypeValidator<E, Object>) NON_NULL_VALIDATOR);
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> 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<Class<?>, 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();
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.CommandFrameworkException;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ExecuteNode<E> extends Node<E> {
+
+    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<E> 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<Collection<String>> completions) {
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> 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;
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+
+public class ExecutorTypeNode<E> extends AbstractValidationNode<E> {
+
+    protected final Function<E, ?> executorMapper;
+
+    public ExecutorTypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+        this.executorMapper = (Function<E, ?>) dataReadable.getExecutorMapper(parameter.getType());
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        Object mappedExecutor = executorMapper.apply(executor);
+        if (mappedExecutor == null) return false;
+        for (AbstractTypeValidator<E, Object> 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<E> child : children) {
+            if (child.execute(executor, nodeData)) return true;
+        }
+        nodeData.remove();
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        Object mappedExecutor = executorMapper.apply(executor);
+        if (mappedExecutor == null) return;
+        for (AbstractTypeValidator<E, Object> validator : validators) {
+            try {
+                if (!validator.validate(executor, executor, nodeData)) {
+                    return;
+                }
+            } catch (ClassCastException e) {
+                // Ignore
+            } catch (Throwable e) {
+                return;
+            }
+        }
+        nodeData.add(name, mappedExecutor);
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+        nodeData.remove();
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (!(children instanceof ExecutorTypeNode)) {
+            return false;
+        }
+        ExecutorTypeNode other = (ExecutorTypeNode) children;
+        if (executorMapper != other.executorMapper) {
+            return false;
+        }
+        return super.equals(parameter, children);
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.GreedyHandler;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Parameter;
+import java.util.HashSet;
+import java.util.Set;
+
+public class GreedyArrayNode<E> extends AbstractArrayNode<E> {
+
+    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<Object> seen = new HashSet<>();
+
+        int i = 0;
+        for (; i < max; i++) {
+            nodeData.add(name, arrayCopy(array, i));
+            Triple<Object, Boolean, Boolean> 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<E> 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;
+    }
+}

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 <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+
+public class LiteralNode<E> extends Node<E> {
+
+    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<E> child : children) {
+                if (child.execute(executor, nodeData)) {
+                    return true;
+                }
+            }
+            nodeData.unconsume();
+        }
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        if (nodeData.hasOneLeft()) {
+            if (literal.startsWith(nodeData.current())) {
+                completions.add(List.of(literal));
+            }
+            return;
+        }
+
+        if (nodeData.current().equalsIgnoreCase(literal)) {
+            nodeData.consume();
+            for (Node<E> child : children) {
+                child.tabComplete(executor, nodeData, completions);
+            }
+            nodeData.unconsume();
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (!(children instanceof LiteralNode)) {
+            return false;
+        }
+        return literal.equalsIgnoreCase(((LiteralNode) children).literal);
+    }
+}