Use deferred where needed instead of a load method on all registries

core/src/main/java/org/geysermc/geyser/GeyserImpl.java

@@ -236,7 +236,6 @@ public void initialize() {
         Both the block registries and the common registries depend on each other,
         so maintaining this order is crucial for Geyser to load.
          */
-        BlockRegistries.load();
         Registries.load();
         BlockRegistries.populate();
         Registries.populate();

core/src/main/java/org/geysermc/geyser/registry/AbstractMappedDeferredRegistry.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2024 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Geyser
+ */
+
+package org.geysermc.geyser.registry;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.geysermc.geyser.registry.loader.RegistryLoader;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public abstract class AbstractMappedDeferredRegistry<K, V, M extends Map<K, V>, R extends AbstractMappedRegistry<K, V, M>> extends DeferredRegistry<M, R> {
+    protected <I> AbstractMappedDeferredRegistry(Function<RegistryLoader<I, M>, R> registryLoader, RegistryLoader<I, M> deferredLoader) {
+        super(registryLoader, deferredLoader);
+    }
+
+    protected <I> AbstractMappedDeferredRegistry(Function<RegistryLoader<I, M>, R> registryLoader, Supplier<RegistryLoader<I, M>> deferredLoader) {
+        super(registryLoader, deferredLoader);
+    }
+
+    protected <I> AbstractMappedDeferredRegistry(I input, RegistryInitializer<M, R> registryInitializer, RegistryLoader<I, M> deferredLoader) {
+        super(input, registryInitializer, deferredLoader);
+    }
+
+    protected <I> AbstractMappedDeferredRegistry(I input, RegistryInitializer<M, R> registryInitializer, Supplier<RegistryLoader<I, M>> deferredLoader) {
+        super(input, registryInitializer, deferredLoader);
+    }
+
+    /**
+     * Returns the value registered by the given key.
+     *
+     * @param key the key
+     * @return the value registered by the given key.
+     */
+    public @Nullable V get(K key) {
+        return get().get(key);
+    }
+
+    /**
+     * Returns and maps the value by the given key if present.
+     *
+     * @param key the key
+     * @param mapper the mapper
+     * @param <U> the type
+     * @return the mapped value from the given key if present
+     */
+    public <U> Optional<U> map(K key, Function<? super V, ? extends U> mapper) {
+        V value = this.get(key);
+        if (value == null) {
+            return Optional.empty();
+        } else {
+            return Optional.ofNullable(mapper.apply(value));
+        }
+    }
+
+    /**
+     * Returns the value registered by the given key or the default value
+     * specified if null.
+     *
+     * @param key the key
+     * @param defaultValue the default value
+     * @return the value registered by the given key or the default value
+     *         specified if null.
+     */
+    public V getOrDefault(K key, V defaultValue) {
+        return get().getOrDefault(key, defaultValue);
+    }
+
+    /**
+     * Registers a new value into this registry with the given key.
+     *
+     * @param key the key
+     * @param value the value
+     * @return a new value into this registry with the given key.
+     */
+    public V register(K key, V value) {
+        return get().put(key, value);
+    }
+}

core/src/main/java/org/geysermc/geyser/registry/BlockRegistries.java

@@ -69,7 +69,7 @@ public class BlockRegistries {
     /**
      * A mapped registry containing which holds block IDs to its {@link BlockCollision}.
      */
-    public static final ListRegistry<BlockCollision> COLLISIONS = ListRegistry.create(Pair.of("org.geysermc.geyser.translator.collision.CollisionRemapper", "mappings/collisions.nbt"), CollisionRegistryLoader::new);
+    public static final ListDeferredRegistry<BlockCollision> COLLISIONS = ListDeferredRegistry.create(Pair.of("org.geysermc.geyser.translator.collision.CollisionRemapper", "mappings/collisions.nbt"), CollisionRegistryLoader::new);
 
     /**
      * A registry which stores Java IDs to {@link Block}, containing miscellaneous information about
@@ -130,23 +130,6 @@ public class BlockRegistries {
      */
     public static final SimpleMappedRegistry<String, CustomSkull> CUSTOM_SKULLS = SimpleMappedRegistry.create(RegistryLoaders.empty(Object2ObjectOpenHashMap::new));
 
-    public static void load() {
-        BLOCKS.load();
-        BLOCK_STATES.load();
-        // collisions are loaded later, because they are initialized later
-        JAVA_BLOCKS.load();
-        JAVA_IDENTIFIER_TO_ID.load();
-        WATERLOGGED.load();
-        INTERACTIVE.load();
-        INTERACTIVE_MAY_BUILD.load();
-        CUSTOM_BLOCKS.load();
-        CUSTOM_BLOCK_STATE_OVERRIDES.load();
-        NON_VANILLA_BLOCK_STATE_OVERRIDES.load();
-        CUSTOM_BLOCK_ITEM_OVERRIDES.load();
-        EXTENDED_COLLISION_BOXES.load();
-        CUSTOM_SKULLS.load();
-    }
-
     public static void populate() {
         Blocks.VAULT.javaId(); // FIXME
         CustomSkullRegistryPopulator.populate();
@@ -160,5 +143,4 @@ public static void populate() {
         BlockRegistryPopulator.populate(BlockRegistryPopulator.Stage.INIT_BEDROCK);
         BlockRegistryPopulator.populate(BlockRegistryPopulator.Stage.POST_INIT);
     }
-
 }

core/src/main/java/org/geysermc/geyser/registry/DeferredRegistry.java

@@ -43,32 +43,36 @@
  *
  * @param <M> the value being held by the registry
  */
-public final class DeferredRegistry<M> implements IRegistry<M> {
-    private final Registry<M> backingRegistry;
+class DeferredRegistry<M, R extends IRegistry<M>> implements IRegistry<M> {
+    private final R backingRegistry;
     private final Supplier<M> loader;
 
     private boolean loaded;
 
-    private <I> DeferredRegistry(Function<RegistryLoader<I, M>, Registry<M>> registryLoader, RegistryLoader<I, M> deferredLoader) {
+    protected <I> DeferredRegistry(Function<RegistryLoader<I, M>, R> registryLoader, RegistryLoader<I, M> deferredLoader) {
         this.backingRegistry = registryLoader.apply(RegistryLoaders.uninitialized());
         this.loader = () -> deferredLoader.load(null);
     }
 
-    private <I> DeferredRegistry(Function<RegistryLoader<I, M>, Registry<M>> registryLoader, Supplier<RegistryLoader<I, M>> deferredLoader) {
+    protected <I> DeferredRegistry(Function<RegistryLoader<I, M>, R> registryLoader, Supplier<RegistryLoader<I, M>> deferredLoader) {
         this.backingRegistry = registryLoader.apply(RegistryLoaders.uninitialized());
         this.loader = () -> deferredLoader.get().load(null);
     }
 
-    private <I> DeferredRegistry(I input, RegistryInitializer<M> registryInitializer, RegistryLoader<I, M> deferredLoader) {
+    protected <I> DeferredRegistry(I input, RegistryInitializer<M, R> registryInitializer, RegistryLoader<I, M> deferredLoader) {
         this.backingRegistry = registryInitializer.initialize(input, RegistryLoaders.uninitialized());
         this.loader = () -> deferredLoader.load(input);
     }
 
-    private <I> DeferredRegistry(I input, RegistryInitializer<M> registryInitializer, Supplier<RegistryLoader<I, M>> deferredLoader) {
+    protected <I> DeferredRegistry(I input, RegistryInitializer<M, R> registryInitializer, Supplier<RegistryLoader<I, M>> deferredLoader) {
         this.backingRegistry = registryInitializer.initialize(input, RegistryLoaders.uninitialized());
         this.loader = () -> deferredLoader.get().load(input);
     }
 
+    protected R backingRegistry() {
+        return this.backingRegistry;
+    }
+
     /**
      * Gets the underlying value held by this registry.
      *
@@ -119,64 +123,12 @@ public boolean loaded() {
         return this.loaded;
     }
 
-    /**
-     * Creates a new deferred registry.
-     *
-     * @param registryLoader the registry loader
-     * @param deferredLoader the deferred loader
-     * @param <I> the input type
-     * @param <M> the registry type
-     * @return the new deferred registry
-     */
-    public static <I, M> DeferredRegistry<M> create(Function<RegistryLoader<I, M>, Registry<M>> registryLoader, RegistryLoader<I, M> deferredLoader) {
-        return new DeferredRegistry<>(registryLoader, deferredLoader);
-    }
-
-    /**
-     * Creates a new deferred registry.
-     *
-     * @param registryLoader the registry loader
-     * @param deferredLoader the deferred loader
-     * @param <I> the input type
-     * @param <M> the registry type
-     * @return the new deferred registry
-     */
-    public static <I, M> DeferredRegistry<M> create(Function<RegistryLoader<I, M>, Registry<M>> registryLoader, Supplier<RegistryLoader<I, M>> deferredLoader) {
-        return new DeferredRegistry<>(registryLoader, deferredLoader);
-    }
-
-    /**
-     * Creates a new deferred registry.
-     *
-     * @param registryInitializer the registry initializer
-     * @param deferredLoader the deferred loader
-     * @param <I> the input type
-     * @param <M> the registry type
-     * @return the new deferred registry
-     */
-    public static <I, M> DeferredRegistry<M> create(I input, RegistryInitializer<M> registryInitializer, RegistryLoader<I, M> deferredLoader) {
-        return new DeferredRegistry<>(input, registryInitializer, deferredLoader);
-    }
-
-    /**
-     * Creates a new deferred registry.
-     *
-     * @param registryInitializer the registry initializer
-     * @param deferredLoader the deferred loader
-     * @param <I> the input type
-     * @param <M> the registry type
-     * @return the new deferred registry
-     */
-    public static <I, M> DeferredRegistry<M> create(I input, RegistryInitializer<M> registryInitializer, Supplier<RegistryLoader<I, M>> deferredLoader) {
-        return new DeferredRegistry<>(input, registryInitializer, deferredLoader);
-    }
-
     /**
      * A registry initializer.
      *
      * @param <M> the registry type
      */
-    interface RegistryInitializer<M> {
+    public interface RegistryInitializer<M, R extends IRegistry<M>> {
 
         /**
          * Initializes the registry.
@@ -186,6 +138,6 @@ interface RegistryInitializer<M> {
          * @param <I> the input type
          * @return the initialized registry
          */
-        <I> Registry<M> initialize(I input, RegistryLoader<I, M> registryLoader);
+        <I> R initialize(I input, RegistryLoader<I, M> registryLoader);
     }
 }