wip: reworked DataComponentAdapters to be more generic and usable in multiple places

Author: roro1506HD

paper-server/src/main/java/io/papermc/paper/datacomponent/DataComponentAdapters.java

@@ -0,0 +1,27 @@
+package io.papermc.paper.datacomponent;
+
+import io.papermc.paper.registry.data.typed.AbstractTypedDataCollector;
+import io.papermc.paper.registry.data.typed.PaperTypedDataAdapter;
+import net.minecraft.core.Registry;
+import net.minecraft.core.component.DataComponentType;
+import net.minecraft.resources.ResourceKey;
+import org.bukkit.craftbukkit.util.Handleable;
+import java.util.Map;
+import java.util.function.Function;
+
+class PaperDataComponentTypeCollector extends AbstractTypedDataCollector<DataComponentType<?>> {
+
+    public PaperDataComponentTypeCollector(final Registry<DataComponentType<?>> registry, final Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters) {
+        super(registry, adapters);
+    }
+
+    // Not using @Override because of generic types
+    public <NMS, API extends Handleable<NMS>> void register(final DataComponentType<NMS> dataComponentType, final Function<NMS, API> vanillaToApi) {
+        super.register(dataComponentType, vanillaToApi);
+    }
+
+    // Not using @Override because of generic types
+    public <NMS, API> void register(final DataComponentType<NMS> dataComponentType, final Function<NMS, API> vanillaToApi, final Function<API, NMS> apiToVanilla) {
+        super.register(dataComponentType, vanillaToApi, apiToVanilla);
+    }
+}

paper-server/src/main/java/io/papermc/paper/datacomponent/PaperDataComponentType.java

@@ -0,0 +1,75 @@
+package io.papermc.paper.registry.data.typed;
+
+import com.mojang.serialization.Codec;
+import java.util.Map;
+import java.util.function.Function;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import org.bukkit.craftbukkit.util.Handleable;
+import org.jspecify.annotations.Nullable;
+
+// This class exists only to be implemented, implementations must override the following register method:
+//   void register(final TYPE type, final Function<NMS, API> vanillaToApi, final Function<API, NMS> apiToVanilla)
+// BUT should NOT use the @Override annotation, this is a hack around generics limitations to prevent
+// having to define generics on each register call as seen below, making collectors easier to read:
+//   collector.<NMSType, APIType>register(...)
+public abstract class AbstractTypedDataCollector<TYPE> implements PaperTypedDataCollector<TYPE> {
+
+    private final Registry<TYPE> registry;
+    private final Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters;
+
+    public AbstractTypedDataCollector(final Registry<TYPE> registry, final Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters) {
+        this.registry = registry;
+        this.adapters = adapters;
+    }
+
+    @Override
+    public void registerUntyped(final TYPE type) {
+        this.registerInternal(this.getKey(type), PaperTypedDataAdapters.UNIT_TO_API_CONVERTER, PaperTypedDataAdapter.API_TO_UNIT_CONVERTER, null);
+    }
+
+    @Override
+    public <NMS> void registerIdentity(final TYPE type, final Function<TYPE, @Nullable Codec<NMS>> codecGetter) {
+        this.registerInternal(this.getKey(type), Function.identity(), Function.identity(), codecGetter.apply(type));
+    }
+
+    @Override
+    public <NMS, API extends Handleable<NMS>> void register(final TYPE type, final Function<NMS, API> vanillaToApi) {
+        this.registerInternal(this.getKey(type), vanillaToApi, Handleable::getHandle, null);
+    }
+
+    @Override
+    public <NMS, API> void register(final TYPE type, final Function<NMS, API> vanillaToApi, final Function<API, NMS> apiToVanilla) {
+        this.registerInternal(this.getKey(type), vanillaToApi, apiToVanilla, null);
+    }
+
+    private ResourceKey<TYPE> getKey(final TYPE type) {
+        return this.registry.getResourceKey(type).orElseThrow();
+    }
+
+    void registerUnimplemented() {
+        for (final ResourceKey<TYPE> key : this.registry.registryKeySet()) {
+            if (!this.adapters.containsKey(key)) {
+                this.registerUnimplemented(key);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void registerUnimplemented(final ResourceKey<TYPE> key) {
+        this.registerInternal(key, PaperTypedDataAdapters.UNIMPLEMENTED_TO_API_CONVERTER, PaperTypedDataAdapter.API_TO_UNIMPLEMENTED_CONVERTER, null);
+    }
+
+    private <NMS, API> void registerInternal(
+        final ResourceKey<?> key,
+        final Function<NMS, API> vanillaToApi,
+        final Function<API, NMS> apiToVanilla,
+        final @Nullable Codec<NMS> codec
+    ) {
+        if (this.adapters.containsKey(key)) {
+            throw new IllegalStateException("Duplicate adapter registration for " + key);
+        }
+
+        this.adapters.put(key, new PaperTypedDataAdapter<>(apiToVanilla, vanillaToApi, codec));
+    }
+}

paper-server/src/main/java/io/papermc/paper/datacomponent/PaperDataComponentTypeCollector.java

@@ -1,16 +1,17 @@
-package io.papermc.paper.datacomponent;
+package io.papermc.paper.registry.data.typed;
 
+import com.mojang.serialization.Codec;
 import java.util.function.Function;
 import net.minecraft.core.Holder;
-import net.minecraft.core.component.DataComponentType;
 import net.minecraft.util.NullOps;
 import net.minecraft.util.Unit;
 import org.bukkit.craftbukkit.CraftRegistry;
+import org.jspecify.annotations.Nullable;
 
-public record DataComponentAdapter<NMS, API>(
+public record PaperTypedDataAdapter<NMS, API>(
     Function<API, NMS> apiToVanilla,
     Function<NMS, API> vanillaToApi,
-    boolean codecValidation
+    @Nullable Codec<NMS> codec
 ) {
     static final Function<Void, Unit> API_TO_UNIT_CONVERTER = $ -> Unit.INSTANCE;
 
@@ -26,10 +27,10 @@ public boolean isUnimplemented() {
         return this.apiToVanilla == API_TO_UNIMPLEMENTED_CONVERTER;
     }
 
-    public NMS toVanilla(final API value, final Holder<? extends DataComponentType<NMS>> type) {
+    public NMS toVanilla(final API value, final Holder<?> type) {
         final NMS nms = this.apiToVanilla.apply(value);
-        if (this.codecValidation && !type.value().isTransient()) {
-            type.value().codecOrThrow().encodeStart(CraftRegistry.getMinecraftRegistry().createSerializationContext(NullOps.INSTANCE), nms).ifError(error -> {
+        if (this.codec != null) {
+            this.codec.encodeStart(CraftRegistry.getMinecraftRegistry().createSerializationContext(NullOps.INSTANCE), nms).ifError(error -> {
                 throw new IllegalArgumentException("Failed to encode data component %s (%s)".formatted(type.unwrapKey().orElseThrow(), error.message()));
             });
         }

paper-server/src/main/java/io/papermc/paper/registry/data/typed/AbstractTypedDataCollector.java

@@ -0,0 +1,49 @@
+package io.papermc.paper.registry.data.typed;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.util.Unit;
+import org.jspecify.annotations.Nullable;
+
+public final class PaperTypedDataAdapters {
+
+    static final Function<Unit, Void> UNIT_TO_API_CONVERTER = $ -> {
+        throw new UnsupportedOperationException("Cannot convert the Unit type to an API value");
+    };
+
+    static final Function UNIMPLEMENTED_TO_API_CONVERTER = $ -> {
+        throw new UnsupportedOperationException("Cannot convert the an unimplemented type to an API value");
+    };
+
+    private final Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters;
+
+    private PaperTypedDataAdapters(Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters) {
+        this.adapters = adapters;
+    }
+
+    public static <TYPE, COLLECTOR extends AbstractTypedDataCollector<TYPE>> PaperTypedDataAdapters create(
+        Registry<TYPE> registry,
+        PaperTypedDataCollector.Factory<TYPE, COLLECTOR> collectorFactory,
+        Consumer<COLLECTOR> consumer
+    ) {
+        Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters = new HashMap<>();
+        COLLECTOR collector = collectorFactory.create(registry, adapters);
+
+        consumer.accept(collector);
+
+        // Loop through every entry in the registry and register any entry
+        // not already registered as unimplemented
+        collector.registerUnimplemented();
+
+        return new PaperTypedDataAdapters(adapters);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <RETURN> @Nullable RETURN getAdapter(ResourceKey<?> key) {
+        return (RETURN) this.adapters.get(key);
+    }
+}

…/datacomponent/DataComponentAdapter.java …ry/data/typed/PaperTypedDataAdapter.javapaper-server/src/main/java/io/papermc/paper/datacomponent/DataComponentAdapter.java renamed to paper-server/src/main/java/io/papermc/paper/registry/data/typed/PaperTypedDataAdapter.java paper-server/src/main/java/io/papermc/paper/datacomponent/DataComponentAdapter.java renamed to paper-server/src/main/java/io/papermc/paper/registry/data/typed/PaperTypedDataAdapter.java

@@ -0,0 +1,26 @@
+package io.papermc.paper.registry.data.typed;
+
+import com.mojang.serialization.Codec;
+import java.util.Map;
+import java.util.function.Function;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import org.bukkit.craftbukkit.util.Handleable;
+import org.jspecify.annotations.Nullable;
+
+public interface PaperTypedDataCollector<TYPE> {
+
+    void registerUntyped(final TYPE type);
+
+    <NMS> void registerIdentity(final TYPE type, final Function<TYPE, @Nullable Codec<NMS>> codecGetter);
+
+    <NMS, API extends Handleable<NMS>> void register(final TYPE type, final Function<NMS, API> vanillaToApi);
+
+    <NMS, API> void register(final TYPE type, final Function<NMS, API> vanillaToApi, final Function<API, NMS> apiToVanilla);
+
+    interface Factory<TYPE, COLLECTOR> {
+
+        COLLECTOR create(Registry<TYPE> registry, Map<ResourceKey<?>, PaperTypedDataAdapter<?, ?>> adapters);
+
+    }
+}

paper-server/src/main/java/io/papermc/paper/registry/data/typed/PaperTypedDataAdapters.java

@@ -0,0 +1,4 @@
+@NullMarked
+package io.papermc.paper.registry.data.typed;
+
+import org.jspecify.annotations.NullMarked;