Refactored to have assets use self reflection to identify with certain extensions

app/src/main/java/org/toop/Main.java

@@ -16,7 +16,9 @@ import java.nio.file.NotDirectoryException;
 public class Main {
     static void main(String[] args) throws IOException, UnsupportedAudioFileException, LineUnavailableException, InterruptedException {
 
-        AssetManager.loadAssets(new AssetLoader("app/src/main/resources/assets"));
+        AssetLoader.initialize("app/src/main/resources/assets");
+        AssetManager.loadAssets(AssetLoader.getInstance());
+
         var b = new NetworkingClientManager();
         var c = new SoundManager();
 

framework/pom.xml

@@ -102,6 +102,13 @@
             <version>25</version>
         </dependency>
 
+		<!-- https://mvnrepository.com/artifact/org.reflections/reflections -->
+		<dependency>
+			<groupId>org.reflections</groupId>
+			<artifactId>reflections</artifactId>
+			<version>0.10.2</version>
+		</dependency>
+
 	</dependencies>
 
 	<build>

framework/src/main/java/org/toop/framework/asset/AssetLoader.java

@@ -1,74 +1,102 @@
 package org.toop.framework.asset;
 
-import org.toop.framework.asset.resources.AudioAsset;
 import org.toop.framework.asset.resources.BaseResource;
-import org.toop.framework.asset.resources.ImageAsset;
 
 import java.io.File;
-import java.io.FileNotFoundException;
+import java.util.*;
-import java.util.ArrayList;
+import java.util.concurrent.ConcurrentHashMap;
-import java.util.Objects;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Function;
+
+import org.reflections.Reflections;
+import org.toop.framework.asset.resources.FileExtension;
 
 public class AssetLoader {
-    private final File rootFolder;
-    private final ArrayList<Asset<? extends BaseResource>> assets = new ArrayList<>();
 
-    public AssetLoader(File rootFolder) {
+    private static AssetLoader INSTANCE;
+
+    private final File rootFolder;
+    private final List<Asset<? extends BaseResource>> assets = new CopyOnWriteArrayList<>();
+    private final Map<String, Function<File, ? extends BaseResource>> registry = new ConcurrentHashMap<>();
+
+    private AssetLoader(File rootFolder) {
         this.rootFolder = rootFolder;
+        autoRegisterResources();
         fileSearcher(rootFolder);
     }
 
-    public AssetLoader(String rootFolder) {
+    public static synchronized void initialize(String rootFolderPath) {
-        this.rootFolder = new File(rootFolder);
+        if (INSTANCE == null) {
-        fileSearcher(this.rootFolder);
+            INSTANCE = new AssetLoader(new File(rootFolderPath));
+        }
     }
 
-    public File getRootFolder() {
+    public static AssetLoader getInstance() {
-        return this.rootFolder;
+        if (INSTANCE == null) {
+            throw new IllegalStateException("AssetLoader not initialized. Call initialize() first.");
+        }
+        return INSTANCE;
     }
 
-    public ArrayList<Asset<? extends BaseResource>> getAssets() {
+    public List<Asset<? extends BaseResource>> getAssets() {
-        return this.assets;
+        return new ArrayList<>(assets);
     }
 
-    private <T extends BaseResource> T resourceMapper(Class<T> type, File file) throws FileNotFoundException {
+    public <T extends BaseResource> void register(String extension, Function<File, T> factory) {
-        BaseResource resource = switch (getExtension(file.getName())) {
+        registry.put(extension, factory);
-            case "wav" -> new AudioAsset(file);
+    }
-            case "png" -> new ImageAsset(file);
+
-            default -> null;
+    private <T extends BaseResource> T resourceMapper(File file, Class<T> type) {
-        };
+        String ext = getExtension(file.getName());
+        Function<File, ? extends BaseResource> factory = registry.get(ext);
+
+        if (factory == null) return null;
+
+        BaseResource resource = factory.apply(file);
+
+        if (!type.isInstance(resource)) {
+            throw new IllegalArgumentException(
+                    "File " + file.getName() + " is not of type " + type.getSimpleName()
+            );
+        }
 
-        if (resource == null) return null;
-        if (!type.isInstance(resource))
-            throw new IllegalArgumentException("File " + file.getName() + " is not of type " + type);
         return type.cast(resource);
     }
 
-    public static String getExtension(String name) {
-        String extension = "";
-
-        int i = name.lastIndexOf('.');
-        if (i > 0) {
-            extension = name.substring(i+1);
-        }
-        return extension;
-    }
-
     private void fileSearcher(final File folder) {
-        for (final File fileEntry : Objects.requireNonNull(folder.listFiles())) {
+        for (File fileEntry : Objects.requireNonNull(folder.listFiles())) {
             if (fileEntry.isDirectory()) {
                 fileSearcher(fileEntry);
             } else {
-                try {
+                BaseResource resource = resourceMapper(fileEntry, BaseResource.class);
-                    BaseResource resource = resourceMapper(BaseResource.class, fileEntry); // generic token
+                if (resource != null) {
-                    if (resource != null) {
+                    assets.add(new Asset<>(fileEntry.getName(), resource));
-                        this.assets.add(new Asset<>(fileEntry.getName(), resource));
-                    }
-                } catch (FileNotFoundException e) {
-                    throw new RuntimeException(e);
                 }
             }
         }
     }
 
+    private void autoRegisterResources() {
+        Reflections reflections = new Reflections("org.toop.framework.asset.resources");
+        Set<Class<? extends BaseResource>> classes = reflections.getSubTypesOf(BaseResource.class);
+
+        for (Class<? extends BaseResource> cls : classes) {
+            if (!cls.isAnnotationPresent(FileExtension.class)) continue;
+            FileExtension annotation = cls.getAnnotation(FileExtension.class);
+            for (String ext : annotation.value()) {
+                registry.put(ext, file -> {
+                    try {
+                        return cls.getConstructor(File.class).newInstance(file);
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                });
+            }
+        }
+    }
+
+    public static String getExtension(String name) {
+        int i = name.lastIndexOf('.');
+        return (i > 0) ? name.substring(i + 1) : "";
+    }
 }

framework/src/main/java/org/toop/framework/asset/resources/AudioAsset.java

@@ -3,6 +3,7 @@ package org.toop.framework.asset.resources;
 import javax.sound.sampled.*;
 import java.io.*;
 
+@FileExtension({"wav"})
 public class AudioAsset extends BaseResource implements LoadableResource {
 
     private AudioInputStream audioInputStream = null;

framework/src/main/java/org/toop/framework/asset/resources/FileExtension.java

@@ -0,0 +1,12 @@
+package org.toop.framework.asset.resources;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface FileExtension {
+    String[] value();
+}

framework/src/main/java/org/toop/framework/asset/resources/ImageAsset.java

@@ -4,11 +4,12 @@ import javafx.scene.image.Image;
 import java.io.File;
 import java.io.FileNotFoundException;
 
+@FileExtension({"png"})
 public class ImageAsset extends BaseResource implements LoadableResource {
     private Image image;
     private boolean isLoaded = false;
 
-    public ImageAsset(final File file) throws FileNotFoundException {
+    public ImageAsset(final File file) {
         super(file);
     }