GenericUtils.getParameterType

Author: hevav

src/main/java/net/elytrium/serializer/language/reader/AbstractReader.java

@@ -36,6 +36,7 @@
 import net.elytrium.serializer.custom.ClassSerializer;
 import net.elytrium.serializer.exceptions.ReflectionException;
 import net.elytrium.serializer.exceptions.SerializableReadException;
+import net.elytrium.serializer.utils.GenericUtils;
 
 public abstract class AbstractReader {
 
@@ -195,9 +196,11 @@ public Object readByType(@Nullable Field owner, @Nullable Object holder, Type ty
         return this.readGuessingType(owner);
       } else if (type instanceof ParameterizedType parameterizedType) {
         Class<?> clazz = (Class<?>) parameterizedType.getRawType();
-        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
-        return Map.class.isAssignableFrom(clazz) ? this.readMap(owner, actualTypeArguments[0], actualTypeArguments[1])
-            : List.class.isAssignableFrom(clazz) ? this.readList(owner, actualTypeArguments[0])
+        return Map.class.isAssignableFrom(clazz) ? this.readMap(owner,
+            GenericUtils.getParameterType(Map.class, parameterizedType, 0),
+            GenericUtils.getParameterType(Map.class, parameterizedType, 1))
+            : List.class.isAssignableFrom(clazz) ? this.readList(owner,
+            GenericUtils.getParameterType(List.class, parameterizedType, 0))
             : this.readGuessingType(owner);
       } else if (type instanceof Class<?> clazz) {
         if (Map.class.isAssignableFrom(clazz)) {

src/main/java/net/elytrium/serializer/language/reader/YamlReader.java

@@ -45,6 +45,7 @@
 import net.elytrium.serializer.placeholders.DefaultPlaceholderReplacer;
 import net.elytrium.serializer.placeholders.PlaceholderReplacer;
 import net.elytrium.serializer.placeholders.Placeholders;
+import net.elytrium.serializer.utils.GenericUtils;
 
 @SuppressWarnings({"SizeReplaceableByIsEmpty", "StringRepeatCanBeUsed"}) // Ignore modern methods, because we support up to Java 8.
 public class YamlReader extends AbstractReader {
@@ -188,15 +189,20 @@ private void updatePlaceholders(Object holder, Field node) throws ReflectiveOper
 
     if (placeholders != null) {
       PlaceholderReplacer<?, ?> replacer = null;
+      Object value = node.get(holder);
       if (placeholders.replacer() == DefaultPlaceholderReplacer.class) {
-        replacer = this.config.getRegisteredReplacer(node.getType());
+        if (value instanceof Collection<?>) {
+          replacer = this.config.getRegisteredReplacer(
+              (Class<?>) GenericUtils.getParameterType(Collection.class, node.getGenericType(), 0));
+        } else {
+          replacer = this.config.getRegisteredReplacer(node.getType());
+        }
       }
 
       if (replacer == null) {
         replacer = this.config.getAndCacheReplacer(placeholders.replacer());
       }
 
-      Object value = node.get(holder);
       if (this.config.isRegisterPlaceholdersForCollectionEntries() && value instanceof Collection<?> collection) {
         for (Object entry : collection) {
           Placeholders.addPlaceholders(entry, replacer, placeholders.wrapWithBraces(), placeholders.value());

src/main/java/net/elytrium/serializer/utils/GenericUtils.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2023 Elytrium
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package net.elytrium.serializer.utils;
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+
+public class GenericUtils {
+
+  public static int getParameterIndex(TypeVariable<?>[] variables, TypeVariable<?> expected) {
+    for (int i = 0; i < variables.length; ++i) {
+      if (variables[i].getName().equals(expected.getName())) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  public static Type getParameterTypeFromSuperclass(Class<?> parent, Type type, Type superclass, int searchIndex) {
+    Type superclassType = GenericUtils.getParameterType(parent, superclass, searchIndex);
+    if (superclassType instanceof TypeVariable<?> typeVariable && type instanceof ParameterizedType parameterizedType) {
+      Class<?> rawSuperclass = (Class<?>) parameterizedType.getRawType();
+      int index = GenericUtils.getParameterIndex(rawSuperclass.getTypeParameters(), typeVariable);
+      if (index != -1) {
+        return parameterizedType.getActualTypeArguments()[index];
+      }
+    }
+
+    return superclassType;
+  }
+
+  public static Type getParameterType(Class<?> parent, Type type, int index) {
+    if (type == null) {
+      return null;
+    }
+
+    Class<?> clazz = null;
+
+    if (type instanceof ParameterizedType parameterizedType) {
+      clazz = (Class<?>) parameterizedType.getRawType();
+      if (clazz.equals(parent)) {
+        return parameterizedType.getActualTypeArguments()[index];
+      }
+    }
+
+    if (type instanceof Class<?> typeClazz) {
+      clazz = typeClazz;
+    }
+
+    if (clazz != null) {
+      Type genericSuperclass = clazz.getGenericSuperclass();
+      Type superclassType = GenericUtils.getParameterTypeFromSuperclass(parent, type, genericSuperclass, index);
+      if (superclassType != null) {
+        return superclassType;
+      }
+
+      for (Type genericInterface : clazz.getGenericInterfaces()) {
+        Type genericInterfaceType = GenericUtils.getParameterTypeFromSuperclass(parent, type, genericInterface, index);
+        if (genericInterfaceType != null) {
+          return genericInterfaceType;
+        }
+      }
+    }
+
+    return null;
+  }
+}