From 3da9e9bc696934abece301ff5bdd0202fd6076eb Mon Sep 17 00:00:00 2001 From: yoyosource Date: Sat, 3 Sep 2022 17:15:21 +0200 Subject: [PATCH 01/28] Add linkage prototype --- src/de/steamwar/linkage/LinkageType.java | 40 ++++++++++++++ src/de/steamwar/linkage/Linked.java | 35 +++++++++++++ src/de/steamwar/linkage/LinkedInstance.java | 30 +++++++++++ src/de/steamwar/linkage/Writer.java | 27 ++++++++++ src/de/steamwar/linkage/plan/BuildPlan.java | 52 +++++++++++++++++++ .../steamwar/linkage/plan/FieldBuilder.java | 38 ++++++++++++++ src/de/steamwar/linkage/types/Command.java | 36 +++++++++++++ 7 files changed, 258 insertions(+) create mode 100644 src/de/steamwar/linkage/LinkageType.java create mode 100644 src/de/steamwar/linkage/Linked.java create mode 100644 src/de/steamwar/linkage/LinkedInstance.java create mode 100644 src/de/steamwar/linkage/Writer.java create mode 100644 src/de/steamwar/linkage/plan/BuildPlan.java create mode 100644 src/de/steamwar/linkage/plan/FieldBuilder.java create mode 100644 src/de/steamwar/linkage/types/Command.java diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java new file mode 100644 index 0000000..45baad6 --- /dev/null +++ b/src/de/steamwar/linkage/LinkageType.java @@ -0,0 +1,40 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +public interface LinkageType { + + // String name = new BufferedReader(new InputStreamReader(processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", "plugin.yml").openInputStream())) + // .lines() + // .filter(s -> s.startsWith("main: ")) + // .map(s -> s.substring(6)) + // .map(s -> s.substring(s.lastIndexOf('.'))) + // .findFirst() + // .orElse(null); + + default Class clazzType() { + return null; + } + default Class interfaceType() { + return null; + } + + String generateCode(String instance); +} diff --git a/src/de/steamwar/linkage/Linked.java b/src/de/steamwar/linkage/Linked.java new file mode 100644 index 0000000..fd091d3 --- /dev/null +++ b/src/de/steamwar/linkage/Linked.java @@ -0,0 +1,35 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.lang.annotation.*; + +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.TYPE}) +@Repeatable(Linked.Linkages.class) +public @interface Linked { + Class value(); + + @Retention(RetentionPolicy.SOURCE) + @Target({ElementType.TYPE}) + @interface Linkages { + @SuppressWarnings("unused") Linked[] value() default {}; + } +} diff --git a/src/de/steamwar/linkage/LinkedInstance.java b/src/de/steamwar/linkage/LinkedInstance.java new file mode 100644 index 0000000..9636ba5 --- /dev/null +++ b/src/de/steamwar/linkage/LinkedInstance.java @@ -0,0 +1,30 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.FIELD}) +public @interface LinkedInstance { +} diff --git a/src/de/steamwar/linkage/Writer.java b/src/de/steamwar/linkage/Writer.java new file mode 100644 index 0000000..235af89 --- /dev/null +++ b/src/de/steamwar/linkage/Writer.java @@ -0,0 +1,27 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.io.BufferedWriter; +import java.io.IOException; + +public interface Writer { + void write(BufferedWriter writer) throws IOException; +} diff --git a/src/de/steamwar/linkage/plan/BuildPlan.java b/src/de/steamwar/linkage/plan/BuildPlan.java new file mode 100644 index 0000000..a1d8795 --- /dev/null +++ b/src/de/steamwar/linkage/plan/BuildPlan.java @@ -0,0 +1,52 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.plan; + +import de.steamwar.linkage.Writer; +import lombok.RequiredArgsConstructor; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +@RequiredArgsConstructor +public class BuildPlan implements Writer { + + private final String packageName; + private final String className; + + private Map, FieldBuilder> fieldBuilderMap = new HashMap<>(); + + public void addField(FieldBuilder fieldBuilder) { + fieldBuilderMap.put(fieldBuilder.getType(), fieldBuilder); + } + + @Override + public void write(BufferedWriter writer) throws IOException { + writer.write("package " + packageName + ";\n"); + writer.write("\n"); + writer.write("public class " + className + " {\n"); + for (FieldBuilder fieldBuilder : fieldBuilderMap.values()) { + fieldBuilder.write(writer); + } + writer.write("}\n"); + } +} diff --git a/src/de/steamwar/linkage/plan/FieldBuilder.java b/src/de/steamwar/linkage/plan/FieldBuilder.java new file mode 100644 index 0000000..8b2379a --- /dev/null +++ b/src/de/steamwar/linkage/plan/FieldBuilder.java @@ -0,0 +1,38 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.plan; + +import de.steamwar.linkage.Writer; +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.io.BufferedWriter; +import java.io.IOException; + +@AllArgsConstructor +public class FieldBuilder implements Writer { + @Getter + private Class type; + + @Override + public void write(BufferedWriter writer) throws IOException { + writer.write(" private static " + type.getTypeName() + " " + type.getSimpleName() + ";"); + } +} diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/types/Command.java new file mode 100644 index 0000000..e4eba15 --- /dev/null +++ b/src/de/steamwar/linkage/types/Command.java @@ -0,0 +1,36 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.command.AbstractSWCommand; +import de.steamwar.linkage.LinkageType; + +public class Command implements LinkageType { + + @Override + public Class clazzType() { + return AbstractSWCommand.class; + } + + @Override + public String generateCode(String instance) { + return null; + } +} From f8e18ec79f8270d750b7ef51c0f07251537fc7b0 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Mon, 19 Sep 2022 09:01:05 +0200 Subject: [PATCH 02/28] Add MethodBuilder Add ParameterBuilder Add MinVersion --- src/de/steamwar/linkage/LinkageType.java | 4 +- src/de/steamwar/linkage/MinVersion.java | 27 +++++++++ src/de/steamwar/linkage/plan/BuildPlan.java | 25 +++++++- .../steamwar/linkage/plan/FieldBuilder.java | 6 +- .../steamwar/linkage/plan/MethodBuilder.java | 57 +++++++++++++++++++ .../linkage/plan/ParameterBuilder.java | 37 ++++++++++++ src/de/steamwar/linkage/types/Command.java | 4 +- 7 files changed, 155 insertions(+), 5 deletions(-) create mode 100644 src/de/steamwar/linkage/MinVersion.java create mode 100644 src/de/steamwar/linkage/plan/MethodBuilder.java create mode 100644 src/de/steamwar/linkage/plan/ParameterBuilder.java diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index 45baad6..98a4719 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -19,6 +19,8 @@ package de.steamwar.linkage; +import de.steamwar.linkage.plan.BuildPlan; + public interface LinkageType { // String name = new BufferedReader(new InputStreamReader(processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", "plugin.yml").openInputStream())) @@ -36,5 +38,5 @@ public interface LinkageType { return null; } - String generateCode(String instance); + void generateCode(BuildPlan buildPlan, String instance); } diff --git a/src/de/steamwar/linkage/MinVersion.java b/src/de/steamwar/linkage/MinVersion.java new file mode 100644 index 0000000..6e396d7 --- /dev/null +++ b/src/de/steamwar/linkage/MinVersion.java @@ -0,0 +1,27 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +/** + * Only applicable in Spigot context. Will be ignored in other contexts. + */ +public @interface MinVersion { + int value(); +} diff --git a/src/de/steamwar/linkage/plan/BuildPlan.java b/src/de/steamwar/linkage/plan/BuildPlan.java index a1d8795..97c9aee 100644 --- a/src/de/steamwar/linkage/plan/BuildPlan.java +++ b/src/de/steamwar/linkage/plan/BuildPlan.java @@ -34,9 +34,26 @@ public class BuildPlan implements Writer { private final String className; private Map, FieldBuilder> fieldBuilderMap = new HashMap<>(); + private Map methodBuilderMap = new HashMap<>(); public void addField(FieldBuilder fieldBuilder) { - fieldBuilderMap.put(fieldBuilder.getType(), fieldBuilder); + fieldBuilderMap.putIfAbsent(fieldBuilder.getType(), fieldBuilder); + } + + public boolean hasField(Class type) { + return fieldBuilderMap.containsKey(type); + } + + public String getFieldName(Class type) { + return fieldBuilderMap.get(type).getFieldName(); + } + + public void addMethod(MethodBuilder methodBuilder) { + methodBuilderMap.put(methodBuilder.getMethodName(), methodBuilder); + } + + public boolean hasMethod(String methodName) { + return methodBuilderMap.containsKey(methodName); } @Override @@ -47,6 +64,12 @@ public class BuildPlan implements Writer { for (FieldBuilder fieldBuilder : fieldBuilderMap.values()) { fieldBuilder.write(writer); } + if (!fieldBuilderMap.isEmpty() && !methodBuilderMap.isEmpty()) { + writer.write("\n"); + } + for (MethodBuilder methodBuilder : methodBuilderMap.values()) { + methodBuilder.write(writer); + } writer.write("}\n"); } } diff --git a/src/de/steamwar/linkage/plan/FieldBuilder.java b/src/de/steamwar/linkage/plan/FieldBuilder.java index 8b2379a..cb67b50 100644 --- a/src/de/steamwar/linkage/plan/FieldBuilder.java +++ b/src/de/steamwar/linkage/plan/FieldBuilder.java @@ -31,8 +31,12 @@ public class FieldBuilder implements Writer { @Getter private Class type; + public String getFieldName() { + return type.getSimpleName(); + } + @Override public void write(BufferedWriter writer) throws IOException { - writer.write(" private static " + type.getTypeName() + " " + type.getSimpleName() + ";"); + writer.write(" private static " + type.getTypeName() + " " + getFieldName() + ";\n"); } } diff --git a/src/de/steamwar/linkage/plan/MethodBuilder.java b/src/de/steamwar/linkage/plan/MethodBuilder.java new file mode 100644 index 0000000..e1a0244 --- /dev/null +++ b/src/de/steamwar/linkage/plan/MethodBuilder.java @@ -0,0 +1,57 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.plan; + +import de.steamwar.linkage.Writer; +import lombok.RequiredArgsConstructor; + +import java.io.BufferedWriter; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +@RequiredArgsConstructor +public class MethodBuilder implements Writer { + + private final String name; + private final Class returnType; + private List parameters = new ArrayList<>(); + private List lines = new ArrayList<>(); + + public String getMethodName() { + return name; + } + + @Override + public void write(BufferedWriter writer) throws IOException { + writer.write(" public static " + returnType.getTypeName() + " " + getMethodName() + "("); + for (int i = 0; i < parameters.size(); i++) { + parameters.get(i).write(writer); + if (i < parameters.size() - 1) { + writer.write(", "); + } + } + writer.write(") {"); + for (String line : lines) { + writer.write(" " + line); + } + writer.write(" }\n"); + } +} diff --git a/src/de/steamwar/linkage/plan/ParameterBuilder.java b/src/de/steamwar/linkage/plan/ParameterBuilder.java new file mode 100644 index 0000000..d856726 --- /dev/null +++ b/src/de/steamwar/linkage/plan/ParameterBuilder.java @@ -0,0 +1,37 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.plan; + +import de.steamwar.linkage.Writer; +import lombok.AllArgsConstructor; + +import java.io.BufferedWriter; +import java.io.IOException; + +@AllArgsConstructor +public class ParameterBuilder implements Writer { + private Class type; + private String name; + + @Override + public void write(BufferedWriter writer) throws IOException { + writer.write(type.getTypeName() + " " + name); + } +} diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/types/Command.java index e4eba15..c7ea544 100644 --- a/src/de/steamwar/linkage/types/Command.java +++ b/src/de/steamwar/linkage/types/Command.java @@ -21,6 +21,7 @@ package de.steamwar.linkage.types; import de.steamwar.command.AbstractSWCommand; import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; public class Command implements LinkageType { @@ -30,7 +31,6 @@ public class Command implements LinkageType { } @Override - public String generateCode(String instance) { - return null; + public void generateCode(BuildPlan buildPlan, String instance) { } } From f152d790ce0698c4b0175e34231dc7a2af5f401e Mon Sep 17 00:00:00 2001 From: yoyosource Date: Mon, 19 Sep 2022 09:13:07 +0200 Subject: [PATCH 03/28] Add some api and linkage types Add LinkageProcessor --- src/de/steamwar/linkage/LinkageProcessor.java | 71 +++++++++++++++++++ src/de/steamwar/linkage/LinkageType.java | 11 +-- src/de/steamwar/linkage/api/Disable.java | 24 +++++++ src/de/steamwar/linkage/api/Enable.java | 24 +++++++ .../steamwar/linkage/plan/MethodBuilder.java | 8 +++ src/de/steamwar/linkage/types/Command.java | 3 +- .../steamwar/linkage/types/DisableLink.java | 39 ++++++++++ src/de/steamwar/linkage/types/EnableLink.java | 38 ++++++++++ src/de/steamwar/linkage/types/Plain.java | 32 +++++++++ 9 files changed, 240 insertions(+), 10 deletions(-) create mode 100644 src/de/steamwar/linkage/LinkageProcessor.java create mode 100644 src/de/steamwar/linkage/api/Disable.java create mode 100644 src/de/steamwar/linkage/api/Enable.java create mode 100644 src/de/steamwar/linkage/types/DisableLink.java create mode 100644 src/de/steamwar/linkage/types/EnableLink.java create mode 100644 src/de/steamwar/linkage/types/Plain.java diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java new file mode 100644 index 0000000..b0e8303 --- /dev/null +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -0,0 +1,71 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import lombok.SneakyThrows; + +import javax.annotation.processing.*; +import javax.lang.model.SourceVersion; +import javax.lang.model.element.TypeElement; +import javax.tools.Diagnostic; +import javax.tools.StandardLocation; +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.io.Writer; +import java.util.Set; + +@SupportedAnnotationTypes("de.steamwar.linkage.Linked") +public class LinkageProcessor extends AbstractProcessor { + + private Messager messager; + private Writer writer; + private boolean processed = false; + + @Override + public SourceVersion getSupportedSourceVersion() { + return SourceVersion.latestSupported(); + } + + @SneakyThrows + @Override + public synchronized void init(ProcessingEnvironment processingEnv) { + super.init(processingEnv); + + String name = new BufferedReader(new InputStreamReader(processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", "plugin.yml").openInputStream())) + .lines() + .filter(s -> s.startsWith("name: ")) + .map(s -> s.substring(6)) + .map(String::toLowerCase) + .findFirst() + .orElse(null); + if (name == null) { + messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin name in plugin.yml"); + return; + } + + writer = processingEnv.getFiler().createSourceFile("de.steamwar." + name + ".linkage.LinkageUtils").openWriter(); + messager = processingEnv.getMessager(); + } + + @Override + public boolean process(Set annotations, RoundEnvironment roundEnv) { + return false; + } +} diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index 98a4719..f71ca2f 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -20,17 +20,10 @@ package de.steamwar.linkage; import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; public interface LinkageType { - // String name = new BufferedReader(new InputStreamReader(processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", "plugin.yml").openInputStream())) - // .lines() - // .filter(s -> s.startsWith("main: ")) - // .map(s -> s.substring(6)) - // .map(s -> s.substring(s.lastIndexOf('.'))) - // .findFirst() - // .orElse(null); - default Class clazzType() { return null; } @@ -38,5 +31,5 @@ public interface LinkageType { return null; } - void generateCode(BuildPlan buildPlan, String instance); + void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance); } diff --git a/src/de/steamwar/linkage/api/Disable.java b/src/de/steamwar/linkage/api/Disable.java new file mode 100644 index 0000000..f09b846 --- /dev/null +++ b/src/de/steamwar/linkage/api/Disable.java @@ -0,0 +1,24 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.api; + +public interface Disable { + void disable(); +} diff --git a/src/de/steamwar/linkage/api/Enable.java b/src/de/steamwar/linkage/api/Enable.java new file mode 100644 index 0000000..5d516cd --- /dev/null +++ b/src/de/steamwar/linkage/api/Enable.java @@ -0,0 +1,24 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.api; + +public interface Enable { + void enable(); +} diff --git a/src/de/steamwar/linkage/plan/MethodBuilder.java b/src/de/steamwar/linkage/plan/MethodBuilder.java index e1a0244..68ae453 100644 --- a/src/de/steamwar/linkage/plan/MethodBuilder.java +++ b/src/de/steamwar/linkage/plan/MethodBuilder.java @@ -35,6 +35,14 @@ public class MethodBuilder implements Writer { private List parameters = new ArrayList<>(); private List lines = new ArrayList<>(); + public void addParameter(ParameterBuilder parameterBuilder) { + parameters.add(parameterBuilder); + } + + public void addLine(String line) { + lines.add(line); + } + public String getMethodName() { return name; } diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/types/Command.java index c7ea544..31b1491 100644 --- a/src/de/steamwar/linkage/types/Command.java +++ b/src/de/steamwar/linkage/types/Command.java @@ -22,6 +22,7 @@ package de.steamwar.linkage.types; import de.steamwar.command.AbstractSWCommand; import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; public class Command implements LinkageType { @@ -31,6 +32,6 @@ public class Command implements LinkageType { } @Override - public void generateCode(BuildPlan buildPlan, String instance) { + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { } } diff --git a/src/de/steamwar/linkage/types/DisableLink.java b/src/de/steamwar/linkage/types/DisableLink.java new file mode 100644 index 0000000..15175a7 --- /dev/null +++ b/src/de/steamwar/linkage/types/DisableLink.java @@ -0,0 +1,39 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.api.Disable; +import de.steamwar.linkage.api.Enable; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +public class DisableLink implements LinkageType { + + @Override + public Class interfaceType() { + return Disable.class; + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + linkageTypeMethod.addLine(instance + ".disable();"); + } +} diff --git a/src/de/steamwar/linkage/types/EnableLink.java b/src/de/steamwar/linkage/types/EnableLink.java new file mode 100644 index 0000000..400c96d --- /dev/null +++ b/src/de/steamwar/linkage/types/EnableLink.java @@ -0,0 +1,38 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.api.Enable; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +public class EnableLink implements LinkageType { + + @Override + public Class interfaceType() { + return Enable.class; + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + linkageTypeMethod.addLine(instance + ".enable();"); + } +} diff --git a/src/de/steamwar/linkage/types/Plain.java b/src/de/steamwar/linkage/types/Plain.java new file mode 100644 index 0000000..d25fa48 --- /dev/null +++ b/src/de/steamwar/linkage/types/Plain.java @@ -0,0 +1,32 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +public class Plain implements LinkageType { + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + linkageTypeMethod.addLine(instance + ";"); + } +} From 1c7e9ad03933b959d6e50e487d761356a81f7e39 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 11:52:09 +0200 Subject: [PATCH 04/28] Update linkage api --- build.gradle | 10 + src/de/steamwar/linkage/LinkageProcessor.java | 195 ++++++++++++++++-- src/de/steamwar/linkage/LinkageType.java | 20 +- src/de/steamwar/linkage/Linked.java | 2 +- src/de/steamwar/linkage/plan/BuildPlan.java | 40 +++- .../steamwar/linkage/plan/FieldBuilder.java | 10 +- .../steamwar/linkage/plan/MethodBuilder.java | 11 +- .../linkage/plan/ParameterBuilder.java | 4 +- src/de/steamwar/linkage/types/Command.java | 10 +- .../steamwar/linkage/types/DisableLink.java | 11 +- src/de/steamwar/linkage/types/EnableLink.java | 9 +- .../steamwar/linkage/types/ListenerLink.java | 114 ++++++++++ src/de/steamwar/linkage/types/Plain.java | 4 +- .../linkage/types/UnlinkListener.java | 51 +++++ 14 files changed, 435 insertions(+), 56 deletions(-) create mode 100644 src/de/steamwar/linkage/types/ListenerLink.java create mode 100644 src/de/steamwar/linkage/types/UnlinkListener.java diff --git a/build.gradle b/build.gradle index 41ba86c..4006496 100644 --- a/build.gradle +++ b/build.gradle @@ -83,6 +83,16 @@ dependencies { testImplementation 'org.hamcrest:hamcrest:2.2' } +task buildResources { + doLast { + File to = new File("${buildDir}/classes/java/main/META-INF/services/javax.annotation.processing.Processor") + to.parentFile.mkdirs() + to.createNewFile() + to.append("de.steamwar.linkage.LinkageProcessor\n") + } +} +classes.finalizedBy(buildResources) + task buildProject { description 'Build this project' group "Steamwar" diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index b0e8303..ee18e5a 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -19,21 +19,36 @@ package de.steamwar.linkage; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.FieldBuilder; +import de.steamwar.linkage.plan.MethodBuilder; +import de.steamwar.linkage.plan.ParameterBuilder; +import de.steamwar.linkage.types.ListenerLink; +import lombok.Getter; import lombok.SneakyThrows; import javax.annotation.processing.*; import javax.lang.model.SourceVersion; -import javax.lang.model.element.TypeElement; +import javax.lang.model.element.*; +import javax.lang.model.type.DeclaredType; +import javax.lang.model.type.TypeMirror; import javax.tools.Diagnostic; -import javax.tools.StandardLocation; -import java.io.BufferedReader; -import java.io.InputStreamReader; +import java.io.BufferedWriter; +import java.io.File; import java.io.Writer; -import java.util.Set; +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.Stream; -@SupportedAnnotationTypes("de.steamwar.linkage.Linked") +@SupportedAnnotationTypes({"de.steamwar.linkage.Linked", "de.steamwar.linkage.Linked$Linkages"}) public class LinkageProcessor extends AbstractProcessor { + @Getter + private static LinkageType.Context context; + + private String packageName; + private String className; + private Messager messager; private Writer writer; private boolean processed = false; @@ -48,24 +63,168 @@ public class LinkageProcessor extends AbstractProcessor { public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); - String name = new BufferedReader(new InputStreamReader(processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", "plugin.yml").openInputStream())) - .lines() - .filter(s -> s.startsWith("name: ")) - .map(s -> s.substring(6)) - .map(String::toLowerCase) - .findFirst() - .orElse(null); - if (name == null) { - messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin name in plugin.yml"); - return; - } + String name = new File(System.getProperty("user.dir")).getName(); + if (name.contains(".")) name = name.substring(0, name.indexOf('.')); + name = name.toLowerCase(); + context = name.contains("bungee") ? LinkageType.Context.BUNGEE : LinkageType.Context.SPIGOT; writer = processingEnv.getFiler().createSourceFile("de.steamwar." + name + ".linkage.LinkageUtils").openWriter(); messager = processingEnv.getMessager(); + + packageName = "de.steamwar." + name + ".linkage"; + className = "LinkageUtils"; } + @SneakyThrows @Override public boolean process(Set annotations, RoundEnvironment roundEnv) { - return false; + messager.printMessage(Diagnostic.Kind.NOTE, "Processing linkage types"); + if (processed) return false; + processed = true; + BuildPlan buildPlan = new BuildPlan(packageName, className); + buildPlan.addImport("java.util.Set"); + buildPlan.addImport("java.lang.Class"); + buildPlan.addImport("de.steamwar.linkage.LinkageType"); + buildPlan.addImport("java.util.HashSet"); + buildPlan.addField(new FieldBuilder("Set>", "enabled", "new HashSet<>()")); + + MethodBuilder runMethod = new MethodBuilder("run", "void"); + buildPlan.addMethod(runMethod); + runMethod.addParameter(new ParameterBuilder("Class", "type")); + runMethod.addLine("if (!enabled.add(type)) return;"); + Set> alreadyGenerated = new HashSet<>(); + + Set elements = roundEnv.getElementsAnnotatedWith(Linked.class); + elements.addAll((Set) roundEnv.getElementsAnnotatedWith(Linked.Linkages.class)); + + Map neededFields = new HashMap<>(); + for (Element element : elements) { + if (element.getKind() != ElementKind.CLASS) { + continue; + } + TypeElement typeElement = (TypeElement) element; + Linked[] linkeds = element.getAnnotationsByType(Linked.class); + if (linkeds.length == 0) { + continue; + } + + if (linkeds.length > 1) { + neededFields.put(typeElement.getQualifiedName().toString(), typeElement); + } + + List variableElements = typeElement.getEnclosedElements().stream().filter(e -> e.getKind() == ElementKind.FIELD).map(VariableElement.class::cast).filter(e -> { + return e.getAnnotation(LinkedInstance.class) != null; + }).collect(Collectors.toList()); + if (variableElements.isEmpty()) { + continue; + } + + for (VariableElement variableElement : variableElements) { + if (!variableElement.getModifiers().contains(Modifier.PUBLIC)) { + messager.printMessage(Diagnostic.Kind.ERROR, "Field " + variableElement.getSimpleName() + " must be public", variableElement); + continue; + } + if (variableElement.getModifiers().contains(Modifier.STATIC)) { + messager.printMessage(Diagnostic.Kind.ERROR, "Field " + variableElement.getSimpleName() + " must be non static", variableElement); + continue; + } + if (variableElement.getModifiers().contains(Modifier.FINAL)) { + messager.printMessage(Diagnostic.Kind.ERROR, "Field " + variableElement.getSimpleName() + " must be non final", variableElement); + continue; + } + neededFields.put(typeElement.getQualifiedName().toString(), typeElement); + TypeElement fieldType = (TypeElement) ((DeclaredType) variableElement.asType()).asElement(); + neededFields.put(fieldType.getQualifiedName().toString(), fieldType); + + buildPlan.addStaticLine(getElement(typeElement, neededFields) + "." + variableElement.getSimpleName().toString() + " = " + getElement((TypeElement) ((DeclaredType) variableElement.asType()).asElement(), neededFields) + ";"); + } + } + neededFields.forEach((s, typeElement) -> { + buildPlan.addImport(typeElement.getQualifiedName().toString()); + buildPlan.addField(new FieldBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString())); + + MethodBuilder initializer = new MethodBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString()); + initializer.addLine("if (" + typeElement.getSimpleName().toString() + " == null) {"); + initializer.addLine(" " + typeElement.getSimpleName().toString() + " = new " + typeElement.getSimpleName().toString() + "();"); + initializer.addLine("}"); + initializer.addLine("return " + typeElement.getSimpleName().toString() + ";"); + buildPlan.addMethod(initializer); + }); + + Map, MethodBuilder> methods = new HashMap<>(); + for (Element element : elements) { + if (element.getKind() != ElementKind.CLASS) { + continue; + } + TypeElement typeElement = (TypeElement) element; + MinVersion minVersion = element.getAnnotation(MinVersion.class); + + System.out.println("Found element: " + typeElement.getQualifiedName().toString()); + element.getAnnotationMirrors().forEach(annotationMirror -> { + if (!annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("Linked")) return; + Class clazz = annotationMirror.getElementValues().entrySet().stream() + .filter(entry -> entry.getKey().getSimpleName().toString().equals("value")) + .map(Map.Entry::getValue) + .map(AnnotationValue::getValue) + .map(Object::toString) + .map(s -> { + try { + return Class.forName(s); + } catch (ClassNotFoundException e) { + return null; + } + }) + .findFirst() + .orElse(null); + if (clazz == null) { + messager.printMessage(Diagnostic.Kind.ERROR, "No class specified", element); + return; + } + + LinkageType type = null; + try { + type = (LinkageType) clazz.getDeclaredConstructor().newInstance(); + } catch (Exception e) { + messager.printMessage(Diagnostic.Kind.ERROR, "Could not instantiate class", element); + return; + } + + if (!type.requirements(typeElement.getSuperclass().toString(), typeElement.getInterfaces().stream().map(TypeMirror::toString).collect(Collectors.toSet()))) { + return; + } + + if (alreadyGenerated.add((Class) clazz)) { + runMethod.addLine("if (type == " + clazz.getTypeName() + ".class) {"); + runMethod.addLine(" run" + clazz.getSimpleName() + "();"); + runMethod.addLine("}"); + } + + MethodBuilder method = methods.computeIfAbsent(clazz, t -> { + MethodBuilder methodBuilder = new MethodBuilder("run" + t.getSimpleName(), "void"); + methodBuilder.setPrivate(true); + buildPlan.addMethod(methodBuilder); + return methodBuilder; + }); + if (context == LinkageType.Context.SPIGOT && minVersion != null) { + method.addLine("if (de.steamwar.core.Core.getVersion() >= " + minVersion.value() + ") {"); + } + type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); + if (context == LinkageType.Context.SPIGOT && minVersion != null) { + method.addLine("}"); + } + }); + } + + BufferedWriter writer = new BufferedWriter(this.writer); + buildPlan.write(writer); + writer.close(); + return true; + } + + private String getElement(TypeElement typeElement, Map neededFields) { + if (neededFields.containsKey(typeElement.getQualifiedName().toString())) { + return typeElement.getSimpleName().toString() + "()"; + } + return "new " + typeElement.getQualifiedName().toString() + "()"; } } diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index f71ca2f..9308905 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -22,14 +22,22 @@ package de.steamwar.linkage; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; +import javax.lang.model.element.TypeElement; +import java.util.OptionalInt; +import java.util.Set; + public interface LinkageType { - default Class clazzType() { - return null; - } - default Class interfaceType() { - return null; + Context context = LinkageProcessor.getContext(); + + enum Context { + BUNGEE, + SPIGOT } - void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance); + default boolean requirements(String superClass, Set interfaces) { + return true; + } + + void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement); } diff --git a/src/de/steamwar/linkage/Linked.java b/src/de/steamwar/linkage/Linked.java index fd091d3..b352982 100644 --- a/src/de/steamwar/linkage/Linked.java +++ b/src/de/steamwar/linkage/Linked.java @@ -25,7 +25,7 @@ import java.lang.annotation.*; @Target({ElementType.TYPE}) @Repeatable(Linked.Linkages.class) public @interface Linked { - Class value(); + Class value(); @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE}) diff --git a/src/de/steamwar/linkage/plan/BuildPlan.java b/src/de/steamwar/linkage/plan/BuildPlan.java index 97c9aee..d53eeb8 100644 --- a/src/de/steamwar/linkage/plan/BuildPlan.java +++ b/src/de/steamwar/linkage/plan/BuildPlan.java @@ -24,27 +24,32 @@ import lombok.RequiredArgsConstructor; import java.io.BufferedWriter; import java.io.IOException; -import java.util.HashMap; -import java.util.Map; +import java.util.*; @RequiredArgsConstructor public class BuildPlan implements Writer { private final String packageName; + private Set imports = new HashSet<>(); private final String className; - private Map, FieldBuilder> fieldBuilderMap = new HashMap<>(); + private Map fieldBuilderMap = new HashMap<>(); private Map methodBuilderMap = new HashMap<>(); + private List staticLines = new ArrayList<>(); + + public void addImport(String importName) { + imports.add(importName); + } public void addField(FieldBuilder fieldBuilder) { fieldBuilderMap.putIfAbsent(fieldBuilder.getType(), fieldBuilder); } - public boolean hasField(Class type) { + public boolean hasField(String type) { return fieldBuilderMap.containsKey(type); } - public String getFieldName(Class type) { + public String getFieldName(String type) { return fieldBuilderMap.get(type).getFieldName(); } @@ -56,19 +61,38 @@ public class BuildPlan implements Writer { return methodBuilderMap.containsKey(methodName); } + public void addStaticLine(String line) { + staticLines.add(line); + } + @Override public void write(BufferedWriter writer) throws IOException { writer.write("package " + packageName + ";\n"); + if (!imports.isEmpty()) { + writer.write("\n"); + for (String importName : imports) { + writer.write("import " + importName + ";\n"); + } + } writer.write("\n"); writer.write("public class " + className + " {\n"); - for (FieldBuilder fieldBuilder : fieldBuilderMap.values()) { - fieldBuilder.write(writer); + if (!fieldBuilderMap.isEmpty()) { + for (FieldBuilder fieldBuilder : fieldBuilderMap.values()) { + fieldBuilder.write(writer); + } + writer.write("\n"); } - if (!fieldBuilderMap.isEmpty() && !methodBuilderMap.isEmpty()) { + if (!staticLines.isEmpty()) { + writer.write(" static {\n"); + for (String line : staticLines) { + writer.write(" " + line + "\n"); + } + writer.write(" }\n"); writer.write("\n"); } for (MethodBuilder methodBuilder : methodBuilderMap.values()) { methodBuilder.write(writer); + writer.write("\n"); } writer.write("}\n"); } diff --git a/src/de/steamwar/linkage/plan/FieldBuilder.java b/src/de/steamwar/linkage/plan/FieldBuilder.java index cb67b50..e45bdb2 100644 --- a/src/de/steamwar/linkage/plan/FieldBuilder.java +++ b/src/de/steamwar/linkage/plan/FieldBuilder.java @@ -22,21 +22,25 @@ package de.steamwar.linkage.plan; import de.steamwar.linkage.Writer; import lombok.AllArgsConstructor; import lombok.Getter; +import lombok.RequiredArgsConstructor; import java.io.BufferedWriter; import java.io.IOException; +@RequiredArgsConstructor @AllArgsConstructor public class FieldBuilder implements Writer { @Getter - private Class type; + private final String type; + private final String name; + private String initializer; public String getFieldName() { - return type.getSimpleName(); + return name; } @Override public void write(BufferedWriter writer) throws IOException { - writer.write(" private static " + type.getTypeName() + " " + getFieldName() + ";\n"); + writer.write(" private static " + type + " " + getFieldName() + (initializer == null ? "" : " = " + initializer) + ";\n"); } } diff --git a/src/de/steamwar/linkage/plan/MethodBuilder.java b/src/de/steamwar/linkage/plan/MethodBuilder.java index 68ae453..a1d4a05 100644 --- a/src/de/steamwar/linkage/plan/MethodBuilder.java +++ b/src/de/steamwar/linkage/plan/MethodBuilder.java @@ -31,9 +31,10 @@ import java.util.List; public class MethodBuilder implements Writer { private final String name; - private final Class returnType; + private final String returnType; private List parameters = new ArrayList<>(); private List lines = new ArrayList<>(); + private boolean isPrivate = false; public void addParameter(ParameterBuilder parameterBuilder) { parameters.add(parameterBuilder); @@ -47,9 +48,13 @@ public class MethodBuilder implements Writer { return name; } + public void setPrivate(boolean isPrivate) { + this.isPrivate = isPrivate; + } + @Override public void write(BufferedWriter writer) throws IOException { - writer.write(" public static " + returnType.getTypeName() + " " + getMethodName() + "("); + writer.write(" " + (isPrivate ? "private" : "public") + " static " + returnType + " " + getMethodName() + "("); for (int i = 0; i < parameters.size(); i++) { parameters.get(i).write(writer); if (i < parameters.size() - 1) { @@ -58,8 +63,10 @@ public class MethodBuilder implements Writer { } writer.write(") {"); for (String line : lines) { + writer.write("\n"); writer.write(" " + line); } + writer.write("\n"); writer.write(" }\n"); } } diff --git a/src/de/steamwar/linkage/plan/ParameterBuilder.java b/src/de/steamwar/linkage/plan/ParameterBuilder.java index d856726..192b8a2 100644 --- a/src/de/steamwar/linkage/plan/ParameterBuilder.java +++ b/src/de/steamwar/linkage/plan/ParameterBuilder.java @@ -27,11 +27,11 @@ import java.io.IOException; @AllArgsConstructor public class ParameterBuilder implements Writer { - private Class type; + private String type; private String name; @Override public void write(BufferedWriter writer) throws IOException { - writer.write(type.getTypeName() + " " + name); + writer.write(type + " " + name); } } diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/types/Command.java index 31b1491..fc522da 100644 --- a/src/de/steamwar/linkage/types/Command.java +++ b/src/de/steamwar/linkage/types/Command.java @@ -19,19 +19,15 @@ package de.steamwar.linkage.types; -import de.steamwar.command.AbstractSWCommand; import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; +import javax.lang.model.element.TypeElement; + public class Command implements LinkageType { @Override - public Class clazzType() { - return AbstractSWCommand.class; - } - - @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { } } diff --git a/src/de/steamwar/linkage/types/DisableLink.java b/src/de/steamwar/linkage/types/DisableLink.java index 15175a7..c3cc54a 100644 --- a/src/de/steamwar/linkage/types/DisableLink.java +++ b/src/de/steamwar/linkage/types/DisableLink.java @@ -20,20 +20,21 @@ package de.steamwar.linkage.types; import de.steamwar.linkage.LinkageType; -import de.steamwar.linkage.api.Disable; -import de.steamwar.linkage.api.Enable; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; +import javax.lang.model.element.TypeElement; +import java.util.Set; + public class DisableLink implements LinkageType { @Override - public Class interfaceType() { - return Disable.class; + public boolean requirements(String superClass, Set interfaces) { + return interfaces.contains("de.steamwar.linkage.api.Disable"); } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { linkageTypeMethod.addLine(instance + ".disable();"); } } diff --git a/src/de/steamwar/linkage/types/EnableLink.java b/src/de/steamwar/linkage/types/EnableLink.java index 400c96d..4b42f86 100644 --- a/src/de/steamwar/linkage/types/EnableLink.java +++ b/src/de/steamwar/linkage/types/EnableLink.java @@ -24,15 +24,18 @@ import de.steamwar.linkage.api.Enable; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; +import javax.lang.model.element.TypeElement; +import java.util.Set; + public class EnableLink implements LinkageType { @Override - public Class interfaceType() { - return Enable.class; + public boolean requirements(String superClass, Set interfaces) { + return interfaces.contains("de.steamwar.linkage.api.Enable"); } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { linkageTypeMethod.addLine(instance + ".enable();"); } } diff --git a/src/de/steamwar/linkage/types/ListenerLink.java b/src/de/steamwar/linkage/types/ListenerLink.java new file mode 100644 index 0000000..350c944 --- /dev/null +++ b/src/de/steamwar/linkage/types/ListenerLink.java @@ -0,0 +1,114 @@ +/* + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.FieldBuilder; +import de.steamwar.linkage.plan.MethodBuilder; +import de.steamwar.linkage.plan.ParameterBuilder; +import lombok.SneakyThrows; + +import javax.lang.model.element.*; +import javax.lang.model.type.DeclaredType; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class ListenerLink implements LinkageType { + + @Override + public boolean requirements(String superClass, Set interfaces) { + if (context == Context.BUNGEE) { + return interfaces.contains("net.md_5.bungee.api.plugin.Listener"); + } else { + return interfaces.contains("org.bukkit.event.Listener"); + } + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + if (context == Context.BUNGEE) { + buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); + buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); + linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(BungeeCore.get(), " + instance + ");"); + } else { + Map eventClasses = new HashMap<>(); + Map eventMethods = new HashMap<>(); + + typeElement.getEnclosedElements().stream().filter(e -> e.getKind() == ElementKind.METHOD).map(ExecutableElement.class::cast).filter(e -> { + return e.getAnnotationMirrors().stream().anyMatch(annotationMirror -> { + return annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler"); + }); + }).forEach(e -> { + TypeElement current = ((TypeElement)((DeclaredType) e.getParameters().get(0).asType()).asElement()); + eventClasses.put(current.getQualifiedName().toString(), current); + eventMethods.put(current, e); + }); + + eventClasses.forEach((s, eventType) -> { + if (buildPlan.hasMethod(s)) return; + buildPlan.addImport("org.bukkit.event.HandlerList"); + buildPlan.addImport("org.bukkit.event.Listener"); + buildPlan.addImport("java.util.function.Consumer"); + buildPlan.addImport("org.bukkit.event.EventPriority"); + buildPlan.addImport("org.bukkit.plugin.RegisteredListener"); + buildPlan.addImport("org.bukkit.plugin.EventExecutor"); + buildPlan.addImport("de.steamwar.core.Core"); + buildPlan.addImport(s); + buildPlan.addField(new FieldBuilder("HandlerList", "handlerList" + eventType.getSimpleName())); + MethodBuilder methodBuilder = new MethodBuilder(eventType.getSimpleName().toString(), "void"); + methodBuilder.addParameter(new ParameterBuilder("Listener", "listener")); + methodBuilder.addParameter(new ParameterBuilder("Consumer<" + eventType.getSimpleName() + ">", "consumer")); + methodBuilder.addParameter(new ParameterBuilder("EventPriority", "eventPriority")); + methodBuilder.addParameter(new ParameterBuilder("boolean", "ignoreCancelled")); + methodBuilder.setPrivate(true); + methodBuilder.addLine("EventExecutor eventExecutor = (l, event) -> {"); + methodBuilder.addLine(" if (event instanceof " + eventType.getSimpleName() + ") {"); + methodBuilder.addLine(" consumer.accept((" + eventType.getSimpleName() + ") event);"); + methodBuilder.addLine(" }"); + methodBuilder.addLine("};"); + methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, Core.getInstance(), ignoreCancelled));"); + buildPlan.addMethod(methodBuilder); + linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + s + ".getHandlerList();"); + }); + + buildPlan.addImport(typeElement.getQualifiedName().toString()); + String localInstance = "local" + typeElement.getSimpleName().toString(); + linkageTypeMethod.addLine(typeElement.getSimpleName() + " " + localInstance + " = " + instance + ";"); + eventMethods.forEach((type, executableElement) -> { + AnnotationMirror eventHandler = executableElement.getAnnotationMirrors().stream().filter(annotationMirror -> annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler")).findFirst().orElse(null); + if (eventHandler == null) { + return; + } + String priority = "NORMAL"; + String ignoreCancelled = "false"; + for (Map.Entry entry : eventHandler.getElementValues().entrySet()) { + if (entry.getKey().getSimpleName().toString().equals("priority")) { + priority = entry.getValue().getValue().toString(); + } else if (entry.getKey().getSimpleName().toString().equals("ignoreCancelled")) { + ignoreCancelled = entry.getValue().getValue().toString(); + } + } + linkageTypeMethod.addLine(type.getSimpleName().toString() + "(" + localInstance + ", " + localInstance + "::" + executableElement.getSimpleName().toString() + ", EventPriority." + priority + ", " + ignoreCancelled + ");"); + }); + } + } +} diff --git a/src/de/steamwar/linkage/types/Plain.java b/src/de/steamwar/linkage/types/Plain.java index d25fa48..1890521 100644 --- a/src/de/steamwar/linkage/types/Plain.java +++ b/src/de/steamwar/linkage/types/Plain.java @@ -23,10 +23,12 @@ import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; +import javax.lang.model.element.TypeElement; + public class Plain implements LinkageType { @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance) { + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { linkageTypeMethod.addLine(instance + ";"); } } diff --git a/src/de/steamwar/linkage/types/UnlinkListener.java b/src/de/steamwar/linkage/types/UnlinkListener.java new file mode 100644 index 0000000..73966a7 --- /dev/null +++ b/src/de/steamwar/linkage/types/UnlinkListener.java @@ -0,0 +1,51 @@ +/* + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +import javax.lang.model.element.TypeElement; +import java.util.Set; + +public class UnlinkListener implements LinkageType { + + @Override + public boolean requirements(String superClass, Set interfaces) { + if (context == Context.BUNGEE) { + return interfaces.contains("net.md_5.bungee.api.plugin.Listener"); + } else { + return interfaces.contains("org.bukkit.event.Listener"); + } + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + if (context == Context.BUNGEE) { + buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); + buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); + linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(" + instance + ");"); + } else { + buildPlan.addImport("org.bukkit.event.HandlerList"); + linkageTypeMethod.addLine("HandlerList.unregisterAll(" + instance + ");"); + } + } +} From 05f5d3f7b3595a6f9afa98a17d6f6112bf8ca5fc Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 12:19:45 +0200 Subject: [PATCH 05/28] Fix LinkageProcessor --- src/de/steamwar/linkage/LinkageProcessor.java | 140 ++++++++++-------- 1 file changed, 80 insertions(+), 60 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index ee18e5a..3a7c3d2 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -23,11 +23,13 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.FieldBuilder; import de.steamwar.linkage.plan.MethodBuilder; import de.steamwar.linkage.plan.ParameterBuilder; -import de.steamwar.linkage.types.ListenerLink; import lombok.Getter; import lombok.SneakyThrows; -import javax.annotation.processing.*; +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.type.DeclaredType; @@ -40,17 +42,16 @@ import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; -@SupportedAnnotationTypes({"de.steamwar.linkage.Linked", "de.steamwar.linkage.Linked$Linkages"}) public class LinkageProcessor extends AbstractProcessor { @Getter private static LinkageType.Context context; + private String name; private String packageName; private String className; private Messager messager; - private Writer writer; private boolean processed = false; @Override @@ -58,6 +59,13 @@ public class LinkageProcessor extends AbstractProcessor { return SourceVersion.latestSupported(); } + @Override + public Set getSupportedAnnotationTypes() { + return Stream.of(Linked.class, Linked.Linkages.class) + .map(Class::getCanonicalName) + .collect(Collectors.toSet()); + } + @SneakyThrows @Override public synchronized void init(ProcessingEnvironment processingEnv) { @@ -68,9 +76,9 @@ public class LinkageProcessor extends AbstractProcessor { name = name.toLowerCase(); context = name.contains("bungee") ? LinkageType.Context.BUNGEE : LinkageType.Context.SPIGOT; - writer = processingEnv.getFiler().createSourceFile("de.steamwar." + name + ".linkage.LinkageUtils").openWriter(); messager = processingEnv.getMessager(); + this.name = name; packageName = "de.steamwar." + name + ".linkage"; className = "LinkageUtils"; } @@ -78,9 +86,11 @@ public class LinkageProcessor extends AbstractProcessor { @SneakyThrows @Override public boolean process(Set annotations, RoundEnvironment roundEnv) { - messager.printMessage(Diagnostic.Kind.NOTE, "Processing linkage types"); if (processed) return false; processed = true; + + Writer writer = processingEnv.getFiler().createSourceFile("de.steamwar." + name + ".linkage.LinkageUtils").openWriter(); + BuildPlan buildPlan = new BuildPlan(packageName, className); buildPlan.addImport("java.util.Set"); buildPlan.addImport("java.lang.Class"); @@ -160,64 +170,74 @@ public class LinkageProcessor extends AbstractProcessor { MinVersion minVersion = element.getAnnotation(MinVersion.class); System.out.println("Found element: " + typeElement.getQualifiedName().toString()); - element.getAnnotationMirrors().forEach(annotationMirror -> { - if (!annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("Linked")) return; - Class clazz = annotationMirror.getElementValues().entrySet().stream() - .filter(entry -> entry.getKey().getSimpleName().toString().equals("value")) - .map(Map.Entry::getValue) - .map(AnnotationValue::getValue) - .map(Object::toString) - .map(s -> { - try { - return Class.forName(s); - } catch (ClassNotFoundException e) { - return null; - } - }) - .findFirst() - .orElse(null); - if (clazz == null) { - messager.printMessage(Diagnostic.Kind.ERROR, "No class specified", element); - return; - } + element.getAnnotationMirrors().stream() + .filter(annotationMirror -> { + String annotationNames = annotationMirror.getAnnotationType().asElement().getSimpleName().toString(); + return annotationNames.equals("Linked") || annotationNames.equals("Linkages"); + }) + .flatMap(annotationMirror -> annotationMirror.getElementValues().values().stream()) + .map(AnnotationValue::getValue) + .flatMap(o -> { + if (o instanceof List) { + return ((List) o).stream() + .map(AnnotationMirror.class::cast) + .map(AnnotationMirror::getElementValues) + .map(Map::values) + .flatMap(Collection::stream) + .map(AnnotationValue::getValue); + } + return Stream.of(o); + }) + .map(Object::toString) + .map(s -> { + try { + return Class.forName(s); + } catch (Exception e) { + messager.printMessage(Diagnostic.Kind.ERROR, "Could not find class " + s, element); + return null; + } + }) + .filter(Objects::nonNull) + .map(clazz -> { + try { + return (LinkageType) clazz.getDeclaredConstructor().newInstance(); + } catch (Exception e) { + messager.printMessage(Diagnostic.Kind.ERROR, "Could not create instance of " + clazz.getName(), element); + return null; + } + }) + .filter(Objects::nonNull) + .forEach(type -> { + Class clazz = type.getClass(); + if (!type.requirements(typeElement.getSuperclass().toString(), typeElement.getInterfaces().stream().map(TypeMirror::toString).collect(Collectors.toSet()))) { + return; + } - LinkageType type = null; - try { - type = (LinkageType) clazz.getDeclaredConstructor().newInstance(); - } catch (Exception e) { - messager.printMessage(Diagnostic.Kind.ERROR, "Could not instantiate class", element); - return; - } + if (alreadyGenerated.add(clazz)) { + runMethod.addLine("if (type == " + clazz.getTypeName() + ".class) {"); + runMethod.addLine(" run" + clazz.getSimpleName() + "();"); + runMethod.addLine("}"); + } - if (!type.requirements(typeElement.getSuperclass().toString(), typeElement.getInterfaces().stream().map(TypeMirror::toString).collect(Collectors.toSet()))) { - return; - } - - if (alreadyGenerated.add((Class) clazz)) { - runMethod.addLine("if (type == " + clazz.getTypeName() + ".class) {"); - runMethod.addLine(" run" + clazz.getSimpleName() + "();"); - runMethod.addLine("}"); - } - - MethodBuilder method = methods.computeIfAbsent(clazz, t -> { - MethodBuilder methodBuilder = new MethodBuilder("run" + t.getSimpleName(), "void"); - methodBuilder.setPrivate(true); - buildPlan.addMethod(methodBuilder); - return methodBuilder; - }); - if (context == LinkageType.Context.SPIGOT && minVersion != null) { - method.addLine("if (de.steamwar.core.Core.getVersion() >= " + minVersion.value() + ") {"); - } - type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); - if (context == LinkageType.Context.SPIGOT && minVersion != null) { - method.addLine("}"); - } - }); + MethodBuilder method = methods.computeIfAbsent(clazz, t -> { + MethodBuilder methodBuilder = new MethodBuilder("run" + t.getSimpleName(), "void"); + methodBuilder.setPrivate(true); + buildPlan.addMethod(methodBuilder); + return methodBuilder; + }); + if (context == LinkageType.Context.SPIGOT && minVersion != null) { + method.addLine("if (de.steamwar.core.Core.getVersion() >= " + minVersion.value() + ") {"); + } + type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); + if (context == LinkageType.Context.SPIGOT && minVersion != null) { + method.addLine("}"); + } + }); } - BufferedWriter writer = new BufferedWriter(this.writer); - buildPlan.write(writer); - writer.close(); + BufferedWriter bufferedWriter = new BufferedWriter(writer); + buildPlan.write(bufferedWriter); + bufferedWriter.close(); return true; } From a58dd0698f777bb872eb1791667d4f29e6c8b75b Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 12:21:30 +0200 Subject: [PATCH 06/28] Fix initializer methods --- src/de/steamwar/linkage/LinkageProcessor.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 3a7c3d2..07a4ed0 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -154,6 +154,7 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addField(new FieldBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString())); MethodBuilder initializer = new MethodBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString()); + initializer.setPrivate(true); initializer.addLine("if (" + typeElement.getSimpleName().toString() + " == null) {"); initializer.addLine(" " + typeElement.getSimpleName().toString() + " = new " + typeElement.getSimpleName().toString() + "();"); initializer.addLine("}"); From 7c21034d33e8b2052115cd89d2ade99449e8698f Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 12:22:44 +0200 Subject: [PATCH 07/28] Update ListenerLink --- src/de/steamwar/linkage/types/ListenerLink.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/de/steamwar/linkage/types/ListenerLink.java b/src/de/steamwar/linkage/types/ListenerLink.java index 350c944..5a1fef2 100644 --- a/src/de/steamwar/linkage/types/ListenerLink.java +++ b/src/de/steamwar/linkage/types/ListenerLink.java @@ -87,7 +87,7 @@ public class ListenerLink implements LinkageType { methodBuilder.addLine("};"); methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, Core.getInstance(), ignoreCancelled));"); buildPlan.addMethod(methodBuilder); - linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + s + ".getHandlerList();"); + linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + eventType.getSimpleName() + ".getHandlerList();"); }); buildPlan.addImport(typeElement.getQualifiedName().toString()); From 7caa627c934eda91760cd7498de45e333e6941b9 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 13:12:51 +0200 Subject: [PATCH 08/28] Update LinkageProcessor --- src/de/steamwar/linkage/LinkageProcessor.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 07a4ed0..7f43a0b 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -98,7 +98,14 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addImport("java.util.HashSet"); buildPlan.addField(new FieldBuilder("Set>", "enabled", "new HashSet<>()")); + MethodBuilder runsMethod = new MethodBuilder("run", "void"); + runsMethod.addParameter(new ParameterBuilder("Class...", "types")); + runsMethod.addLine("for (Class type : types) run(type);"); + buildPlan.addMethod(runsMethod); + + MethodBuilder runMethod = new MethodBuilder("run", "void"); + runMethod.setPrivate(true); buildPlan.addMethod(runMethod); runMethod.addParameter(new ParameterBuilder("Class", "type")); runMethod.addLine("if (!enabled.add(type)) return;"); From f628bb67ddf39c1d892350da14e7b3e11c2a1563 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 13:15:22 +0200 Subject: [PATCH 09/28] Fix LinkageProcessor --- src/de/steamwar/linkage/LinkageProcessor.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 7f43a0b..343ee56 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -100,11 +100,11 @@ public class LinkageProcessor extends AbstractProcessor { MethodBuilder runsMethod = new MethodBuilder("run", "void"); runsMethod.addParameter(new ParameterBuilder("Class...", "types")); - runsMethod.addLine("for (Class type : types) run(type);"); + runsMethod.addLine("for (Class type : types) _run(type);"); buildPlan.addMethod(runsMethod); - MethodBuilder runMethod = new MethodBuilder("run", "void"); + MethodBuilder runMethod = new MethodBuilder("_run", "void"); runMethod.setPrivate(true); buildPlan.addMethod(runMethod); runMethod.addParameter(new ParameterBuilder("Class", "type")); From a2c2b3ecf1e646bac3706df97a315cd569c14e74 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 13:39:58 +0200 Subject: [PATCH 10/28] Fix registering target for listeners and for command messages --- src/de/steamwar/linkage/LinkageProcessor.java | 40 +++++++++++++++++-- src/de/steamwar/linkage/LinkageType.java | 4 ++ src/de/steamwar/linkage/types/Command.java | 11 +++++ .../steamwar/linkage/types/ListenerLink.java | 3 +- 4 files changed, 52 insertions(+), 6 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 343ee56..25eb4bd 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -35,8 +35,7 @@ import javax.lang.model.element.*; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; import javax.tools.Diagnostic; -import java.io.BufferedWriter; -import java.io.File; +import java.io.*; import java.io.Writer; import java.util.*; import java.util.stream.Collectors; @@ -47,6 +46,9 @@ public class LinkageProcessor extends AbstractProcessor { @Getter private static LinkageType.Context context; + @Getter + private static String pluginMain; + private String name; private String packageName; private String className; @@ -81,6 +83,36 @@ public class LinkageProcessor extends AbstractProcessor { this.name = name; packageName = "de.steamwar." + name + ".linkage"; className = "LinkageUtils"; + mainClass(); + } + + private void mainClass() { + File file = new File(System.getProperty("user.dir")); + String subModuleName = file.getName(); + if (subModuleName.contains(".")) subModuleName = subModuleName.substring(0, subModuleName.indexOf('.')); + + Optional main = getMainName(new File(file, "src/plugin.yml")); + if (!main.isPresent()) main = getMainName(new File(file, "src/main/resources/plugin.yml")); + if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Core/src/plugin.yml")); + if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Core/src/main/resources/plugin.yml")); + if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Main/src/plugin.yml")); + if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Main/src/main/resources/plugin.yml")); + if (!main.isPresent()) { + messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin.yml"); + return; + } + pluginMain = main.get(); + } + + @SneakyThrows + private Optional getMainName(File pluginYML) { + if (!pluginYML.exists()) return Optional.empty(); + try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(pluginYML)))) { + return reader.lines() + .filter(line -> line.startsWith("main:")) + .map(line -> line.substring(line.indexOf(':') + 1).trim()) + .findFirst(); + } } @SneakyThrows @@ -100,11 +132,11 @@ public class LinkageProcessor extends AbstractProcessor { MethodBuilder runsMethod = new MethodBuilder("run", "void"); runsMethod.addParameter(new ParameterBuilder("Class...", "types")); - runsMethod.addLine("for (Class type : types) _run(type);"); + runsMethod.addLine("for (Class type : types) run(type);"); buildPlan.addMethod(runsMethod); - MethodBuilder runMethod = new MethodBuilder("_run", "void"); + MethodBuilder runMethod = new MethodBuilder("run", "void"); runMethod.setPrivate(true); buildPlan.addMethod(runMethod); runMethod.addParameter(new ParameterBuilder("Class", "type")); diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index 9308905..8ed8a6e 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -23,12 +23,16 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; +import java.util.Optional; import java.util.OptionalInt; import java.util.Set; public interface LinkageType { Context context = LinkageProcessor.getContext(); + default Optional getPluginMain() { + return LinkageProcessor.getPluginMain(); + } enum Context { BUNGEE, diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/types/Command.java index fc522da..68c4607 100644 --- a/src/de/steamwar/linkage/types/Command.java +++ b/src/de/steamwar/linkage/types/Command.java @@ -24,10 +24,21 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; +import java.util.Set; public class Command implements LinkageType { + @Override + public boolean requirements(String superClass, Set interfaces) { + return superClass.equals("de.steamwar.command.SWCommand"); + } + @Override public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + if (context == Context.BUNGEE) { + linkageTypeMethod.addLine(instance + ";"); + return; + } + linkageTypeMethod.addLine(instance + ".setMessage(" + getPluginMain() + ".MESSAGE);"); } } diff --git a/src/de/steamwar/linkage/types/ListenerLink.java b/src/de/steamwar/linkage/types/ListenerLink.java index 5a1fef2..3eb140a 100644 --- a/src/de/steamwar/linkage/types/ListenerLink.java +++ b/src/de/steamwar/linkage/types/ListenerLink.java @@ -71,7 +71,6 @@ public class ListenerLink implements LinkageType { buildPlan.addImport("org.bukkit.event.EventPriority"); buildPlan.addImport("org.bukkit.plugin.RegisteredListener"); buildPlan.addImport("org.bukkit.plugin.EventExecutor"); - buildPlan.addImport("de.steamwar.core.Core"); buildPlan.addImport(s); buildPlan.addField(new FieldBuilder("HandlerList", "handlerList" + eventType.getSimpleName())); MethodBuilder methodBuilder = new MethodBuilder(eventType.getSimpleName().toString(), "void"); @@ -85,7 +84,7 @@ public class ListenerLink implements LinkageType { methodBuilder.addLine(" consumer.accept((" + eventType.getSimpleName() + ") event);"); methodBuilder.addLine(" }"); methodBuilder.addLine("};"); - methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, Core.getInstance(), ignoreCancelled));"); + methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, " + getPluginMain() + ".getInstance(), ignoreCancelled));"); buildPlan.addMethod(methodBuilder); linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + eventType.getSimpleName() + ".getHandlerList();"); }); From bbd4eeacd3d4b6ed30828fda61e6a728967adfd0 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 13:40:48 +0200 Subject: [PATCH 11/28] Fix LinkageType --- src/de/steamwar/linkage/LinkageType.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index 8ed8a6e..5ae6693 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -30,7 +30,7 @@ import java.util.Set; public interface LinkageType { Context context = LinkageProcessor.getContext(); - default Optional getPluginMain() { + default String getPluginMain() { return LinkageProcessor.getPluginMain(); } From 067acf5f6200a8f165150585013ac53e4ecf2fc2 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 13:46:39 +0200 Subject: [PATCH 12/28] Finalize Linkage --- src/de/steamwar/linkage/LinkageProcessor.java | 2 +- src/de/steamwar/linkage/LinkageType.java | 19 ++- src/de/steamwar/linkage/types/Command.java | 13 +- .../steamwar/linkage/types/DisableLink.java | 2 +- src/de/steamwar/linkage/types/EnableLink.java | 3 +- .../steamwar/linkage/types/ListenerLink.java | 124 +++++++++--------- .../linkage/types/UnlinkListener.java | 22 ++-- 7 files changed, 99 insertions(+), 86 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 25eb4bd..37b4529 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -249,7 +249,7 @@ public class LinkageProcessor extends AbstractProcessor { .filter(Objects::nonNull) .forEach(type -> { Class clazz = type.getClass(); - if (!type.requirements(typeElement.getSuperclass().toString(), typeElement.getInterfaces().stream().map(TypeMirror::toString).collect(Collectors.toSet()))) { + if (!type.requirements(typeElement.getSuperclass().toString(), typeElement.getInterfaces().stream().map(TypeMirror::toString).collect(Collectors.toSet()), typeElement)) { return; } diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index 5ae6693..afc37cc 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -23,8 +23,6 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -import java.util.Optional; -import java.util.OptionalInt; import java.util.Set; public interface LinkageType { @@ -39,9 +37,22 @@ public interface LinkageType { SPIGOT } - default boolean requirements(String superClass, Set interfaces) { + default boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { return true; } - void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement); + default void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + switch (context) { + case BUNGEE: + generateCodeBungee(buildPlan, linkageTypeMethod, instance, typeElement); + break; + case SPIGOT: + generateCodeSpigot(buildPlan, linkageTypeMethod, instance, typeElement); + break; + } + } + default void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + } + default void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + } } diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/types/Command.java index 68c4607..6d6948c 100644 --- a/src/de/steamwar/linkage/types/Command.java +++ b/src/de/steamwar/linkage/types/Command.java @@ -29,16 +29,17 @@ import java.util.Set; public class Command implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces) { + public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { return superClass.equals("de.steamwar.command.SWCommand"); } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - if (context == Context.BUNGEE) { - linkageTypeMethod.addLine(instance + ";"); - return; - } + public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + linkageTypeMethod.addLine(instance + ";"); + } + + @Override + public void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { linkageTypeMethod.addLine(instance + ".setMessage(" + getPluginMain() + ".MESSAGE);"); } } diff --git a/src/de/steamwar/linkage/types/DisableLink.java b/src/de/steamwar/linkage/types/DisableLink.java index c3cc54a..72f816d 100644 --- a/src/de/steamwar/linkage/types/DisableLink.java +++ b/src/de/steamwar/linkage/types/DisableLink.java @@ -29,7 +29,7 @@ import java.util.Set; public class DisableLink implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces) { + public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { return interfaces.contains("de.steamwar.linkage.api.Disable"); } diff --git a/src/de/steamwar/linkage/types/EnableLink.java b/src/de/steamwar/linkage/types/EnableLink.java index 4b42f86..d7630a4 100644 --- a/src/de/steamwar/linkage/types/EnableLink.java +++ b/src/de/steamwar/linkage/types/EnableLink.java @@ -20,7 +20,6 @@ package de.steamwar.linkage.types; import de.steamwar.linkage.LinkageType; -import de.steamwar.linkage.api.Enable; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; @@ -30,7 +29,7 @@ import java.util.Set; public class EnableLink implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces) { + public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { return interfaces.contains("de.steamwar.linkage.api.Enable"); } diff --git a/src/de/steamwar/linkage/types/ListenerLink.java b/src/de/steamwar/linkage/types/ListenerLink.java index 3eb140a..5c815c5 100644 --- a/src/de/steamwar/linkage/types/ListenerLink.java +++ b/src/de/steamwar/linkage/types/ListenerLink.java @@ -24,7 +24,6 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.FieldBuilder; import de.steamwar.linkage.plan.MethodBuilder; import de.steamwar.linkage.plan.ParameterBuilder; -import lombok.SneakyThrows; import javax.lang.model.element.*; import javax.lang.model.type.DeclaredType; @@ -35,7 +34,7 @@ import java.util.Set; public class ListenerLink implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces) { + public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { if (context == Context.BUNGEE) { return interfaces.contains("net.md_5.bungee.api.plugin.Listener"); } else { @@ -44,70 +43,71 @@ public class ListenerLink implements LinkageType { } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - if (context == Context.BUNGEE) { - buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); - buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); - linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(BungeeCore.get(), " + instance + ");"); - } else { - Map eventClasses = new HashMap<>(); - Map eventMethods = new HashMap<>(); + public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); + buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); + linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(BungeeCore.get(), " + instance + ");"); + } - typeElement.getEnclosedElements().stream().filter(e -> e.getKind() == ElementKind.METHOD).map(ExecutableElement.class::cast).filter(e -> { - return e.getAnnotationMirrors().stream().anyMatch(annotationMirror -> { - return annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler"); - }); - }).forEach(e -> { - TypeElement current = ((TypeElement)((DeclaredType) e.getParameters().get(0).asType()).asElement()); - eventClasses.put(current.getQualifiedName().toString(), current); - eventMethods.put(current, e); + @Override + public void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + Map eventClasses = new HashMap<>(); + Map eventMethods = new HashMap<>(); + + typeElement.getEnclosedElements().stream().filter(e -> e.getKind() == ElementKind.METHOD).map(ExecutableElement.class::cast).filter(e -> { + return e.getAnnotationMirrors().stream().anyMatch(annotationMirror -> { + return annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler"); }); + }).forEach(e -> { + TypeElement current = ((TypeElement)((DeclaredType) e.getParameters().get(0).asType()).asElement()); + eventClasses.put(current.getQualifiedName().toString(), current); + eventMethods.put(current, e); + }); - eventClasses.forEach((s, eventType) -> { - if (buildPlan.hasMethod(s)) return; - buildPlan.addImport("org.bukkit.event.HandlerList"); - buildPlan.addImport("org.bukkit.event.Listener"); - buildPlan.addImport("java.util.function.Consumer"); - buildPlan.addImport("org.bukkit.event.EventPriority"); - buildPlan.addImport("org.bukkit.plugin.RegisteredListener"); - buildPlan.addImport("org.bukkit.plugin.EventExecutor"); - buildPlan.addImport(s); - buildPlan.addField(new FieldBuilder("HandlerList", "handlerList" + eventType.getSimpleName())); - MethodBuilder methodBuilder = new MethodBuilder(eventType.getSimpleName().toString(), "void"); - methodBuilder.addParameter(new ParameterBuilder("Listener", "listener")); - methodBuilder.addParameter(new ParameterBuilder("Consumer<" + eventType.getSimpleName() + ">", "consumer")); - methodBuilder.addParameter(new ParameterBuilder("EventPriority", "eventPriority")); - methodBuilder.addParameter(new ParameterBuilder("boolean", "ignoreCancelled")); - methodBuilder.setPrivate(true); - methodBuilder.addLine("EventExecutor eventExecutor = (l, event) -> {"); - methodBuilder.addLine(" if (event instanceof " + eventType.getSimpleName() + ") {"); - methodBuilder.addLine(" consumer.accept((" + eventType.getSimpleName() + ") event);"); - methodBuilder.addLine(" }"); - methodBuilder.addLine("};"); - methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, " + getPluginMain() + ".getInstance(), ignoreCancelled));"); - buildPlan.addMethod(methodBuilder); - linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + eventType.getSimpleName() + ".getHandlerList();"); - }); + eventClasses.forEach((s, eventType) -> { + if (buildPlan.hasMethod(s)) return; + buildPlan.addImport("org.bukkit.event.HandlerList"); + buildPlan.addImport("org.bukkit.event.Listener"); + buildPlan.addImport("java.util.function.Consumer"); + buildPlan.addImport("org.bukkit.event.EventPriority"); + buildPlan.addImport("org.bukkit.plugin.RegisteredListener"); + buildPlan.addImport("org.bukkit.plugin.EventExecutor"); + buildPlan.addImport(s); + buildPlan.addField(new FieldBuilder("HandlerList", "handlerList" + eventType.getSimpleName())); + MethodBuilder methodBuilder = new MethodBuilder(eventType.getSimpleName().toString(), "void"); + methodBuilder.addParameter(new ParameterBuilder("Listener", "listener")); + methodBuilder.addParameter(new ParameterBuilder("Consumer<" + eventType.getSimpleName() + ">", "consumer")); + methodBuilder.addParameter(new ParameterBuilder("EventPriority", "eventPriority")); + methodBuilder.addParameter(new ParameterBuilder("boolean", "ignoreCancelled")); + methodBuilder.setPrivate(true); + methodBuilder.addLine("EventExecutor eventExecutor = (l, event) -> {"); + methodBuilder.addLine(" if (event instanceof " + eventType.getSimpleName() + ") {"); + methodBuilder.addLine(" consumer.accept((" + eventType.getSimpleName() + ") event);"); + methodBuilder.addLine(" }"); + methodBuilder.addLine("};"); + methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, " + getPluginMain() + ".getInstance(), ignoreCancelled));"); + buildPlan.addMethod(methodBuilder); + linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + eventType.getSimpleName() + ".getHandlerList();"); + }); - buildPlan.addImport(typeElement.getQualifiedName().toString()); - String localInstance = "local" + typeElement.getSimpleName().toString(); - linkageTypeMethod.addLine(typeElement.getSimpleName() + " " + localInstance + " = " + instance + ";"); - eventMethods.forEach((type, executableElement) -> { - AnnotationMirror eventHandler = executableElement.getAnnotationMirrors().stream().filter(annotationMirror -> annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler")).findFirst().orElse(null); - if (eventHandler == null) { - return; + buildPlan.addImport(typeElement.getQualifiedName().toString()); + String localInstance = "local" + typeElement.getSimpleName().toString(); + linkageTypeMethod.addLine(typeElement.getSimpleName() + " " + localInstance + " = " + instance + ";"); + eventMethods.forEach((type, executableElement) -> { + AnnotationMirror eventHandler = executableElement.getAnnotationMirrors().stream().filter(annotationMirror -> annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler")).findFirst().orElse(null); + if (eventHandler == null) { + return; + } + String priority = "NORMAL"; + String ignoreCancelled = "false"; + for (Map.Entry entry : eventHandler.getElementValues().entrySet()) { + if (entry.getKey().getSimpleName().toString().equals("priority")) { + priority = entry.getValue().getValue().toString(); + } else if (entry.getKey().getSimpleName().toString().equals("ignoreCancelled")) { + ignoreCancelled = entry.getValue().getValue().toString(); } - String priority = "NORMAL"; - String ignoreCancelled = "false"; - for (Map.Entry entry : eventHandler.getElementValues().entrySet()) { - if (entry.getKey().getSimpleName().toString().equals("priority")) { - priority = entry.getValue().getValue().toString(); - } else if (entry.getKey().getSimpleName().toString().equals("ignoreCancelled")) { - ignoreCancelled = entry.getValue().getValue().toString(); - } - } - linkageTypeMethod.addLine(type.getSimpleName().toString() + "(" + localInstance + ", " + localInstance + "::" + executableElement.getSimpleName().toString() + ", EventPriority." + priority + ", " + ignoreCancelled + ");"); - }); - } + } + linkageTypeMethod.addLine(type.getSimpleName().toString() + "(" + localInstance + ", " + localInstance + "::" + executableElement.getSimpleName().toString() + ", EventPriority." + priority + ", " + ignoreCancelled + ");"); + }); } } diff --git a/src/de/steamwar/linkage/types/UnlinkListener.java b/src/de/steamwar/linkage/types/UnlinkListener.java index 73966a7..564d567 100644 --- a/src/de/steamwar/linkage/types/UnlinkListener.java +++ b/src/de/steamwar/linkage/types/UnlinkListener.java @@ -24,12 +24,13 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; +import java.lang.reflect.Type; import java.util.Set; public class UnlinkListener implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces) { + public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { if (context == Context.BUNGEE) { return interfaces.contains("net.md_5.bungee.api.plugin.Listener"); } else { @@ -38,14 +39,15 @@ public class UnlinkListener implements LinkageType { } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - if (context == Context.BUNGEE) { - buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); - buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); - linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(" + instance + ");"); - } else { - buildPlan.addImport("org.bukkit.event.HandlerList"); - linkageTypeMethod.addLine("HandlerList.unregisterAll(" + instance + ");"); - } + public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); + buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); + linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(" + instance + ");"); + } + + @Override + public void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + buildPlan.addImport("org.bukkit.event.HandlerList"); + linkageTypeMethod.addLine("HandlerList.unregisterAll(" + instance + ");"); } } From f161379b620c9960cd1f636af809481afb7d8b98 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 14:53:42 +0200 Subject: [PATCH 13/28] Finalize min version checks --- src/de/steamwar/linkage/LinkageProcessor.java | 38 +++++++++++++------ 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 37b4529..6b59e3b 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -38,6 +38,7 @@ import javax.tools.Diagnostic; import java.io.*; import java.io.Writer; import java.util.*; +import java.util.function.Consumer; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -185,7 +186,9 @@ public class LinkageProcessor extends AbstractProcessor { TypeElement fieldType = (TypeElement) ((DeclaredType) variableElement.asType()).asElement(); neededFields.put(fieldType.getQualifiedName().toString(), fieldType); - buildPlan.addStaticLine(getElement(typeElement, neededFields) + "." + variableElement.getSimpleName().toString() + " = " + getElement((TypeElement) ((DeclaredType) variableElement.asType()).asElement(), neededFields) + ";"); + specialElements(typeElement, buildPlan, buildPlan::addStaticLine, () -> { + buildPlan.addStaticLine(getElement(typeElement, neededFields) + "." + variableElement.getSimpleName().toString() + " = " + getElement((TypeElement) ((DeclaredType) variableElement.asType()).asElement(), neededFields) + ";"); + }); } } neededFields.forEach((s, typeElement) -> { @@ -194,9 +197,11 @@ public class LinkageProcessor extends AbstractProcessor { MethodBuilder initializer = new MethodBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString()); initializer.setPrivate(true); - initializer.addLine("if (" + typeElement.getSimpleName().toString() + " == null) {"); - initializer.addLine(" " + typeElement.getSimpleName().toString() + " = new " + typeElement.getSimpleName().toString() + "();"); - initializer.addLine("}"); + specialElements(typeElement, buildPlan, initializer::addLine, () -> { + initializer.addLine("if (" + typeElement.getSimpleName().toString() + " == null) {"); + initializer.addLine(" " + typeElement.getSimpleName().toString() + " = new " + typeElement.getSimpleName().toString() + "();"); + initializer.addLine("}"); + }); initializer.addLine("return " + typeElement.getSimpleName().toString() + ";"); buildPlan.addMethod(initializer); }); @@ -207,7 +212,6 @@ public class LinkageProcessor extends AbstractProcessor { continue; } TypeElement typeElement = (TypeElement) element; - MinVersion minVersion = element.getAnnotation(MinVersion.class); System.out.println("Found element: " + typeElement.getQualifiedName().toString()); element.getAnnotationMirrors().stream() @@ -265,13 +269,9 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addMethod(methodBuilder); return methodBuilder; }); - if (context == LinkageType.Context.SPIGOT && minVersion != null) { - method.addLine("if (de.steamwar.core.Core.getVersion() >= " + minVersion.value() + ") {"); - } - type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); - if (context == LinkageType.Context.SPIGOT && minVersion != null) { - method.addLine("}"); - } + specialElements(typeElement, buildPlan, method::addLine, () -> { + type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); + }); }); } @@ -287,4 +287,18 @@ public class LinkageProcessor extends AbstractProcessor { } return "new " + typeElement.getQualifiedName().toString() + "()"; } + + private void specialElements(TypeElement typeElement, BuildPlan buildPlan, Consumer stringConsumer, Runnable inner) { + if (context == LinkageType.Context.SPIGOT) { + MinVersion minVersion = typeElement.getAnnotation(MinVersion.class); + if (minVersion != null) { + buildPlan.addImport("de.steamwar.core.Core"); + stringConsumer.accept("if (Core.getVersion() >= " + minVersion.value() + ") {"); + } + inner.run(); + if (minVersion != null) stringConsumer.accept("}"); + } else { + inner.run(); + } + } } From ff8ffbf5fbdc6ccd831449329dfade3bbc7d832c Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 15:21:04 +0200 Subject: [PATCH 14/28] Add AllowedContexts Add DiscordMode Add EventMode --- src/de/steamwar/linkage/AllowedContexts.java | 36 +++++++++++++++ src/de/steamwar/linkage/DiscordMode.java | 31 +++++++++++++ src/de/steamwar/linkage/EventMode.java | 44 +++++++++++++++++++ src/de/steamwar/linkage/LinkageProcessor.java | 12 +++++ src/de/steamwar/linkage/MinVersion.java | 11 +++-- 5 files changed, 131 insertions(+), 3 deletions(-) create mode 100644 src/de/steamwar/linkage/AllowedContexts.java create mode 100644 src/de/steamwar/linkage/DiscordMode.java create mode 100644 src/de/steamwar/linkage/EventMode.java diff --git a/src/de/steamwar/linkage/AllowedContexts.java b/src/de/steamwar/linkage/AllowedContexts.java new file mode 100644 index 0000000..775aaf5 --- /dev/null +++ b/src/de/steamwar/linkage/AllowedContexts.java @@ -0,0 +1,36 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.ANNOTATION_TYPE) +@Retention(RetentionPolicy.CLASS) +public @interface AllowedContexts { + + /** + * The context in which this annotation is valid. + */ + LinkageType.Context[] value(); + +} diff --git a/src/de/steamwar/linkage/DiscordMode.java b/src/de/steamwar/linkage/DiscordMode.java new file mode 100644 index 0000000..f30bab8 --- /dev/null +++ b/src/de/steamwar/linkage/DiscordMode.java @@ -0,0 +1,31 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@AllowedContexts(LinkageType.Context.BUNGEE) +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.TYPE}) +public @interface DiscordMode { +} diff --git a/src/de/steamwar/linkage/EventMode.java b/src/de/steamwar/linkage/EventMode.java new file mode 100644 index 0000000..86c8528 --- /dev/null +++ b/src/de/steamwar/linkage/EventMode.java @@ -0,0 +1,44 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@AllowedContexts(LinkageType.Context.BUNGEE) +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.TYPE}) +public @interface EventMode { + Mode value(); + + @AllArgsConstructor + enum Mode { + EventOnly(""), + NonEvent("!"); + + @Getter + private String prefix; + } +} diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 6b59e3b..14249ad 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -298,7 +298,19 @@ public class LinkageProcessor extends AbstractProcessor { inner.run(); if (minVersion != null) stringConsumer.accept("}"); } else { + EventMode eventMode = typeElement.getAnnotation(EventMode.class); + DiscordMode discordMode = typeElement.getAnnotation(DiscordMode.class); + if (eventMode != null) { + buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); + stringConsumer.accept("if (" + eventMode.value().getPrefix() + "BungeeCore.EVENT_MODE) {"); + } + if (discordMode != null) { + buildPlan.addImport("de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig"); + stringConsumer.accept("if (SteamwarDiscordBotConfig.loaded) {"); + } inner.run(); + if (discordMode != null) stringConsumer.accept("}"); + if (eventMode != null) stringConsumer.accept("}"); } } } diff --git a/src/de/steamwar/linkage/MinVersion.java b/src/de/steamwar/linkage/MinVersion.java index 6e396d7..d897935 100644 --- a/src/de/steamwar/linkage/MinVersion.java +++ b/src/de/steamwar/linkage/MinVersion.java @@ -19,9 +19,14 @@ package de.steamwar.linkage; -/** - * Only applicable in Spigot context. Will be ignored in other contexts. - */ +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@AllowedContexts(LinkageType.Context.SPIGOT) +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.TYPE}) public @interface MinVersion { int value(); } From eac3433ed14c545f4bf77d5c89cc9724997fdf6f Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 19:08:17 +0200 Subject: [PATCH 15/28] Add MaxVersion --- src/de/steamwar/linkage/LinkageProcessor.java | 23 +++++++++++-- src/de/steamwar/linkage/MaxVersion.java | 32 +++++++++++++++++++ 2 files changed, 52 insertions(+), 3 deletions(-) create mode 100644 src/de/steamwar/linkage/MaxVersion.java diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 14249ad..57d2cc8 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -37,6 +37,7 @@ import javax.lang.model.type.TypeMirror; import javax.tools.Diagnostic; import java.io.*; import java.io.Writer; +import java.lang.annotation.Annotation; import java.util.*; import java.util.function.Consumer; import java.util.stream.Collectors; @@ -289,17 +290,25 @@ public class LinkageProcessor extends AbstractProcessor { } private void specialElements(TypeElement typeElement, BuildPlan buildPlan, Consumer stringConsumer, Runnable inner) { + MinVersion minVersion = typeElement.getAnnotation(MinVersion.class); + MaxVersion maxVersion = typeElement.getAnnotation(MaxVersion.class); + EventMode eventMode = typeElement.getAnnotation(EventMode.class); + DiscordMode discordMode = typeElement.getAnnotation(DiscordMode.class); if (context == LinkageType.Context.SPIGOT) { - MinVersion minVersion = typeElement.getAnnotation(MinVersion.class); + errorOnNonNull(typeElement, eventMode, discordMode); if (minVersion != null) { buildPlan.addImport("de.steamwar.core.Core"); stringConsumer.accept("if (Core.getVersion() >= " + minVersion.value() + ") {"); } + if (maxVersion != null) { + buildPlan.addImport("de.steamwar.core.Core"); + stringConsumer.accept("if (Core.getVersion() < " + maxVersion.value() + ") {"); + } inner.run(); + if (maxVersion != null) stringConsumer.accept("}"); if (minVersion != null) stringConsumer.accept("}"); } else { - EventMode eventMode = typeElement.getAnnotation(EventMode.class); - DiscordMode discordMode = typeElement.getAnnotation(DiscordMode.class); + errorOnNonNull(typeElement, minVersion, maxVersion); if (eventMode != null) { buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); stringConsumer.accept("if (" + eventMode.value().getPrefix() + "BungeeCore.EVENT_MODE) {"); @@ -313,4 +322,12 @@ public class LinkageProcessor extends AbstractProcessor { if (eventMode != null) stringConsumer.accept("}"); } } + + private void errorOnNonNull(TypeElement typeElement, Annotation... annotations) { + for (Annotation annotation : annotations) { + if (annotation != null) { + messager.printMessage(Diagnostic.Kind.ERROR, annotation.annotationType().getSimpleName() + " is not supported in " + context.name(), typeElement); + } + } + } } diff --git a/src/de/steamwar/linkage/MaxVersion.java b/src/de/steamwar/linkage/MaxVersion.java new file mode 100644 index 0000000..589a67f --- /dev/null +++ b/src/de/steamwar/linkage/MaxVersion.java @@ -0,0 +1,32 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@AllowedContexts(LinkageType.Context.SPIGOT) +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.TYPE}) +public @interface MaxVersion { + int value(); +} From 8b7c1e08fdac0773b8eaa53fd9332047103b86d7 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 19:20:16 +0200 Subject: [PATCH 16/28] Add PluginCheck --- src/de/steamwar/linkage/LinkageProcessor.java | 15 +++++++ src/de/steamwar/linkage/PluginCheck.java | 42 +++++++++++++++++++ 2 files changed, 57 insertions(+) create mode 100644 src/de/steamwar/linkage/PluginCheck.java diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 57d2cc8..41abf0e 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -294,6 +294,7 @@ public class LinkageProcessor extends AbstractProcessor { MaxVersion maxVersion = typeElement.getAnnotation(MaxVersion.class); EventMode eventMode = typeElement.getAnnotation(EventMode.class); DiscordMode discordMode = typeElement.getAnnotation(DiscordMode.class); + PluginCheck[] pluginChecks = typeElement.getAnnotationsByType(PluginCheck.class); if (context == LinkageType.Context.SPIGOT) { errorOnNonNull(typeElement, eventMode, discordMode); if (minVersion != null) { @@ -304,7 +305,14 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addImport("de.steamwar.core.Core"); stringConsumer.accept("if (Core.getVersion() < " + maxVersion.value() + ") {"); } + if (pluginChecks.length != 0) { + buildPlan.addImport("org.bukkit.Bukkit"); + stringConsumer.accept(Arrays.stream(pluginChecks).map(pluginCheck -> { + return "Bukkit.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "=" : "!") + "= null"; + }).collect(Collectors.joining(" && ", "if (", ") {"))); + } inner.run(); + if (pluginChecks.length != 0) stringConsumer.accept("}"); if (maxVersion != null) stringConsumer.accept("}"); if (minVersion != null) stringConsumer.accept("}"); } else { @@ -317,7 +325,14 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addImport("de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig"); stringConsumer.accept("if (SteamwarDiscordBotConfig.loaded) {"); } + if (pluginChecks.length != 0) { + buildPlan.addImport("net.md_5.bungee.BungeeCord"); + stringConsumer.accept(Arrays.stream(pluginChecks).map(pluginCheck -> { + return "BungeeCord.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "=" : "!") + "= null"; + }).collect(Collectors.joining(" && ", "if (", ") {"))); + } inner.run(); + if (pluginChecks.length != 0) stringConsumer.accept("}"); if (discordMode != null) stringConsumer.accept("}"); if (eventMode != null) stringConsumer.accept("}"); } diff --git a/src/de/steamwar/linkage/PluginCheck.java b/src/de/steamwar/linkage/PluginCheck.java new file mode 100644 index 0000000..6b9931a --- /dev/null +++ b/src/de/steamwar/linkage/PluginCheck.java @@ -0,0 +1,42 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import java.lang.annotation.*; + +@AllowedContexts({LinkageType.Context.BUNGEE, LinkageType.Context.SPIGOT}) +@Retention(RetentionPolicy.SOURCE) +@Target({ElementType.TYPE}) +@Repeatable(PluginCheck.PluginChecks.class) +public @interface PluginCheck { + Has has() default Has.THIS; + String value(); + + enum Has { + THIS, + NOT + } + + @Retention(RetentionPolicy.SOURCE) + @Target({ElementType.TYPE}) + @interface PluginChecks { + @SuppressWarnings("unused") PluginCheck[] value() default {}; + } +} From 33133ed07936664bec353234f93311e74965281a Mon Sep 17 00:00:00 2001 From: yoyosource Date: Thu, 22 Sep 2022 21:48:26 +0200 Subject: [PATCH 17/28] Update if generation --- src/de/steamwar/linkage/LinkageProcessor.java | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 41abf0e..90e9a0a 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -297,44 +297,44 @@ public class LinkageProcessor extends AbstractProcessor { PluginCheck[] pluginChecks = typeElement.getAnnotationsByType(PluginCheck.class); if (context == LinkageType.Context.SPIGOT) { errorOnNonNull(typeElement, eventMode, discordMode); + List checks = new ArrayList<>(); if (minVersion != null) { buildPlan.addImport("de.steamwar.core.Core"); - stringConsumer.accept("if (Core.getVersion() >= " + minVersion.value() + ") {"); + checks.add("Core.getVersion() >= " + minVersion.value()); } if (maxVersion != null) { buildPlan.addImport("de.steamwar.core.Core"); - stringConsumer.accept("if (Core.getVersion() < " + maxVersion.value() + ") {"); + checks.add("Core.getVersion() < " + maxVersion.value()); } if (pluginChecks.length != 0) { buildPlan.addImport("org.bukkit.Bukkit"); - stringConsumer.accept(Arrays.stream(pluginChecks).map(pluginCheck -> { + Arrays.stream(pluginChecks).map(pluginCheck -> { return "Bukkit.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "=" : "!") + "= null"; - }).collect(Collectors.joining(" && ", "if (", ") {"))); + }).forEach(checks::add); } + if (!checks.isEmpty()) stringConsumer.accept("if (" + String.join(" && ", checks) + ") {"); inner.run(); - if (pluginChecks.length != 0) stringConsumer.accept("}"); - if (maxVersion != null) stringConsumer.accept("}"); - if (minVersion != null) stringConsumer.accept("}"); + if (!checks.isEmpty()) stringConsumer.accept("}"); } else { errorOnNonNull(typeElement, minVersion, maxVersion); + List checks = new ArrayList<>(); if (eventMode != null) { buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); - stringConsumer.accept("if (" + eventMode.value().getPrefix() + "BungeeCore.EVENT_MODE) {"); + checks.add(eventMode.value().getPrefix() + "BungeeCore.EVENT_MODE"); } if (discordMode != null) { buildPlan.addImport("de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig"); - stringConsumer.accept("if (SteamwarDiscordBotConfig.loaded) {"); + checks.add("SteamwarDiscordBotConfig.loaded"); } if (pluginChecks.length != 0) { buildPlan.addImport("net.md_5.bungee.BungeeCord"); - stringConsumer.accept(Arrays.stream(pluginChecks).map(pluginCheck -> { + Arrays.stream(pluginChecks).map(pluginCheck -> { return "BungeeCord.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "=" : "!") + "= null"; - }).collect(Collectors.joining(" && ", "if (", ") {"))); + }).forEach(checks::add); } + if (!checks.isEmpty()) stringConsumer.accept("if (" + String.join(" && ", checks) + ") {"); inner.run(); - if (pluginChecks.length != 0) stringConsumer.accept("}"); - if (discordMode != null) stringConsumer.accept("}"); - if (eventMode != null) stringConsumer.accept("}"); + if (!checks.isEmpty()) stringConsumer.accept("}"); } } From 9eb18d96264f4ea7782e10d574e261f3dfd8b930 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 23 Sep 2022 08:57:11 +0200 Subject: [PATCH 18/28] Fix run method generation --- src/de/steamwar/linkage/LinkageProcessor.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 90e9a0a..8255791 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -134,11 +134,11 @@ public class LinkageProcessor extends AbstractProcessor { MethodBuilder runsMethod = new MethodBuilder("run", "void"); runsMethod.addParameter(new ParameterBuilder("Class...", "types")); - runsMethod.addLine("for (Class type : types) run(type);"); + runsMethod.addLine("for (Class type : types) _run(type);"); buildPlan.addMethod(runsMethod); - MethodBuilder runMethod = new MethodBuilder("run", "void"); + MethodBuilder runMethod = new MethodBuilder("_run", "void"); runMethod.setPrivate(true); buildPlan.addMethod(runMethod); runMethod.addParameter(new ParameterBuilder("Class", "type")); From a25ea3878d8c772dae21e18b412a12935dadccdf Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 23 Sep 2022 09:00:22 +0200 Subject: [PATCH 19/28] Fix BuildPlan --- src/de/steamwar/linkage/plan/BuildPlan.java | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/src/de/steamwar/linkage/plan/BuildPlan.java b/src/de/steamwar/linkage/plan/BuildPlan.java index d53eeb8..ac2c06f 100644 --- a/src/de/steamwar/linkage/plan/BuildPlan.java +++ b/src/de/steamwar/linkage/plan/BuildPlan.java @@ -33,7 +33,7 @@ public class BuildPlan implements Writer { private Set imports = new HashSet<>(); private final String className; - private Map fieldBuilderMap = new HashMap<>(); + private List fieldBuilders = new ArrayList<>(); private Map methodBuilderMap = new HashMap<>(); private List staticLines = new ArrayList<>(); @@ -42,15 +42,7 @@ public class BuildPlan implements Writer { } public void addField(FieldBuilder fieldBuilder) { - fieldBuilderMap.putIfAbsent(fieldBuilder.getType(), fieldBuilder); - } - - public boolean hasField(String type) { - return fieldBuilderMap.containsKey(type); - } - - public String getFieldName(String type) { - return fieldBuilderMap.get(type).getFieldName(); + fieldBuilders.add(fieldBuilder); } public void addMethod(MethodBuilder methodBuilder) { @@ -76,8 +68,8 @@ public class BuildPlan implements Writer { } writer.write("\n"); writer.write("public class " + className + " {\n"); - if (!fieldBuilderMap.isEmpty()) { - for (FieldBuilder fieldBuilder : fieldBuilderMap.values()) { + if (!fieldBuilders.isEmpty()) { + for (FieldBuilder fieldBuilder : fieldBuilders) { fieldBuilder.write(writer); } writer.write("\n"); From fd0af779bc1aa1e05c7979fe821c92b3ac0994e2 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 23 Sep 2022 09:05:15 +0200 Subject: [PATCH 20/28] Fix LinkageProcessor --- src/de/steamwar/linkage/LinkageProcessor.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 8255791..13670de 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -309,7 +309,7 @@ public class LinkageProcessor extends AbstractProcessor { if (pluginChecks.length != 0) { buildPlan.addImport("org.bukkit.Bukkit"); Arrays.stream(pluginChecks).map(pluginCheck -> { - return "Bukkit.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "=" : "!") + "= null"; + return "Bukkit.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "!" : "=") + "= null"; }).forEach(checks::add); } if (!checks.isEmpty()) stringConsumer.accept("if (" + String.join(" && ", checks) + ") {"); @@ -329,7 +329,7 @@ public class LinkageProcessor extends AbstractProcessor { if (pluginChecks.length != 0) { buildPlan.addImport("net.md_5.bungee.BungeeCord"); Arrays.stream(pluginChecks).map(pluginCheck -> { - return "BungeeCord.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "=" : "!") + "= null"; + return "BungeeCord.getPluginManager().getPlugin(\"" + pluginCheck.value() + "\") " + (pluginCheck.has() == PluginCheck.Has.THIS ? "!" : "=") + "= null"; }).forEach(checks::add); } if (!checks.isEmpty()) stringConsumer.accept("if (" + String.join(" && ", checks) + ") {"); From 4dd552d08dd4d78899f85e57c3a9accfeb4891c6 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 23 Sep 2022 09:20:39 +0200 Subject: [PATCH 21/28] Fix a build error --- build.gradle | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 4006496..f1c8306 100644 --- a/build.gradle +++ b/build.gradle @@ -87,8 +87,10 @@ task buildResources { doLast { File to = new File("${buildDir}/classes/java/main/META-INF/services/javax.annotation.processing.Processor") to.parentFile.mkdirs() - to.createNewFile() - to.append("de.steamwar.linkage.LinkageProcessor\n") + if (!to.exists()) { + to.createNewFile() + to.append("de.steamwar.linkage.LinkageProcessor\n") + } } } classes.finalizedBy(buildResources) From de02138e8dd7ab0edf49ad6f297ff2af4aef3552 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 23 Sep 2022 11:49:27 +0200 Subject: [PATCH 22/28] Add plugin.yml discovery by traversal --- src/de/steamwar/linkage/LinkageProcessor.java | 25 +++++++++++-------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 13670de..35b5a6a 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -38,6 +38,8 @@ import javax.tools.Diagnostic; import java.io.*; import java.io.Writer; import java.lang.annotation.Annotation; +import java.nio.file.Files; +import java.nio.file.Path; import java.util.*; import java.util.function.Consumer; import java.util.stream.Collectors; @@ -88,22 +90,23 @@ public class LinkageProcessor extends AbstractProcessor { mainClass(); } + @SneakyThrows private void mainClass() { File file = new File(System.getProperty("user.dir")); - String subModuleName = file.getName(); - if (subModuleName.contains(".")) subModuleName = subModuleName.substring(0, subModuleName.indexOf('.')); - - Optional main = getMainName(new File(file, "src/plugin.yml")); - if (!main.isPresent()) main = getMainName(new File(file, "src/main/resources/plugin.yml")); - if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Core/src/plugin.yml")); - if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Core/src/main/resources/plugin.yml")); - if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Main/src/plugin.yml")); - if (!main.isPresent()) main = getMainName(new File(file, subModuleName + "_Main/src/main/resources/plugin.yml")); - if (!main.isPresent()) { + Optional pluginYMLFile = Files.walk(file.toPath()) + .map(Path::toFile) + .filter(f -> f.getName().equals("plugin.yml")) + .findFirst(); + if (!pluginYMLFile.isPresent()) { messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin.yml"); return; } - pluginMain = main.get(); + Optional mainName = getMainName(pluginYMLFile.get()); + if (!mainName.isPresent()) { + messager.printMessage(Diagnostic.Kind.ERROR, "Could not find main class in plugin.yml"); + return; + } + pluginMain = mainName.get(); } @SneakyThrows From b7e5de48948733d3981adaca388f4a2fd5ee74ef Mon Sep 17 00:00:00 2001 From: yoyosource Date: Fri, 23 Sep 2022 12:07:22 +0200 Subject: [PATCH 23/28] Remove Writer.java Update Bungee/Spigot detection --- src/de/steamwar/linkage/LinkageProcessor.java | 9 ++++--- src/de/steamwar/linkage/Writer.java | 27 ------------------- src/de/steamwar/linkage/plan/BuildPlan.java | 4 +-- .../steamwar/linkage/plan/FieldBuilder.java | 4 +-- .../steamwar/linkage/plan/MethodBuilder.java | 4 +-- .../linkage/plan/ParameterBuilder.java | 4 +-- 6 files changed, 9 insertions(+), 43 deletions(-) delete mode 100644 src/de/steamwar/linkage/Writer.java diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 35b5a6a..6f0fbd9 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -80,7 +80,6 @@ public class LinkageProcessor extends AbstractProcessor { String name = new File(System.getProperty("user.dir")).getName(); if (name.contains(".")) name = name.substring(0, name.indexOf('.')); name = name.toLowerCase(); - context = name.contains("bungee") ? LinkageType.Context.BUNGEE : LinkageType.Context.SPIGOT; messager = processingEnv.getMessager(); @@ -95,15 +94,17 @@ public class LinkageProcessor extends AbstractProcessor { File file = new File(System.getProperty("user.dir")); Optional pluginYMLFile = Files.walk(file.toPath()) .map(Path::toFile) - .filter(f -> f.getName().equals("plugin.yml")) + .filter(File::isFile) + .filter(f -> f.getName().equals("plugin.yml") || f.getName().equals("bungee.yml")) .findFirst(); if (!pluginYMLFile.isPresent()) { - messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin.yml"); + messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin.yml or bungee.yml"); return; } + context = pluginYMLFile.get().getName().equals("bungee.yml") ? LinkageType.Context.BUNGEE : LinkageType.Context.SPIGOT; Optional mainName = getMainName(pluginYMLFile.get()); if (!mainName.isPresent()) { - messager.printMessage(Diagnostic.Kind.ERROR, "Could not find main class in plugin.yml"); + messager.printMessage(Diagnostic.Kind.ERROR, "Could not find main class in plugin.yml or bungee.yml"); return; } pluginMain = mainName.get(); diff --git a/src/de/steamwar/linkage/Writer.java b/src/de/steamwar/linkage/Writer.java deleted file mode 100644 index 235af89..0000000 --- a/src/de/steamwar/linkage/Writer.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * 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 . - */ - -package de.steamwar.linkage; - -import java.io.BufferedWriter; -import java.io.IOException; - -public interface Writer { - void write(BufferedWriter writer) throws IOException; -} diff --git a/src/de/steamwar/linkage/plan/BuildPlan.java b/src/de/steamwar/linkage/plan/BuildPlan.java index ac2c06f..2fc7b8b 100644 --- a/src/de/steamwar/linkage/plan/BuildPlan.java +++ b/src/de/steamwar/linkage/plan/BuildPlan.java @@ -19,7 +19,6 @@ package de.steamwar.linkage.plan; -import de.steamwar.linkage.Writer; import lombok.RequiredArgsConstructor; import java.io.BufferedWriter; @@ -27,7 +26,7 @@ import java.io.IOException; import java.util.*; @RequiredArgsConstructor -public class BuildPlan implements Writer { +public class BuildPlan { private final String packageName; private Set imports = new HashSet<>(); @@ -57,7 +56,6 @@ public class BuildPlan implements Writer { staticLines.add(line); } - @Override public void write(BufferedWriter writer) throws IOException { writer.write("package " + packageName + ";\n"); if (!imports.isEmpty()) { diff --git a/src/de/steamwar/linkage/plan/FieldBuilder.java b/src/de/steamwar/linkage/plan/FieldBuilder.java index e45bdb2..12fa440 100644 --- a/src/de/steamwar/linkage/plan/FieldBuilder.java +++ b/src/de/steamwar/linkage/plan/FieldBuilder.java @@ -19,7 +19,6 @@ package de.steamwar.linkage.plan; -import de.steamwar.linkage.Writer; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.RequiredArgsConstructor; @@ -29,7 +28,7 @@ import java.io.IOException; @RequiredArgsConstructor @AllArgsConstructor -public class FieldBuilder implements Writer { +public class FieldBuilder { @Getter private final String type; private final String name; @@ -39,7 +38,6 @@ public class FieldBuilder implements Writer { return name; } - @Override public void write(BufferedWriter writer) throws IOException { writer.write(" private static " + type + " " + getFieldName() + (initializer == null ? "" : " = " + initializer) + ";\n"); } diff --git a/src/de/steamwar/linkage/plan/MethodBuilder.java b/src/de/steamwar/linkage/plan/MethodBuilder.java index a1d4a05..6a31175 100644 --- a/src/de/steamwar/linkage/plan/MethodBuilder.java +++ b/src/de/steamwar/linkage/plan/MethodBuilder.java @@ -19,7 +19,6 @@ package de.steamwar.linkage.plan; -import de.steamwar.linkage.Writer; import lombok.RequiredArgsConstructor; import java.io.BufferedWriter; @@ -28,7 +27,7 @@ import java.util.ArrayList; import java.util.List; @RequiredArgsConstructor -public class MethodBuilder implements Writer { +public class MethodBuilder { private final String name; private final String returnType; @@ -52,7 +51,6 @@ public class MethodBuilder implements Writer { this.isPrivate = isPrivate; } - @Override public void write(BufferedWriter writer) throws IOException { writer.write(" " + (isPrivate ? "private" : "public") + " static " + returnType + " " + getMethodName() + "("); for (int i = 0; i < parameters.size(); i++) { diff --git a/src/de/steamwar/linkage/plan/ParameterBuilder.java b/src/de/steamwar/linkage/plan/ParameterBuilder.java index 192b8a2..d88364b 100644 --- a/src/de/steamwar/linkage/plan/ParameterBuilder.java +++ b/src/de/steamwar/linkage/plan/ParameterBuilder.java @@ -19,18 +19,16 @@ package de.steamwar.linkage.plan; -import de.steamwar.linkage.Writer; import lombok.AllArgsConstructor; import java.io.BufferedWriter; import java.io.IOException; @AllArgsConstructor -public class ParameterBuilder implements Writer { +public class ParameterBuilder { private String type; private String name; - @Override public void write(BufferedWriter writer) throws IOException { writer.write(type + " " + name); } From be2b368802a2f6c188266f829f0743beaf1931c3 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Sat, 24 Sep 2022 11:22:22 +0200 Subject: [PATCH 24/28] Update MaxVersion check to be inclusive --- src/de/steamwar/linkage/LinkageProcessor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 6f0fbd9..19d962e 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -308,7 +308,7 @@ public class LinkageProcessor extends AbstractProcessor { } if (maxVersion != null) { buildPlan.addImport("de.steamwar.core.Core"); - checks.add("Core.getVersion() < " + maxVersion.value()); + checks.add("Core.getVersion() <= " + maxVersion.value()); } if (pluginChecks.length != 0) { buildPlan.addImport("org.bukkit.Bukkit"); From 75ff0c3d45263901e7947388c0e1eb4e7c795145 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Sat, 24 Sep 2022 12:53:18 +0200 Subject: [PATCH 25/28] Update some stuff --- src/de/steamwar/linkage/AllowedContexts.java | 2 +- .../{DiscordMode.java => Context.java} | 12 +- src/de/steamwar/linkage/EventMode.java | 2 +- src/de/steamwar/linkage/LinkageProcessor.java | 156 ++++++------------ src/de/steamwar/linkage/LinkageType.java | 26 +-- src/de/steamwar/linkage/LinkageTypeOld.java | 52 ++++++ src/de/steamwar/linkage/Linked.java | 8 - src/de/steamwar/linkage/MaxVersion.java | 2 +- src/de/steamwar/linkage/MinVersion.java | 2 +- src/de/steamwar/linkage/PluginCheck.java | 2 +- .../linkage/{types => typesold}/Command.java | 6 +- .../{types => typesold}/DisableLink.java | 6 +- .../{types => typesold}/EnableLink.java | 6 +- .../{types => typesold}/ListenerLink.java | 7 +- .../linkage/{types => typesold}/Plain.java | 6 +- .../{types => typesold}/UnlinkListener.java | 10 +- 16 files changed, 137 insertions(+), 168 deletions(-) rename src/de/steamwar/linkage/{DiscordMode.java => Context.java} (72%) create mode 100644 src/de/steamwar/linkage/LinkageTypeOld.java rename src/de/steamwar/linkage/{types => typesold}/Command.java (92%) rename src/de/steamwar/linkage/{types => typesold}/DisableLink.java (90%) rename src/de/steamwar/linkage/{types => typesold}/EnableLink.java (90%) rename src/de/steamwar/linkage/{types => typesold}/ListenerLink.java (97%) rename src/de/steamwar/linkage/{types => typesold}/Plain.java (89%) rename src/de/steamwar/linkage/{types => typesold}/UnlinkListener.java (89%) diff --git a/src/de/steamwar/linkage/AllowedContexts.java b/src/de/steamwar/linkage/AllowedContexts.java index 775aaf5..175a783 100644 --- a/src/de/steamwar/linkage/AllowedContexts.java +++ b/src/de/steamwar/linkage/AllowedContexts.java @@ -31,6 +31,6 @@ public @interface AllowedContexts { /** * The context in which this annotation is valid. */ - LinkageType.Context[] value(); + Context[] value(); } diff --git a/src/de/steamwar/linkage/DiscordMode.java b/src/de/steamwar/linkage/Context.java similarity index 72% rename from src/de/steamwar/linkage/DiscordMode.java rename to src/de/steamwar/linkage/Context.java index f30bab8..7559bd0 100644 --- a/src/de/steamwar/linkage/DiscordMode.java +++ b/src/de/steamwar/linkage/Context.java @@ -19,13 +19,7 @@ package de.steamwar.linkage; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -@AllowedContexts(LinkageType.Context.BUNGEE) -@Retention(RetentionPolicy.SOURCE) -@Target({ElementType.TYPE}) -public @interface DiscordMode { +public enum Context { + BUNGEE, + SPIGOT } diff --git a/src/de/steamwar/linkage/EventMode.java b/src/de/steamwar/linkage/EventMode.java index 86c8528..cdff466 100644 --- a/src/de/steamwar/linkage/EventMode.java +++ b/src/de/steamwar/linkage/EventMode.java @@ -27,7 +27,7 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; -@AllowedContexts(LinkageType.Context.BUNGEE) +@AllowedContexts(Context.BUNGEE) @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE}) public @interface EventMode { diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 19d962e..ddf7923 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -22,33 +22,27 @@ package de.steamwar.linkage; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.FieldBuilder; import de.steamwar.linkage.plan.MethodBuilder; -import de.steamwar.linkage.plan.ParameterBuilder; import lombok.Getter; import lombok.SneakyThrows; -import javax.annotation.processing.AbstractProcessor; -import javax.annotation.processing.Messager; -import javax.annotation.processing.ProcessingEnvironment; -import javax.annotation.processing.RoundEnvironment; +import javax.annotation.processing.*; import javax.lang.model.SourceVersion; import javax.lang.model.element.*; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; import javax.tools.Diagnostic; import java.io.*; -import java.io.Writer; import java.lang.annotation.Annotation; import java.nio.file.Files; import java.nio.file.Path; import java.util.*; import java.util.function.Consumer; import java.util.stream.Collectors; -import java.util.stream.Stream; +@SupportedAnnotationTypes("de.steamwar.linkage.Linked") public class LinkageProcessor extends AbstractProcessor { - @Getter - private static LinkageType.Context context; + private static Context context; @Getter private static String pluginMain; @@ -65,13 +59,6 @@ public class LinkageProcessor extends AbstractProcessor { return SourceVersion.latestSupported(); } - @Override - public Set getSupportedAnnotationTypes() { - return Stream.of(Linked.class, Linked.Linkages.class) - .map(Class::getCanonicalName) - .collect(Collectors.toSet()); - } - @SneakyThrows @Override public synchronized void init(ProcessingEnvironment processingEnv) { @@ -101,7 +88,7 @@ public class LinkageProcessor extends AbstractProcessor { messager.printMessage(Diagnostic.Kind.ERROR, "Could not find plugin.yml or bungee.yml"); return; } - context = pluginYMLFile.get().getName().equals("bungee.yml") ? LinkageType.Context.BUNGEE : LinkageType.Context.SPIGOT; + context = pluginYMLFile.get().getName().equals("bungee.yml") ? Context.BUNGEE : Context.SPIGOT; Optional mainName = getMainName(pluginYMLFile.get()); if (!mainName.isPresent()) { messager.printMessage(Diagnostic.Kind.ERROR, "Could not find main class in plugin.yml or bungee.yml"); @@ -134,36 +121,19 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addImport("java.lang.Class"); buildPlan.addImport("de.steamwar.linkage.LinkageType"); buildPlan.addImport("java.util.HashSet"); - buildPlan.addField(new FieldBuilder("Set>", "enabled", "new HashSet<>()")); - - MethodBuilder runsMethod = new MethodBuilder("run", "void"); - runsMethod.addParameter(new ParameterBuilder("Class...", "types")); - runsMethod.addLine("for (Class type : types) _run(type);"); - buildPlan.addMethod(runsMethod); - - - MethodBuilder runMethod = new MethodBuilder("_run", "void"); - runMethod.setPrivate(true); - buildPlan.addMethod(runMethod); - runMethod.addParameter(new ParameterBuilder("Class", "type")); - runMethod.addLine("if (!enabled.add(type)) return;"); - Set> alreadyGenerated = new HashSet<>(); Set elements = roundEnv.getElementsAnnotatedWith(Linked.class); - elements.addAll((Set) roundEnv.getElementsAnnotatedWith(Linked.Linkages.class)); - Map neededFields = new HashMap<>(); for (Element element : elements) { if (element.getKind() != ElementKind.CLASS) { continue; } TypeElement typeElement = (TypeElement) element; - Linked[] linkeds = element.getAnnotationsByType(Linked.class); - if (linkeds.length == 0) { + Linked linked = element.getAnnotation(Linked.class); + if (linked == null) { continue; } - - if (linkeds.length > 1) { + if (getLinkagesOfType(typeElement).size() > 1) { neededFields.put(typeElement.getQualifiedName().toString(), typeElement); } @@ -211,7 +181,7 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addMethod(initializer); }); - Map, MethodBuilder> methods = new HashMap<>(); + Map methods = new HashMap<>(); for (Element element : elements) { if (element.getKind() != ElementKind.CLASS) { continue; @@ -219,65 +189,21 @@ public class LinkageProcessor extends AbstractProcessor { TypeElement typeElement = (TypeElement) element; System.out.println("Found element: " + typeElement.getQualifiedName().toString()); - element.getAnnotationMirrors().stream() - .filter(annotationMirror -> { - String annotationNames = annotationMirror.getAnnotationType().asElement().getSimpleName().toString(); - return annotationNames.equals("Linked") || annotationNames.equals("Linkages"); - }) - .flatMap(annotationMirror -> annotationMirror.getElementValues().values().stream()) - .map(AnnotationValue::getValue) - .flatMap(o -> { - if (o instanceof List) { - return ((List) o).stream() - .map(AnnotationMirror.class::cast) - .map(AnnotationMirror::getElementValues) - .map(Map::values) - .flatMap(Collection::stream) - .map(AnnotationValue::getValue); - } - return Stream.of(o); - }) - .map(Object::toString) - .map(s -> { - try { - return Class.forName(s); - } catch (Exception e) { - messager.printMessage(Diagnostic.Kind.ERROR, "Could not find class " + s, element); - return null; - } - }) - .filter(Objects::nonNull) - .map(clazz -> { - try { - return (LinkageType) clazz.getDeclaredConstructor().newInstance(); - } catch (Exception e) { - messager.printMessage(Diagnostic.Kind.ERROR, "Could not create instance of " + clazz.getName(), element); - return null; - } - }) - .filter(Objects::nonNull) - .forEach(type -> { - Class clazz = type.getClass(); - if (!type.requirements(typeElement.getSuperclass().toString(), typeElement.getInterfaces().stream().map(TypeMirror::toString).collect(Collectors.toSet()), typeElement)) { - return; - } + Map> linkages = getLinkagesOfType(typeElement); + if (linkages.isEmpty()) { + continue; + } - if (alreadyGenerated.add(clazz)) { - runMethod.addLine("if (type == " + clazz.getTypeName() + ".class) {"); - runMethod.addLine(" run" + clazz.getSimpleName() + "();"); - runMethod.addLine("}"); - } - - MethodBuilder method = methods.computeIfAbsent(clazz, t -> { - MethodBuilder methodBuilder = new MethodBuilder("run" + t.getSimpleName(), "void"); - methodBuilder.setPrivate(true); - buildPlan.addMethod(methodBuilder); - return methodBuilder; - }); - specialElements(typeElement, buildPlan, method::addLine, () -> { - type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); - }); + for (Map.Entry> entry : linkages.entrySet()) { + MethodBuilder method = methods.computeIfAbsent(entry.getKey(), s -> { + return new MethodBuilder(s, "void"); + }); + for (LinkageType type : entry.getValue()) { + specialElements(typeElement, buildPlan, method::addLine, () -> { + type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); }); + } + } } BufferedWriter bufferedWriter = new BufferedWriter(writer); @@ -297,10 +223,9 @@ public class LinkageProcessor extends AbstractProcessor { MinVersion minVersion = typeElement.getAnnotation(MinVersion.class); MaxVersion maxVersion = typeElement.getAnnotation(MaxVersion.class); EventMode eventMode = typeElement.getAnnotation(EventMode.class); - DiscordMode discordMode = typeElement.getAnnotation(DiscordMode.class); PluginCheck[] pluginChecks = typeElement.getAnnotationsByType(PluginCheck.class); - if (context == LinkageType.Context.SPIGOT) { - errorOnNonNull(typeElement, eventMode, discordMode); + if (context == Context.SPIGOT) { + errorOnNonNull(typeElement, eventMode); List checks = new ArrayList<>(); if (minVersion != null) { buildPlan.addImport("de.steamwar.core.Core"); @@ -326,10 +251,6 @@ public class LinkageProcessor extends AbstractProcessor { buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); checks.add(eventMode.value().getPrefix() + "BungeeCore.EVENT_MODE"); } - if (discordMode != null) { - buildPlan.addImport("de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig"); - checks.add("SteamwarDiscordBotConfig.loaded"); - } if (pluginChecks.length != 0) { buildPlan.addImport("net.md_5.bungee.BungeeCord"); Arrays.stream(pluginChecks).map(pluginCheck -> { @@ -349,4 +270,35 @@ public class LinkageProcessor extends AbstractProcessor { } } } + + private Map> getLinkagesOfType(TypeElement typeElement) { + Map> linkages = new HashMap<>(); + LinkageType superClassType = resolveSingle(typeElement.getSuperclass()); + if (superClassType != null) { + linkages.computeIfAbsent(superClassType.method(), s -> new ArrayList<>()).add(superClassType); + } + for (TypeMirror typeMirror : typeElement.getInterfaces()) { + LinkageType interfaceType = resolveSingle(typeMirror); + if (interfaceType != null) { + linkages.computeIfAbsent(interfaceType.method(), s -> new ArrayList<>()).add(interfaceType); + } + } + return linkages; + } + + private LinkageType resolveSingle(TypeMirror typeMirror) { + String qualifier = typeMirror.toString(); + qualifier = qualifier.substring(qualifier.lastIndexOf('.') + 1); + try { + return (LinkageType) Class.forName("de.steamwar.linkage.types." + qualifier + context.name()).getDeclaredConstructor().newInstance(); + } catch (Exception e) { + // Ignore + } + try { + return (LinkageType) Class.forName("de.steamwar.linkage.types." + qualifier).getDeclaredConstructor().newInstance(); + } catch (Exception e) { + // Ignore + } + return null; + } } diff --git a/src/de/steamwar/linkage/LinkageType.java b/src/de/steamwar/linkage/LinkageType.java index afc37cc..9291279 100644 --- a/src/de/steamwar/linkage/LinkageType.java +++ b/src/de/steamwar/linkage/LinkageType.java @@ -23,36 +23,14 @@ import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -import java.util.Set; public interface LinkageType { - Context context = LinkageProcessor.getContext(); default String getPluginMain() { return LinkageProcessor.getPluginMain(); } - enum Context { - BUNGEE, - SPIGOT - } + String method(); - default boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - return true; - } - - default void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - switch (context) { - case BUNGEE: - generateCodeBungee(buildPlan, linkageTypeMethod, instance, typeElement); - break; - case SPIGOT: - generateCodeSpigot(buildPlan, linkageTypeMethod, instance, typeElement); - break; - } - } - default void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - } - default void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - } + void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement); } diff --git a/src/de/steamwar/linkage/LinkageTypeOld.java b/src/de/steamwar/linkage/LinkageTypeOld.java new file mode 100644 index 0000000..d85db84 --- /dev/null +++ b/src/de/steamwar/linkage/LinkageTypeOld.java @@ -0,0 +1,52 @@ +/* + * 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 . + */ + +package de.steamwar.linkage; + +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +import javax.lang.model.element.TypeElement; +import java.util.Set; + +public interface LinkageTypeOld { + + default String getPluginMain() { + return LinkageProcessor.getPluginMain(); + } + + default boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { + return true; + } + + default void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + switch (context) { + case BUNGEE: + generateCodeBungee(buildPlan, linkageTypeMethod, instance, typeElement); + break; + case SPIGOT: + generateCodeSpigot(buildPlan, linkageTypeMethod, instance, typeElement); + break; + } + } + default void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + } + default void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + } +} diff --git a/src/de/steamwar/linkage/Linked.java b/src/de/steamwar/linkage/Linked.java index b352982..f3836e0 100644 --- a/src/de/steamwar/linkage/Linked.java +++ b/src/de/steamwar/linkage/Linked.java @@ -23,13 +23,5 @@ import java.lang.annotation.*; @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE}) -@Repeatable(Linked.Linkages.class) public @interface Linked { - Class value(); - - @Retention(RetentionPolicy.SOURCE) - @Target({ElementType.TYPE}) - @interface Linkages { - @SuppressWarnings("unused") Linked[] value() default {}; - } } diff --git a/src/de/steamwar/linkage/MaxVersion.java b/src/de/steamwar/linkage/MaxVersion.java index 589a67f..e144b16 100644 --- a/src/de/steamwar/linkage/MaxVersion.java +++ b/src/de/steamwar/linkage/MaxVersion.java @@ -24,7 +24,7 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; -@AllowedContexts(LinkageType.Context.SPIGOT) +@AllowedContexts(Context.SPIGOT) @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE}) public @interface MaxVersion { diff --git a/src/de/steamwar/linkage/MinVersion.java b/src/de/steamwar/linkage/MinVersion.java index d897935..b6f5b99 100644 --- a/src/de/steamwar/linkage/MinVersion.java +++ b/src/de/steamwar/linkage/MinVersion.java @@ -24,7 +24,7 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; -@AllowedContexts(LinkageType.Context.SPIGOT) +@AllowedContexts(Context.SPIGOT) @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE}) public @interface MinVersion { diff --git a/src/de/steamwar/linkage/PluginCheck.java b/src/de/steamwar/linkage/PluginCheck.java index 6b9931a..241f19a 100644 --- a/src/de/steamwar/linkage/PluginCheck.java +++ b/src/de/steamwar/linkage/PluginCheck.java @@ -21,7 +21,7 @@ package de.steamwar.linkage; import java.lang.annotation.*; -@AllowedContexts({LinkageType.Context.BUNGEE, LinkageType.Context.SPIGOT}) +@AllowedContexts({Context.BUNGEE, Context.SPIGOT}) @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE}) @Repeatable(PluginCheck.PluginChecks.class) diff --git a/src/de/steamwar/linkage/types/Command.java b/src/de/steamwar/linkage/typesold/Command.java similarity index 92% rename from src/de/steamwar/linkage/types/Command.java rename to src/de/steamwar/linkage/typesold/Command.java index 6d6948c..d890a49 100644 --- a/src/de/steamwar/linkage/types/Command.java +++ b/src/de/steamwar/linkage/typesold/Command.java @@ -17,16 +17,16 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.types; +package de.steamwar.linkage.typesold; -import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.LinkageTypeOld; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; import java.util.Set; -public class Command implements LinkageType { +public class Command implements LinkageTypeOld { @Override public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { diff --git a/src/de/steamwar/linkage/types/DisableLink.java b/src/de/steamwar/linkage/typesold/DisableLink.java similarity index 90% rename from src/de/steamwar/linkage/types/DisableLink.java rename to src/de/steamwar/linkage/typesold/DisableLink.java index 72f816d..a78d873 100644 --- a/src/de/steamwar/linkage/types/DisableLink.java +++ b/src/de/steamwar/linkage/typesold/DisableLink.java @@ -17,16 +17,16 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.types; +package de.steamwar.linkage.typesold; -import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.LinkageTypeOld; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; import java.util.Set; -public class DisableLink implements LinkageType { +public class DisableLink implements LinkageTypeOld { @Override public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { diff --git a/src/de/steamwar/linkage/types/EnableLink.java b/src/de/steamwar/linkage/typesold/EnableLink.java similarity index 90% rename from src/de/steamwar/linkage/types/EnableLink.java rename to src/de/steamwar/linkage/typesold/EnableLink.java index d7630a4..a0b5171 100644 --- a/src/de/steamwar/linkage/types/EnableLink.java +++ b/src/de/steamwar/linkage/typesold/EnableLink.java @@ -17,16 +17,16 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.types; +package de.steamwar.linkage.typesold; -import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.LinkageTypeOld; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; import java.util.Set; -public class EnableLink implements LinkageType { +public class EnableLink implements LinkageTypeOld { @Override public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { diff --git a/src/de/steamwar/linkage/types/ListenerLink.java b/src/de/steamwar/linkage/typesold/ListenerLink.java similarity index 97% rename from src/de/steamwar/linkage/types/ListenerLink.java rename to src/de/steamwar/linkage/typesold/ListenerLink.java index 5c815c5..5a96d73 100644 --- a/src/de/steamwar/linkage/types/ListenerLink.java +++ b/src/de/steamwar/linkage/typesold/ListenerLink.java @@ -17,9 +17,10 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.types; +package de.steamwar.linkage.typesold; -import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.Context; +import de.steamwar.linkage.LinkageTypeOld; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.FieldBuilder; import de.steamwar.linkage.plan.MethodBuilder; @@ -31,7 +32,7 @@ import java.util.HashMap; import java.util.Map; import java.util.Set; -public class ListenerLink implements LinkageType { +public class ListenerLink implements LinkageTypeOld { @Override public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { diff --git a/src/de/steamwar/linkage/types/Plain.java b/src/de/steamwar/linkage/typesold/Plain.java similarity index 89% rename from src/de/steamwar/linkage/types/Plain.java rename to src/de/steamwar/linkage/typesold/Plain.java index 1890521..25258fc 100644 --- a/src/de/steamwar/linkage/types/Plain.java +++ b/src/de/steamwar/linkage/typesold/Plain.java @@ -17,15 +17,15 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.types; +package de.steamwar.linkage.typesold; -import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.LinkageTypeOld; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -public class Plain implements LinkageType { +public class Plain implements LinkageTypeOld { @Override public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { diff --git a/src/de/steamwar/linkage/types/UnlinkListener.java b/src/de/steamwar/linkage/typesold/UnlinkListener.java similarity index 89% rename from src/de/steamwar/linkage/types/UnlinkListener.java rename to src/de/steamwar/linkage/typesold/UnlinkListener.java index 564d567..94e4662 100644 --- a/src/de/steamwar/linkage/types/UnlinkListener.java +++ b/src/de/steamwar/linkage/typesold/UnlinkListener.java @@ -17,17 +17,17 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.types; +package de.steamwar.linkage.typesold; -import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.Context; +import de.steamwar.linkage.LinkageTypeOld; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -import java.lang.reflect.Type; import java.util.Set; -public class UnlinkListener implements LinkageType { +public class UnlinkListener implements LinkageTypeOld { @Override public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { @@ -42,7 +42,7 @@ public class UnlinkListener implements LinkageType { public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); - linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(" + instance + ");"); + linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().unregisterListener(" + instance + ");"); } @Override From 49a6a6f23fce853c610909acc6167ce4b7fb7dfb Mon Sep 17 00:00:00 2001 From: yoyosource Date: Sat, 24 Sep 2022 13:34:10 +0200 Subject: [PATCH 26/28] Update some stuff --- src/de/steamwar/linkage/LinkageProcessor.java | 34 ++++++------ src/de/steamwar/linkage/LinkageTypeOld.java | 52 ------------------ .../Disable_GENERIC.java} | 17 +++--- .../Enable_GENERIC.java} | 17 +++--- .../Listener_BUNGEE.java} | 24 ++++----- .../Listener_SPIGOT.java} | 32 ++++------- .../Plain.java => types/Plain_GENERIC.java} | 17 +++--- .../linkage/types/SWCommand_BUNGEE.java | 39 ++++++++++++++ .../linkage/types/SWCommand_SPIGOT.java | 39 ++++++++++++++ .../linkage/typesold/UnlinkListener.java | 53 ------------------- 10 files changed, 139 insertions(+), 185 deletions(-) delete mode 100644 src/de/steamwar/linkage/LinkageTypeOld.java rename src/de/steamwar/linkage/{typesold/EnableLink.java => types/Disable_GENERIC.java} (66%) rename src/de/steamwar/linkage/{typesold/DisableLink.java => types/Enable_GENERIC.java} (66%) rename src/de/steamwar/linkage/{typesold/Command.java => types/Listener_BUNGEE.java} (53%) rename src/de/steamwar/linkage/{typesold/ListenerLink.java => types/Listener_SPIGOT.java} (74%) rename src/de/steamwar/linkage/{typesold/Plain.java => types/Plain_GENERIC.java} (73%) create mode 100644 src/de/steamwar/linkage/types/SWCommand_BUNGEE.java create mode 100644 src/de/steamwar/linkage/types/SWCommand_SPIGOT.java delete mode 100644 src/de/steamwar/linkage/typesold/UnlinkListener.java diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index ddf7923..83f6794 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -22,6 +22,7 @@ package de.steamwar.linkage; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.FieldBuilder; import de.steamwar.linkage.plan.MethodBuilder; +import de.steamwar.linkage.types.Plain_GENERIC; import lombok.Getter; import lombok.SneakyThrows; @@ -117,10 +118,7 @@ public class LinkageProcessor extends AbstractProcessor { Writer writer = processingEnv.getFiler().createSourceFile("de.steamwar." + name + ".linkage.LinkageUtils").openWriter(); BuildPlan buildPlan = new BuildPlan(packageName, className); - buildPlan.addImport("java.util.Set"); - buildPlan.addImport("java.lang.Class"); buildPlan.addImport("de.steamwar.linkage.LinkageType"); - buildPlan.addImport("java.util.HashSet"); Set elements = roundEnv.getElementsAnnotatedWith(Linked.class); Map neededFields = new HashMap<>(); @@ -168,17 +166,7 @@ public class LinkageProcessor extends AbstractProcessor { } neededFields.forEach((s, typeElement) -> { buildPlan.addImport(typeElement.getQualifiedName().toString()); - buildPlan.addField(new FieldBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString())); - - MethodBuilder initializer = new MethodBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString()); - initializer.setPrivate(true); - specialElements(typeElement, buildPlan, initializer::addLine, () -> { - initializer.addLine("if (" + typeElement.getSimpleName().toString() + " == null) {"); - initializer.addLine(" " + typeElement.getSimpleName().toString() + " = new " + typeElement.getSimpleName().toString() + "();"); - initializer.addLine("}"); - }); - initializer.addLine("return " + typeElement.getSimpleName().toString() + ";"); - buildPlan.addMethod(initializer); + buildPlan.addField(new FieldBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString(), "new " + typeElement.getSimpleName().toString() + "()")); }); Map methods = new HashMap<>(); @@ -196,10 +184,13 @@ public class LinkageProcessor extends AbstractProcessor { for (Map.Entry> entry : linkages.entrySet()) { MethodBuilder method = methods.computeIfAbsent(entry.getKey(), s -> { - return new MethodBuilder(s, "void"); + MethodBuilder methodBuilder = new MethodBuilder(s, "void"); + buildPlan.addMethod(methodBuilder); + return methodBuilder; }); for (LinkageType type : entry.getValue()) { specialElements(typeElement, buildPlan, method::addLine, () -> { + buildPlan.addImport(typeElement.getQualifiedName().toString()); type.generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement); }); } @@ -214,9 +205,9 @@ public class LinkageProcessor extends AbstractProcessor { private String getElement(TypeElement typeElement, Map neededFields) { if (neededFields.containsKey(typeElement.getQualifiedName().toString())) { - return typeElement.getSimpleName().toString() + "()"; + return typeElement.getSimpleName().toString(); } - return "new " + typeElement.getQualifiedName().toString() + "()"; + return "new " + typeElement.getSimpleName().toString() + "()"; } private void specialElements(TypeElement typeElement, BuildPlan buildPlan, Consumer stringConsumer, Runnable inner) { @@ -271,6 +262,8 @@ public class LinkageProcessor extends AbstractProcessor { } } + private Plain_GENERIC plain_GENERIC = new Plain_GENERIC(); + private Map> getLinkagesOfType(TypeElement typeElement) { Map> linkages = new HashMap<>(); LinkageType superClassType = resolveSingle(typeElement.getSuperclass()); @@ -283,6 +276,9 @@ public class LinkageProcessor extends AbstractProcessor { linkages.computeIfAbsent(interfaceType.method(), s -> new ArrayList<>()).add(interfaceType); } } + if (!linkages.containsKey(plain_GENERIC.method())) { + linkages.put(plain_GENERIC.method(), Collections.singletonList(plain_GENERIC)); + } return linkages; } @@ -290,12 +286,12 @@ public class LinkageProcessor extends AbstractProcessor { String qualifier = typeMirror.toString(); qualifier = qualifier.substring(qualifier.lastIndexOf('.') + 1); try { - return (LinkageType) Class.forName("de.steamwar.linkage.types." + qualifier + context.name()).getDeclaredConstructor().newInstance(); + return (LinkageType) Class.forName("de.steamwar.linkage.types." + qualifier + "_" + context.name()).getDeclaredConstructor().newInstance(); } catch (Exception e) { // Ignore } try { - return (LinkageType) Class.forName("de.steamwar.linkage.types." + qualifier).getDeclaredConstructor().newInstance(); + return (LinkageType) Class.forName("de.steamwar.linkage.types." + qualifier + "_GENERIC").getDeclaredConstructor().newInstance(); } catch (Exception e) { // Ignore } diff --git a/src/de/steamwar/linkage/LinkageTypeOld.java b/src/de/steamwar/linkage/LinkageTypeOld.java deleted file mode 100644 index d85db84..0000000 --- a/src/de/steamwar/linkage/LinkageTypeOld.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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 . - */ - -package de.steamwar.linkage; - -import de.steamwar.linkage.plan.BuildPlan; -import de.steamwar.linkage.plan.MethodBuilder; - -import javax.lang.model.element.TypeElement; -import java.util.Set; - -public interface LinkageTypeOld { - - default String getPluginMain() { - return LinkageProcessor.getPluginMain(); - } - - default boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - return true; - } - - default void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - switch (context) { - case BUNGEE: - generateCodeBungee(buildPlan, linkageTypeMethod, instance, typeElement); - break; - case SPIGOT: - generateCodeSpigot(buildPlan, linkageTypeMethod, instance, typeElement); - break; - } - } - default void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - } - default void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - } -} diff --git a/src/de/steamwar/linkage/typesold/EnableLink.java b/src/de/steamwar/linkage/types/Disable_GENERIC.java similarity index 66% rename from src/de/steamwar/linkage/typesold/EnableLink.java rename to src/de/steamwar/linkage/types/Disable_GENERIC.java index a0b5171..ea58c91 100644 --- a/src/de/steamwar/linkage/typesold/EnableLink.java +++ b/src/de/steamwar/linkage/types/Disable_GENERIC.java @@ -1,7 +1,7 @@ /* * This file is a part of the SteamWar software. * - * Copyright (C) 2022 SteamWar.de-Serverteam + * 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 @@ -17,24 +17,23 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.typesold; +package de.steamwar.linkage.types; -import de.steamwar.linkage.LinkageTypeOld; +import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -import java.util.Set; -public class EnableLink implements LinkageTypeOld { +public class Disable_GENERIC implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - return interfaces.contains("de.steamwar.linkage.api.Enable"); + public String method() { + return "unlink"; } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - linkageTypeMethod.addLine(instance + ".enable();"); + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + method.addLine(instance + ".disable();"); } } diff --git a/src/de/steamwar/linkage/typesold/DisableLink.java b/src/de/steamwar/linkage/types/Enable_GENERIC.java similarity index 66% rename from src/de/steamwar/linkage/typesold/DisableLink.java rename to src/de/steamwar/linkage/types/Enable_GENERIC.java index a78d873..03afd57 100644 --- a/src/de/steamwar/linkage/typesold/DisableLink.java +++ b/src/de/steamwar/linkage/types/Enable_GENERIC.java @@ -1,7 +1,7 @@ /* * This file is a part of the SteamWar software. * - * Copyright (C) 2022 SteamWar.de-Serverteam + * 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 @@ -17,24 +17,23 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.typesold; +package de.steamwar.linkage.types; -import de.steamwar.linkage.LinkageTypeOld; +import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -import java.util.Set; -public class DisableLink implements LinkageTypeOld { +public class Enable_GENERIC implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - return interfaces.contains("de.steamwar.linkage.api.Disable"); + public String method() { + return "link"; } @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - linkageTypeMethod.addLine(instance + ".disable();"); + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + method.addLine(instance + ".enable();"); } } diff --git a/src/de/steamwar/linkage/typesold/Command.java b/src/de/steamwar/linkage/types/Listener_BUNGEE.java similarity index 53% rename from src/de/steamwar/linkage/typesold/Command.java rename to src/de/steamwar/linkage/types/Listener_BUNGEE.java index d890a49..327b19a 100644 --- a/src/de/steamwar/linkage/typesold/Command.java +++ b/src/de/steamwar/linkage/types/Listener_BUNGEE.java @@ -1,7 +1,7 @@ /* * This file is a part of the SteamWar software. * - * Copyright (C) 2022 SteamWar.de-Serverteam + * 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 @@ -17,29 +17,25 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.typesold; +package de.steamwar.linkage.types; -import de.steamwar.linkage.LinkageTypeOld; +import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -import java.util.Set; -public class Command implements LinkageTypeOld { +public class Listener_BUNGEE implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - return superClass.equals("de.steamwar.command.SWCommand"); + public String method() { + return "link"; } @Override - public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - linkageTypeMethod.addLine(instance + ";"); - } - - @Override - public void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - linkageTypeMethod.addLine(instance + ".setMessage(" + getPluginMain() + ".MESSAGE);"); + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); + buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); + method.addLine("ProxyServer.getInstance().getPluginManager().registerListener(BungeeCore.get(), " + instance + ");"); } } diff --git a/src/de/steamwar/linkage/typesold/ListenerLink.java b/src/de/steamwar/linkage/types/Listener_SPIGOT.java similarity index 74% rename from src/de/steamwar/linkage/typesold/ListenerLink.java rename to src/de/steamwar/linkage/types/Listener_SPIGOT.java index 5a96d73..4d78b08 100644 --- a/src/de/steamwar/linkage/typesold/ListenerLink.java +++ b/src/de/steamwar/linkage/types/Listener_SPIGOT.java @@ -17,10 +17,9 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.typesold; +package de.steamwar.linkage.types; -import de.steamwar.linkage.Context; -import de.steamwar.linkage.LinkageTypeOld; +import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.FieldBuilder; import de.steamwar.linkage.plan.MethodBuilder; @@ -30,28 +29,16 @@ import javax.lang.model.element.*; import javax.lang.model.type.DeclaredType; import java.util.HashMap; import java.util.Map; -import java.util.Set; -public class ListenerLink implements LinkageTypeOld { +public class Listener_SPIGOT implements LinkageType { @Override - public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - if (context == Context.BUNGEE) { - return interfaces.contains("net.md_5.bungee.api.plugin.Listener"); - } else { - return interfaces.contains("org.bukkit.event.Listener"); - } + public String method() { + return "link"; } @Override - public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); - buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); - linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().registerListener(BungeeCore.get(), " + instance + ");"); - } - - @Override - public void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { Map eventClasses = new HashMap<>(); Map eventMethods = new HashMap<>(); @@ -88,12 +75,11 @@ public class ListenerLink implements LinkageTypeOld { methodBuilder.addLine("};"); methodBuilder.addLine("handlerList" + eventType.getSimpleName() + ".register(new RegisteredListener(listener, eventExecutor, eventPriority, " + getPluginMain() + ".getInstance(), ignoreCancelled));"); buildPlan.addMethod(methodBuilder); - linkageTypeMethod.addLine("handlerList" + eventType.getSimpleName() + " = " + eventType.getSimpleName() + ".getHandlerList();"); + method.addLine("handlerList" + eventType.getSimpleName() + " = " + eventType.getSimpleName() + ".getHandlerList();"); }); - buildPlan.addImport(typeElement.getQualifiedName().toString()); String localInstance = "local" + typeElement.getSimpleName().toString(); - linkageTypeMethod.addLine(typeElement.getSimpleName() + " " + localInstance + " = " + instance + ";"); + method.addLine(typeElement.getSimpleName() + " " + localInstance + " = " + instance + ";"); eventMethods.forEach((type, executableElement) -> { AnnotationMirror eventHandler = executableElement.getAnnotationMirrors().stream().filter(annotationMirror -> annotationMirror.getAnnotationType().asElement().getSimpleName().toString().equals("EventHandler")).findFirst().orElse(null); if (eventHandler == null) { @@ -108,7 +94,7 @@ public class ListenerLink implements LinkageTypeOld { ignoreCancelled = entry.getValue().getValue().toString(); } } - linkageTypeMethod.addLine(type.getSimpleName().toString() + "(" + localInstance + ", " + localInstance + "::" + executableElement.getSimpleName().toString() + ", EventPriority." + priority + ", " + ignoreCancelled + ");"); + method.addLine(type.getSimpleName().toString() + "(" + localInstance + ", " + localInstance + "::" + executableElement.getSimpleName().toString() + ", EventPriority." + priority + ", " + ignoreCancelled + ");"); }); } } diff --git a/src/de/steamwar/linkage/typesold/Plain.java b/src/de/steamwar/linkage/types/Plain_GENERIC.java similarity index 73% rename from src/de/steamwar/linkage/typesold/Plain.java rename to src/de/steamwar/linkage/types/Plain_GENERIC.java index 25258fc..eca2830 100644 --- a/src/de/steamwar/linkage/typesold/Plain.java +++ b/src/de/steamwar/linkage/types/Plain_GENERIC.java @@ -1,7 +1,7 @@ /* * This file is a part of the SteamWar software. * - * Copyright (C) 2022 SteamWar.de-Serverteam + * 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 @@ -17,18 +17,23 @@ * along with this program. If not, see . */ -package de.steamwar.linkage.typesold; +package de.steamwar.linkage.types; -import de.steamwar.linkage.LinkageTypeOld; +import de.steamwar.linkage.LinkageType; import de.steamwar.linkage.plan.BuildPlan; import de.steamwar.linkage.plan.MethodBuilder; import javax.lang.model.element.TypeElement; -public class Plain implements LinkageTypeOld { +public class Plain_GENERIC implements LinkageType { @Override - public void generateCode(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - linkageTypeMethod.addLine(instance + ";"); + public String method() { + return "link"; + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + method.addLine(instance + ";"); } } diff --git a/src/de/steamwar/linkage/types/SWCommand_BUNGEE.java b/src/de/steamwar/linkage/types/SWCommand_BUNGEE.java new file mode 100644 index 0000000..5db62c4 --- /dev/null +++ b/src/de/steamwar/linkage/types/SWCommand_BUNGEE.java @@ -0,0 +1,39 @@ +/* + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +import javax.lang.model.element.TypeElement; + +public class SWCommand_BUNGEE implements LinkageType { + + @Override + public String method() { + return "link"; + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + method.addLine(instance + ";"); + } +} diff --git a/src/de/steamwar/linkage/types/SWCommand_SPIGOT.java b/src/de/steamwar/linkage/types/SWCommand_SPIGOT.java new file mode 100644 index 0000000..96e3f77 --- /dev/null +++ b/src/de/steamwar/linkage/types/SWCommand_SPIGOT.java @@ -0,0 +1,39 @@ +/* + * This file is a part of the SteamWar software. + * + * Copyright (C) 2020 SteamWar.de-Serverteam + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +import javax.lang.model.element.TypeElement; + +public class SWCommand_SPIGOT implements LinkageType { + + @Override + public String method() { + return "link"; + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + method.addLine(instance + ".setMessage(" + getPluginMain() + ".MESSAGE);"); + } +} diff --git a/src/de/steamwar/linkage/typesold/UnlinkListener.java b/src/de/steamwar/linkage/typesold/UnlinkListener.java deleted file mode 100644 index 94e4662..0000000 --- a/src/de/steamwar/linkage/typesold/UnlinkListener.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * This file is a part of the SteamWar software. - * - * Copyright (C) 2020 SteamWar.de-Serverteam - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - * - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . - */ - -package de.steamwar.linkage.typesold; - -import de.steamwar.linkage.Context; -import de.steamwar.linkage.LinkageTypeOld; -import de.steamwar.linkage.plan.BuildPlan; -import de.steamwar.linkage.plan.MethodBuilder; - -import javax.lang.model.element.TypeElement; -import java.util.Set; - -public class UnlinkListener implements LinkageTypeOld { - - @Override - public boolean requirements(String superClass, Set interfaces, TypeElement typeElement) { - if (context == Context.BUNGEE) { - return interfaces.contains("net.md_5.bungee.api.plugin.Listener"); - } else { - return interfaces.contains("org.bukkit.event.Listener"); - } - } - - @Override - public void generateCodeBungee(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - buildPlan.addImport("net.md_5.bungee.api.ProxyServer"); - buildPlan.addImport("de.steamwar.bungeecore.BungeeCore"); - linkageTypeMethod.addLine("ProxyServer.getInstance().getPluginManager().unregisterListener(" + instance + ");"); - } - - @Override - public void generateCodeSpigot(BuildPlan buildPlan, MethodBuilder linkageTypeMethod, String instance, TypeElement typeElement) { - buildPlan.addImport("org.bukkit.event.HandlerList"); - linkageTypeMethod.addLine("HandlerList.unregisterAll(" + instance + ");"); - } -} From f0151f2c8d85b7fce92cfa1546484ba6b8229740 Mon Sep 17 00:00:00 2001 From: yoyosource Date: Sat, 24 Sep 2022 13:38:00 +0200 Subject: [PATCH 27/28] Update some stuff --- src/de/steamwar/linkage/LinkageProcessor.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java index 83f6794..f2f245c 100644 --- a/src/de/steamwar/linkage/LinkageProcessor.java +++ b/src/de/steamwar/linkage/LinkageProcessor.java @@ -166,7 +166,9 @@ public class LinkageProcessor extends AbstractProcessor { } neededFields.forEach((s, typeElement) -> { buildPlan.addImport(typeElement.getQualifiedName().toString()); - buildPlan.addField(new FieldBuilder(typeElement.getSimpleName().toString(), typeElement.getSimpleName().toString(), "new " + typeElement.getSimpleName().toString() + "()")); + String t = typeElement.getSimpleName().toString(); + t = t.substring(0, 1).toLowerCase() + t.substring(1); + buildPlan.addField(new FieldBuilder(typeElement.getSimpleName().toString(), t, "new " + typeElement.getSimpleName().toString() + "()")); }); Map methods = new HashMap<>(); @@ -205,7 +207,8 @@ public class LinkageProcessor extends AbstractProcessor { private String getElement(TypeElement typeElement, Map neededFields) { if (neededFields.containsKey(typeElement.getQualifiedName().toString())) { - return typeElement.getSimpleName().toString(); + String s = typeElement.getSimpleName().toString(); + return s.substring(0, 1).toLowerCase() + s.substring(1); } return "new " + typeElement.getSimpleName().toString() + "()"; } From e02930f124322a1d3a8be7e20a674146348c3a1d Mon Sep 17 00:00:00 2001 From: yoyosource Date: Sat, 24 Sep 2022 13:48:40 +0200 Subject: [PATCH 28/28] Add PacketHandler_GENERIC --- .../linkage/types/PacketHandler_GENERIC.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 src/de/steamwar/linkage/types/PacketHandler_GENERIC.java diff --git a/src/de/steamwar/linkage/types/PacketHandler_GENERIC.java b/src/de/steamwar/linkage/types/PacketHandler_GENERIC.java new file mode 100644 index 0000000..630f6f9 --- /dev/null +++ b/src/de/steamwar/linkage/types/PacketHandler_GENERIC.java @@ -0,0 +1,39 @@ +/* + * 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 . + */ + +package de.steamwar.linkage.types; + +import de.steamwar.linkage.LinkageType; +import de.steamwar.linkage.plan.BuildPlan; +import de.steamwar.linkage.plan.MethodBuilder; + +import javax.lang.model.element.TypeElement; + +public class PacketHandler_GENERIC implements LinkageType { + + @Override + public String method() { + return "link"; + } + + @Override + public void generateCode(BuildPlan buildPlan, MethodBuilder method, String instance, TypeElement typeElement) { + method.addLine(instance + ".register();"); + } +}