Fix: Converting back fails for nested collections of complex ConfigurationElements

Note that you now have to set a nesting level when using nested
collections that require the ElementType annotation.

Author: Exlll

ConfigLib-Bukkit/src/main/resources/plugin.yml

@@ -1,5 +1,5 @@
 name: ConfigLib
 author: Exlll
 
-version: 2.0.2
+version: 2.0.3
 main: de.exlll.configlib.ConfigLib

ConfigLib-Bungee/src/main/resources/plugin.yml

@@ -1,5 +1,5 @@
 name: ConfigLib
 author: Exlll
 
-version: 2.0.2
+version: 2.0.3
 main: de.exlll.configlib.ConfigLib

ConfigLib-Core/src/main/java/de/exlll/configlib/Converter.java

@@ -67,6 +67,8 @@ final class ConversionInfo {
         private final Class<?> elementType;
         private final String fieldName;
         private final Configuration.Properties props;
+        private final int nestingLevel;
+        private int currentNestingLevel;
 
         private ConversionInfo(Field field, Object instance, Object mapValue,
                                Configuration.Properties props) {
@@ -79,6 +81,7 @@ private ConversionInfo(Field field, Object instance, Object mapValue,
             this.fieldName = field.getName();
             this.props = props;
             this.elementType = elementType(field);
+            this.nestingLevel = nestingLevel(field);
         }
 
         private static Class<?> elementType(Field field) {
@@ -89,6 +92,14 @@ private static Class<?> elementType(Field field) {
             return null;
         }
 
+        private static int nestingLevel(Field field) {
+            if (field.isAnnotationPresent(ElementType.class)) {
+                ElementType et = field.getAnnotation(ElementType.class);
+                return et.nestingLevel();
+            }
+            return -1;
+        }
+
         static ConversionInfo of(Field field, Object instance,
                                  Configuration.Properties props) {
             return new ConversionInfo(field, instance, null, props);
@@ -192,5 +203,17 @@ public Class<?> getElementType() {
         public boolean hasElementType() {
             return elementType != null;
         }
+
+        int getNestingLevel() {
+            return nestingLevel;
+        }
+
+        int getCurrentNestingLevel() {
+            return currentNestingLevel;
+        }
+
+        void incCurrentNestingLevel() {
+            currentNestingLevel++;
+        }
     }
 }

ConfigLib-Core/src/main/java/de/exlll/configlib/Converters.java

@@ -344,26 +344,48 @@ public void preConvertFrom(ConversionInfo info) {
     private static Function<Object, ?> createToConversionFunction(
             Object element, ConversionInfo info
     ) {
-        return o -> selectNonSimpleConverter(element.getClass(), info)
-                .convertTo(o, info);
+        checkNestingLevel(element, info);
+        if (Reflect.isContainerType(element.getClass())) {
+            info.incCurrentNestingLevel();
+        }
+        Converter<Object, ?> converter = selectNonSimpleConverter(
+                element.getClass(), info
+        );
+        return o -> converter.convertTo(o, info);
     }
 
     private static Function<Object, ?> createFromConversionFunction(
             Object element, ConversionInfo info
     ) {
-        if ((element instanceof Map<?, ?>) && isTypeMap((Map<?, ?>) element)) {
+        boolean currentLevelSameAsExpected =
+                info.getNestingLevel() == info.getCurrentNestingLevel();
+        checkCurrentLevelSameAsExpectedRequiresMapOrString(
+                currentLevelSameAsExpected, element, info
+        );
+        if ((element instanceof Map<?, ?>) && currentLevelSameAsExpected) {
             return o -> {
                 Map<String, Object> map = toTypeMap(o, null);
                 Object inst = Reflect.newInstance(info.getElementType());
                 FieldMapper.instanceFromMap(inst, map, info.getProperties());
                 return inst;
             };
+        } else if ((element instanceof String) && currentLevelSameAsExpected) {
+            return createNonSimpleConverter(element, info);
         } else {
-            return o -> selectNonSimpleConverter(element.getClass(), info)
-                    .convertFrom(o, info);
+            info.incCurrentNestingLevel();
+            return createNonSimpleConverter(element, info);
         }
     }
 
+    private static Function<Object, ?> createNonSimpleConverter(
+            Object element, ConversionInfo info
+    ) {
+        Converter<?, Object> converter = selectNonSimpleConverter(
+                element.getClass(), info
+        );
+        return o -> converter.convertFrom(o, info);
+    }
+
     private static Map<String, Object> toTypeMap(Object value, String fn) {
         checkIsMap(value, fn);
         checkMapKeysAreStrings((Map<?, ?>) value, fn);

ConfigLib-Core/src/main/java/de/exlll/configlib/Validator.java

@@ -315,6 +315,37 @@ static void checkElementIsConvertibleToConfigurationElement(
         }
     }
 
+    static void checkNestingLevel(Object element, ConversionInfo info) {
+        if (!Reflect.isContainerType(element.getClass())) {
+            if (info.getNestingLevel() != info.getCurrentNestingLevel()) {
+                String msg = "Field '" + info.getFieldName() + "' of class " +
+                        "'" + getClsName(info.getInstance().getClass()) + "' " +
+                        "has a nesting level of " + info.getNestingLevel() +
+                        " but the first object of type '" +
+                        getClsName(info.getElementType()) + "' was found on " +
+                        "level " + info.getCurrentNestingLevel() + ".";
+                throw new ConfigurationException(msg);
+            }
+        }
+    }
+
+    static void checkCurrentLevelSameAsExpectedRequiresMapOrString(
+            boolean currentLevelSameAsExpected,
+            Object element, ConversionInfo info
+    ) {
+        boolean isMapOrString = (element instanceof Map<?, ?>) ||
+                (element instanceof String);
+        if (currentLevelSameAsExpected && !isMapOrString) {
+            Class<?> cls = info.getInstance().getClass();
+            String msg = "Field '" + info.getFieldName() + "' of class '" +
+                    getClsName(cls) + "' has a nesting level" +
+                    " of " + info.getNestingLevel() + " but element '" + element +
+                    "' of type '" + getClsName(element.getClass()) + "' cannot be " +
+                    "converted to '" + getClsName(info.getElementType()) + "'.";
+            throw new ConfigurationException(msg);
+        }
+    }
+
     static void checkElementTypeIsEnumType(Class<?> type, ConversionInfo info) {
         if (!Reflect.isEnumType(type)) {
             String msg = "Element type '" + getClsName(type) + "' of field " +

ConfigLib-Core/src/main/java/de/exlll/configlib/annotation/ElementType.java

@@ -10,9 +10,21 @@
  * This annotation must only be used if a {@code Collection} or {@code Map} contains
  * elements whose type is not simple. Note that {@code Map} keys can only be of some
  * simple type.
+ * <p>
+ * If collections are nested, the {@code nestingLevel} must be set. Examples:
+ * <ul>
+ * <li>nestingLevel 1: {@code List<List<T>>}</li>
+ * <li>nestingLevel 1: {@code List<Set<T>>}</li>
+ * <li>nestingLevel 1: {@code List<Map<String, T>>}</li>
+ * <li>nestingLevel 2: {@code List<List<List<T>>>}</li>
+ * <li>nestingLevel 2: {@code List<Set<List<T>>>}</li>
+ * <li>nestingLevel 2: {@code List<List<Map<String, T>>>}</li>
+ * </ul>
  */
 @Target(java.lang.annotation.ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface ElementType {
     Class<?> value();
+
+    int nestingLevel() default 0;
 }

ConfigLib-Core/src/test/java/de/exlll/configlib/FieldMapperConverterTest.java

@@ -342,7 +342,7 @@ class A {
     @Test
     void instanceFromMapCatchesClassCastExceptionOfUnknownEnumConstantsInLists() {
         class A {
-            @ElementType(LocalTestEnum.class)
+            @ElementType(value = LocalTestEnum.class, nestingLevel = 1)
             List<List<LocalTestEnum>> l = listOf();
         }
         Map<String, Object> map = mapOf(
@@ -359,7 +359,7 @@ class A {
     @Test
     void instanceFromMapCatchesClassCastExceptionOfUnknownEnumConstantsInSets() {
         class A {
-            @ElementType(LocalTestEnum.class)
+            @ElementType(value = LocalTestEnum.class, nestingLevel = 1)
             Set<List<LocalTestEnum>> s = setOf();
         }
         Map<String, Object> map = mapOf(
@@ -376,7 +376,7 @@ class A {
     @Test
     void instanceFromMapCatchesClassCastExceptionOfUnknownEnumConstantsInMaps() {
         class A {
-            @ElementType(LocalTestEnum.class)
+            @ElementType(value = LocalTestEnum.class, nestingLevel = 1)
             Map<Integer, List<LocalTestEnum>> m = mapOf();
         }
         Map<String, Object> map = mapOf(