Fixing Mappable copy method

Author: CroaBeast

src/main/java/me/croabeast/file/HashMappable.java

@@ -1,37 +1,51 @@
 package me.croabeast.file;
 
+import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
+import java.util.function.Supplier;
 
 /**
  * A concrete implementation of {@link Mappable} backed by a {@link HashMap}.
  * <p>
  * {@code HashMappable} associates integer keys with collections of elements of type {@code T}.
  * It extends {@code HashMap<Integer, C>} and implements the {@code Mappable} interface, providing
- * utility methods for ordering and copying the mapping. This implementation is intended as a base
- * class; certain methods (such as {@link #getStoredValues()}) must be overridden in subclasses or
- * specific instances to provide concrete functionality.
+ * utility methods for ordering and copying the mapping. In addition, it stores a {@link Supplier} to
+ * generate new instances of the collection type {@code C} when needed.
  * </p>
  *
  * @param <T> the type of elements stored in the collections.
  * @param <C> the type of collection that holds the elements.
  * @see Mappable
  */
+@Getter
 public class HashMappable<T, C extends Collection<T>> extends HashMap<Integer, C> implements Mappable<T, C, HashMappable<T, C>> {
 
     /**
-     * Constructs an empty {@code HashMappable}.
+     * A supplier for creating new instances of the collection type {@code C}.
      */
-    public HashMappable() {}
+    private final Supplier<C> supplier;
+
+    /**
+     * Constructs an empty {@code HashMappable} with the specified collection supplier.
+     *
+     * @param supplier a {@link Supplier} used to create new collections of type {@code C}; must not be {@code null}
+     */
+    public HashMappable(Supplier<C> supplier) {
+        super();
+        this.supplier = Objects.requireNonNull(supplier);
+    }
 
     /**
      * Constructs a new {@code HashMappable} with the mappings copied from the provided map.
      *
-     * @param map the map whose entries are to be placed in this mappable.
+     * @param supplier a {@link Supplier} used to create new collections of type {@code C}; must not be {@code null}
+     * @param map      the map whose entries are to be placed in this mappable
      */
-    public HashMappable(Map<Integer, ? extends C> map) {
+    public HashMappable(Supplier<C> supplier, Map<Integer, ? extends C> map) {
         super(map);
+        this.supplier = Objects.requireNonNull(supplier);
     }
 
     /**
@@ -42,49 +56,58 @@ public HashMappable(Map<Integer, ? extends C> map) {
      * containing the ordered entries.
      * </p>
      *
-     * @param comparator the comparator used for ordering the keys.
-     * @return a new {@code HashMappable} instance with entries ordered according to the comparator.
+     * @param comparator the comparator used for ordering the keys; must not be {@code null}
+     * @return a new {@code HashMappable} instance with entries ordered according to the comparator
      */
     @NotNull
     public HashMappable<T, C> order(Comparator<Integer> comparator) {
         TreeMap<Integer, C> map = new TreeMap<>(comparator);
-        map.putAll(this);
-        return new HashMappable<>(map);
+        forEach((k, v) -> {
+            C collection = supplier.get();
+            collection.addAll(v);
+            map.put(k, collection);
+        });
+        return new HashMappable<>(supplier, map);
     }
 
     /**
      * Creates a shallow copy of this {@code HashMappable}.
      * <p>
-     * The returned copy contains the same keys and values as this instance.
+     * The returned copy contains the same keys and values as this instance. Note that the collections
+     * associated with each key are also copied using the supplier, but their elements are not deep-cloned.
      * </p>
      *
-     * @return a new {@code HashMappable} instance with the same data.
+     * @return a new {@code HashMappable} instance with the same data as this instance.
      */
     @NotNull
     public HashMappable<T, C> copy() {
-        return new HashMappable<>(this);
+        HashMappable<T, C> mappable = new HashMappable<>(supplier);
+        forEach((k, v) -> {
+            C collection = supplier.get();
+            collection.addAll(v);
+            mappable.put(k, collection);
+        });
+        return mappable;
     }
 
     /**
-     * Retrieves all stored values combined into a single collection.
+     * Retrieves all stored values across all keys combined into a single collection.
      * <p>
-     * <b>Note:</b> This method is not implemented in {@code HashMappable} and throws an
-     * {@link UnsupportedOperationException}. It must be overridden in a subclass or a concrete
-     * instance to provide the desired behavior.
+     * This method collects all elements from each collection in the mapping and returns a new collection
+     * containing all these elements.
      * </p>
      *
-     * @return a collection containing all values from the mapping.
-     * @throws UnsupportedOperationException if this method is not overridden.
+     * @return a collection containing all values from the mapping
      */
     @NotNull
     public C getStoredValues() {
-        throw new UnsupportedOperationException("getStoredValues");
+        return getStoredValues(supplier);
     }
 
     /**
-     * Returns this instance.
+     * Returns this instance as a {@code HashMappable}.
      *
-     * @return this {@code HashMappable} instance.
+     * @return this {@code HashMappable} instance
      */
     @NotNull
     public HashMappable<T, C> instance() {

src/main/java/me/croabeast/file/MapUtils.java

@@ -19,11 +19,11 @@
  * </p>
  * <ul>
  *   <li>
- *     <b>Section-based mappables:</b> for mapping {@link ConfigurationSection} instances,
+ *     <b>Section-based mappable:</b> for mapping {@link ConfigurationSection} instances,
  *     represented by {@link AbstractSection} and its nested classes {@code SetImpl} and {@code ListImpl}.
  *   </li>
  *   <li>
- *     <b>Unit-based mappables:</b> for mapping configurable units (instances of {@link ConfigurableUnit}),
+ *     <b>Unit-based mappable:</b> for mapping configurable units (instances of {@link ConfigurableUnit}),
  *     represented by {@link AbstractUnit} and its nested classes {@code SetImpl} and {@code ListImpl}.
  *   </li>
  * </ul>
@@ -43,15 +43,17 @@ static abstract class AbstractMappable<T, C extends Collection<T>, M extends Map
         /**
          * Creates an empty {@code AbstractMappable}.
          */
-        AbstractMappable() {}
+        AbstractMappable() {
+            super();
+        }
 
         /**
          * Creates a new {@code AbstractMappable} instance and populates it with the given map.
          *
          * @param map the initial map data; if {@code null} or empty, the mappable will be empty.
          */
         AbstractMappable(Map<Integer, ? extends C> map) {
-            if (map != null && !map.isEmpty()) putAll(map);
+            super(map == null ? new HashMap<>() : map);
         }
     }
 
@@ -138,7 +140,7 @@ public List toList() {
             @NotNull
             public Set order(Comparator<Integer> comparator) {
                 TreeMap<Integer, java.util.Set<ConfigurationSection>> map = new TreeMap<>(comparator);
-                map.putAll(this);
+                forEach((k, v) -> map.put(k, new HashSet<>(v)));
                 return new SetImpl(map);
             }
 
@@ -149,7 +151,9 @@ public Set order(Comparator<Integer> comparator) {
              */
             @NotNull
             public Set copy() {
-                return new SetImpl(this);
+                Set set = new SetImpl();
+                forEach((k, v) -> set.put(k, new HashSet<>(v)));
+                return set;
             }
 
             /**
@@ -219,7 +223,7 @@ public Set toSet() {
             @NotNull
             public List order(Comparator<Integer> comparator) {
                 TreeMap<Integer, java.util.List<ConfigurationSection>> map = new TreeMap<>(comparator);
-                map.putAll(this);
+                forEach((k, v) -> map.put(k, new ArrayList<>(v)));
                 return new ListImpl(map);
             }
 
@@ -230,7 +234,9 @@ public List order(Comparator<Integer> comparator) {
              */
             @NotNull
             public List copy() {
-                return new ListImpl(this);
+                List list = new ListImpl();
+                forEach((k, v) -> list.put(k, new ArrayList<>(v)));
+                return list;
             }
 
             /**
@@ -315,7 +321,7 @@ public List<U> toList() {
             @NotNull
             public Set<U> order(Comparator<Integer> comparator) {
                 TreeMap<Integer, java.util.Set<U>> map = new TreeMap<>(comparator);
-                map.putAll(this);
+                forEach((k, v) -> map.put(k, new HashSet<>(v)));
                 return new SetImpl<>(map);
             }
 
@@ -326,7 +332,9 @@ public Set<U> order(Comparator<Integer> comparator) {
              */
             @NotNull
             public Set<U> copy() {
-                return new SetImpl<>(this);
+                Set<U> set = new SetImpl<>();
+                forEach((k, v) -> set.put(k, new HashSet<>(v)));
+                return set;
             }
 
             /**
@@ -382,7 +390,7 @@ public Set<U> toSet() {
             @NotNull
             public List<U> order(Comparator<Integer> comparator) {
                 TreeMap<Integer, java.util.List<U>> map = new TreeMap<>(comparator);
-                map.putAll(this);
+                forEach((k, v) -> map.put(k, new ArrayList<>(v)));
                 return new ListImpl<>(map);
             }
 
@@ -393,7 +401,9 @@ public List<U> order(Comparator<Integer> comparator) {
              */
             @NotNull
             public List<U> copy() {
-                return new ListImpl<U>(this);
+                List<U> list = new ListImpl<>();
+                forEach((k, v) -> list.put(k, new ArrayList<>(v)));
+                return list;
             }
 
             /**

src/main/java/me/croabeast/file/Mappable.java

@@ -83,13 +83,13 @@ default B order(boolean ascendant) {
      * Retrieves all stored values merged into a single collection, using the provided supplier to create the collection.
      *
      * @param supplier The supplier used to create a new collection instance.
-     * @param <X>      The type of the resulting collection.
+     * @param <V>      The type of the resulting collection.
      * @return A collection containing all stored values across all keys.
      */
     @NotNull
-    default <X extends Collection<T>> X getStoredValues(Supplier<X> supplier) {
+    default <V extends Collection<T>> V getStoredValues(Supplier<V> supplier) {
         Objects.requireNonNull(supplier);
-        X collection = supplier.get();
+        V collection = supplier.get();
         values().forEach(collection::addAll);
         return collection;
     }