SkriptRegistration - gave functions their own Registrar

Author: ShaneBeee

src/main/java/io/github/syst3ms/skriptparser/registration/SkriptRegistration.java

@@ -33,6 +33,9 @@
 import io.github.syst3ms.skriptparser.registration.tags.Tag;
 import io.github.syst3ms.skriptparser.registration.tags.TagInfo;
 import io.github.syst3ms.skriptparser.registration.tags.TagManager;
+import io.github.syst3ms.skriptparser.structures.functions.FunctionParameter;
+import io.github.syst3ms.skriptparser.structures.functions.Functions;
+import io.github.syst3ms.skriptparser.structures.functions.JavaFunction;
 import io.github.syst3ms.skriptparser.types.Type;
 import io.github.syst3ms.skriptparser.types.TypeManager;
 import io.github.syst3ms.skriptparser.types.changers.Arithmetic;
@@ -46,6 +49,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -80,6 +84,7 @@ public class SkriptRegistration {
     private final List<TagInfo<? extends Tag>> tags = new ArrayList<>();
     private final List<SkriptEventInfo<?>> events = new ArrayList<>();
     private final List<StructureInfo<?>> structures = new ArrayList<>();
+    private final List<FunctionRegistrar<?>> functions = new ArrayList<>();
     private final SkriptAddon registerer;
     private final SkriptLogger logger;
     protected boolean newTypes;
@@ -172,6 +177,13 @@ public List<StructureInfo<?>> getStructures() {
         return this.structures;
     }
 
+    /**
+     * @return All currently registered functions
+     */
+    public List<FunctionRegistrar<?>> getFunctions() {
+        return this.functions;
+    }
+
     /**
      * @return all currently registered types
      */
@@ -765,6 +777,9 @@ public List<LogEntry> register(boolean ignoreLogs) {
         Converters.registerConverters(this);
         Converters.createMissingConverters();
         finishConsumers.forEach(consumer -> consumer.accept(registerer));
+        for (FunctionRegistrar<?> function : getFunctions()) {
+            Functions.registerFunction(this, function.javaFunction);
+        }
         if (ignoreLogs) {
             logger.clearLogs();
             return new ArrayList<>();
@@ -1048,6 +1063,105 @@ public void register() {
         }
     }
 
+    public class FunctionRegistrar<T> implements Registrar {
+
+        private final Documentation documentation = new Documentation();
+        private final String functionName;
+        private final Class<T> returnType;
+        private final boolean isSingle;
+        private final List<FunctionParameter<?>> params = new ArrayList<>();
+        public JavaFunction<T> javaFunction;
+        private Function<Object[][],T[]> func;
+
+        public FunctionRegistrar(String functionName, Class<T> returnType, boolean isSingle) {
+            this.functionName = functionName;
+            this.returnType = returnType;
+            this.isSingle = isSingle;
+        }
+
+        public FunctionRegistrar<T> parameter(String name, Class<?> type, boolean single) {
+            FunctionParameter<?> param = new FunctionParameter<>(name, type, single);
+            this.params.add(param);
+            return this;
+        }
+
+        public FunctionRegistrar<T> parameter(String name, Class<?> type) {
+            FunctionParameter<?> param = new FunctionParameter<>(name, type, true);
+            this.params.add(param);
+            return this;
+        }
+
+
+        public FunctionRegistrar<T> execute(Function<Object[][],T[]> params) {
+            this.func = params;
+            return this;
+        }
+
+        @SuppressWarnings("unchecked")
+        public FunctionRegistrar<T> executeSingle(Function<Object[][],T> params) {
+            this.func = objects -> {
+                T[] o = (T[]) Array.newInstance(this.returnType, 1);
+                o[0] = params.apply(objects);
+                return o;
+            };
+            return this;
+        }
+
+        public FunctionRegistrar<T> noDoc() {
+            this.documentation.noDoc();
+            return this;
+        }
+
+        public FunctionRegistrar<T> experimental() {
+            this.documentation.experimental();
+            return this;
+        }
+
+        public FunctionRegistrar<T> experimental(String message) {
+            this.documentation.experimental(message);
+            return this;
+        }
+
+        public FunctionRegistrar<T> name(String name) {
+            this.documentation.setName(name);
+            return this;
+        }
+
+        public FunctionRegistrar<T> description(String... description) {
+            this.documentation.setDescription(description);
+            return this;
+        }
+
+        public FunctionRegistrar<T> examples(String... examples) {
+            this.documentation.setExamples(examples);
+            return this;
+        }
+
+        public FunctionRegistrar<T> since(String since) {
+            this.documentation.setSince(since);
+            return this;
+        }
+
+        @Override
+        public void register() {
+            this.javaFunction = new JavaFunction<>(this.functionName,
+                this.params.toArray(new FunctionParameter[0]),
+                this.returnType,
+                this.isSingle) {
+                @Override
+                public T[] executeSimple(Object[][] params) {
+                    return func.apply(params);
+                }
+            };
+            SkriptRegistration.this.functions.add(this);
+        }
+    }
+
+    public <T> FunctionRegistrar<T> newJavaFunction(String functionName, Class<T> returnType, boolean isSingle) {
+        return new FunctionRegistrar<>(functionName, returnType, isSingle);
+
+    }
+
     public class ExpressionRegistrar<C extends Expression<? extends T>, T> extends SyntaxRegistrar<C> {
         private final Class<T> returnType;
         private final boolean isSingle;

src/main/java/io/github/syst3ms/skriptparser/structures/functions/DefaultFunctions.java

@@ -7,17 +7,14 @@ public class DefaultFunctions {
 
     static {
         SkriptRegistration reg = Parser.getMainRegistration();
-        Functions.newJavaFunction(reg, new JavaFunction<>(
-                "mod",
-                new FunctionParameter[]{new FunctionParameter<>("i", Number.class, true), new FunctionParameter<>("m", Number.class, true)},
-                Number.class,
-                true) {
-                @Override
-                public Number[] executeSimple(Object[][] params) {
-                    Number d = (Number) params[0][0];
-                    Number m = (Number) params[1][0];
-                    return new Number[]{d.doubleValue() % m.doubleValue()};
-                }
+
+        reg.newJavaFunction("mod", Number.class, true)
+            .parameter("i", Number.class, true)
+            .parameter("m", Number.class, true)
+            .executeSingle(params -> {
+                Number i = (Number) params[0][0];
+                Number m = (Number) params[1][0];
+                return i.doubleValue() % m.doubleValue();
             })
             .name("Mod")
             .description("Returns the remainder of the division of the first number by the second one.")

src/main/java/io/github/syst3ms/skriptparser/structures/functions/Functions.java

@@ -127,10 +127,15 @@ public static boolean isValidFunctionName(String name) {
     }
 
 
+    /**
+     * Use {@link SkriptRegistration#newJavaFunction(String, Class, boolean)} instead
+     */
+    @Deprecated(forRemoval = true)
     public static FunctionDefinition newJavaFunction(SkriptRegistration registration, JavaFunction<?> function) {
         return new FunctionDefinition(registration, function);
     }
 
+    @Deprecated(forRemoval = true)
     public static class FunctionDefinition {
         private final SkriptRegistration registration;
         private final Documentation documentation = new Documentation();
@@ -186,4 +191,5 @@ public void register() {
             Functions.registerFunction(this.registration, this.function);
         }
     }
+
 }