Immutable Components

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/ComponentRegistry.java

@@ -22,12 +22,19 @@
  */
 package org.ladysnake.cca.api.v3.component;
 
+import com.mojang.serialization.MapCodec;
+import net.minecraft.network.RegistryByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.codec.PacketCodecs;
 import net.minecraft.util.Identifier;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Contract;
+import org.ladysnake.cca.api.v3.component.immutable.ImmutableComponent;
+import org.ladysnake.cca.api.v3.component.immutable.ImmutableComponentKey;
 import org.ladysnake.cca.internal.base.ComponentRegistryImpl;
 
 import javax.annotation.Nullable;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 /**
@@ -76,6 +83,22 @@ public static <C extends Component> ComponentKey<C> getOrCreate(Identifier compo
         return ComponentRegistryV3.INSTANCE.getOrCreate(componentId, componentClass);
     }
 
+    public static <C extends ImmutableComponent> ImmutableComponentKey<C> getOrCreateTransient(Identifier componentId, Class<C> componentClass) {
+        return ComponentRegistryV3.INSTANCE.getOrCreateImmutable(componentId, componentClass, null, null);
+    }
+
+    public static <C extends ImmutableComponent> ImmutableComponentKey<C> getOrCreateTransient(Identifier componentId, Class<C> componentClass, PacketCodec<RegistryByteBuf, C> packetCodec) {
+        return ComponentRegistryV3.INSTANCE.getOrCreateImmutable(componentId, componentClass, null, packetCodec);
+    }
+
+    public static <C extends ImmutableComponent> ImmutableComponentKey<C> getOrCreate(Identifier componentId, Class<C> componentClass, MapCodec<C> mapCodec, PacketCodec<RegistryByteBuf, C> packetCodec) {
+        return ComponentRegistryV3.INSTANCE.getOrCreateImmutable(componentId, componentClass, mapCodec, packetCodec);
+    }
+
+    public static <C extends ImmutableComponent> ImmutableComponentKey<C> getOrCreate(Identifier componentId, Class<C> componentClass, MapCodec<C> mapCodec) {
+        return ComponentRegistryV3.INSTANCE.getOrCreateImmutable(componentId, componentClass, mapCodec, null);
+    }
+
     /**
      * Directly retrieves a ComponentKey using its id.
      *

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/ComponentRegistryV3.java

@@ -22,12 +22,18 @@
  */
 package org.ladysnake.cca.api.v3.component;
 
+import com.mojang.serialization.MapCodec;
+import net.minecraft.network.RegistryByteBuf;
+import net.minecraft.network.codec.PacketCodec;
 import net.minecraft.util.Identifier;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Contract;
+import org.ladysnake.cca.api.v3.component.immutable.ImmutableComponent;
+import org.ladysnake.cca.api.v3.component.immutable.ImmutableComponentKey;
 import org.ladysnake.cca.internal.base.ComponentRegistryImpl;
 
 import javax.annotation.Nullable;
+import java.util.Optional;
 import java.util.stream.Stream;
 
 /**
@@ -80,6 +86,8 @@ public interface ComponentRegistryV3 {
      */
     <C extends Component> ComponentKey<C> getOrCreate(Identifier componentId, Class<C> componentClass);
 
+    <C extends ImmutableComponent> ImmutableComponentKey<C> getOrCreateImmutable(Identifier componentId, Class<C> componentClass, @org.jetbrains.annotations.Nullable MapCodec<C> mapCodec, @org.jetbrains.annotations.Nullable PacketCodec<RegistryByteBuf, C> packetCodec);
+
     /**
      * Directly retrieves a ComponentKey using its id.
      *

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/StaticComponentInitializer.java

@@ -48,6 +48,10 @@ default Collection<Identifier> getSupportedComponentKeys() {
         return Collections.emptySet();
     }
 
+    default Collection<Identifier> getSupportedImmutableComponentKeys() {
+        return Collections.emptySet();
+    }
+
     /**
      * Called when static component bootstrap is finished.
      *

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/immutable/ImmutableComponent.java

@@ -0,0 +1,17 @@
+package org.ladysnake.cca.api.v3.component.immutable;
+
+public interface ImmutableComponent {
+    @FunctionalInterface
+    interface Modifier<C extends ImmutableComponent, O> {
+        C modify(C component, O attachedTo);
+    }
+    @FunctionalInterface
+    interface Listener<C extends ImmutableComponent, O> extends Modifier<C, O> {
+        void listen(C component, O attachedTo);
+        @Override
+        default C modify(C component, O attachedTo) {
+            this.listen(component, attachedTo);
+            return component;
+        }
+    }
+}

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/immutable/ImmutableComponentFactory.java

@@ -0,0 +1,48 @@
+/*
+ * Cardinal-Components-API
+ * Copyright (C) 2019-2024 Ladysnake
+ *
+ * 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.
+ */
+package org.ladysnake.cca.api.v3.component.immutable;
+
+import org.jetbrains.annotations.Contract;
+import org.ladysnake.cca.api.v3.component.Component;
+
+/**
+ * A single-arg component factory.
+ *
+ * <p>When invoked, the factory must return a {@link Component} of the right type.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface ImmutableComponentFactory<T, C extends ImmutableComponent> {
+    /**
+     * Instantiates a {@link Component} for the given provider.
+     *
+     * <p>The component returned by this method will be available
+     * on the provider as soon as all component factories have been invoked.
+     *
+     * @param t the factory argument
+     * @return a new {@link Component}
+     */
+    @Contract(value = "_ -> new", pure = true)
+    C createComponent(T t);
+}

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/immutable/ImmutableComponentHookType.java

@@ -0,0 +1,44 @@
+package org.ladysnake.cca.api.v3.component.immutable;
+
+import org.ladysnake.cca.api.v3.component.load.ClientLoadAwareComponent;
+import org.ladysnake.cca.api.v3.component.load.ClientUnloadAwareComponent;
+import org.ladysnake.cca.api.v3.component.load.ServerLoadAwareComponent;
+import org.ladysnake.cca.api.v3.component.load.ServerUnloadAwareComponent;
+import org.ladysnake.cca.api.v3.component.tick.ClientTickingComponent;
+import org.ladysnake.cca.api.v3.component.tick.ServerTickingComponent;
+
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+
+public record ImmutableComponentHookType<I>(Class<I> itf,
+                                            String methodName,
+                                            MethodType exposedType,
+                                            MethodType implType) {
+    public ImmutableComponentHookType {
+        if (!itf.isInterface()
+            || Arrays.stream(itf.getDeclaredMethods())
+            .filter(m -> Modifier.isAbstract(m.getModifiers()))
+            .count() != 1) {
+            throw new IllegalArgumentException("ImmutableComponentHookType accepts only functional interfaces");
+        }
+    }
+
+    public static <I> ImmutableComponentHookType<I> fromFunctionalInterface(Class<I> itf) {
+        var method = Arrays.stream(itf.getDeclaredMethods())
+            .filter(m -> Modifier.isAbstract(m.getModifiers()))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("ImmutableComponentHookType accepts only functional interfaces"));
+        String name = method.getName();
+        var type = MethodType.methodType(method.getReturnType(), method.getParameterTypes());
+        var implType = type.insertParameterTypes(0, ImmutableComponentWrapper.class);
+        return new ImmutableComponentHookType<>(itf, name, type, implType);
+    }
+
+    public static final ImmutableComponentHookType<ServerTickingComponent> SERVER_TICK = fromFunctionalInterface(ServerTickingComponent.class);
+    public static final ImmutableComponentHookType<ClientTickingComponent> CLIENT_TICK = fromFunctionalInterface(ClientTickingComponent.class);
+    public static final ImmutableComponentHookType<ServerLoadAwareComponent> SERVER_LOAD = fromFunctionalInterface(ServerLoadAwareComponent.class);
+    public static final ImmutableComponentHookType<ClientLoadAwareComponent> CLIENT_LOAD = fromFunctionalInterface(ClientLoadAwareComponent.class);
+    public static final ImmutableComponentHookType<ServerUnloadAwareComponent> SERVER_UNLOAD = fromFunctionalInterface(ServerUnloadAwareComponent.class);
+    public static final ImmutableComponentHookType<ClientUnloadAwareComponent> CLIENT_UNLOAD = fromFunctionalInterface(ClientUnloadAwareComponent.class);
+}

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/immutable/ImmutableComponentKey.java

@@ -0,0 +1,75 @@
+package org.ladysnake.cca.api.v3.component.immutable;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.network.RegistryByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.ladysnake.cca.api.v3.component.ComponentKey;
+
+import java.util.function.UnaryOperator;
+
+public abstract class ImmutableComponentKey<C extends ImmutableComponent> extends ComponentKey<ImmutableComponentWrapper<C, ?>> {
+    private final @Nullable MapCodec<C> mapCodec;
+    private final @Nullable PacketCodec<RegistryByteBuf, C> packetCodec;
+    private final Class<C> immutableComponentClass;
+
+    protected ImmutableComponentKey(Identifier id, Class<C> immutableComponentClass, Class<ImmutableComponentWrapper<C, ?>> wrapperClass, @Nullable MapCodec<C> mapCodec, @Nullable PacketCodec<RegistryByteBuf, C> packetCodec) {
+        super(id, wrapperClass);
+        this.immutableComponentClass = immutableComponentClass;
+        this.mapCodec = mapCodec;
+        this.packetCodec = packetCodec;
+    }
+
+    public Class<C> getImmutableComponentClass() {
+        return this.immutableComponentClass;
+    }
+
+    public MapCodec<C> getMapCodec() {
+        return this.mapCodec;
+    }
+
+    public PacketCodec<RegistryByteBuf, C> getPacketCodec() {
+        return this.packetCodec;
+    }
+
+    public C getValue(Object owner) {
+        return this.get(owner).getData();
+    }
+
+    public void set(Object owner, C data) {
+        var wrapper = this.get(owner);
+        wrapper.setData(data);
+    }
+
+    public void setAndSync(Object owner, C data) {
+        var wrapper = this.get(owner);
+        wrapper.setAndSync(data);
+    }
+
+    public void update(Object owner, UnaryOperator<C> operator) {
+        var wrapper = this.get(owner);
+        wrapper.update(operator);
+    }
+
+    public void updateAndSync(Object owner, UnaryOperator<C> operator) {
+        var wrapper = this.get(owner);
+        wrapper.updateAndSync(operator);
+    }
+
+    public <O> void update(O owner, ImmutableComponent.Modifier<C, O> modifier) {
+        var wrapper = this.getWrapper(owner);
+        wrapper.update(modifier);
+    }
+
+    public <O> void updateAndSync(O owner, ImmutableComponent.Modifier<C, O> modifier) {
+        var wrapper = this.getWrapper(owner);
+        wrapper.updateAndSync(modifier);
+    }
+
+    @SuppressWarnings("unchecked")
+    private <O> @NotNull ImmutableComponentWrapper<C, O> getWrapper(O owner) {
+        return (ImmutableComponentWrapper<C, O>) this.get(owner);
+    }
+}

cardinal-components-base/src/main/java/org/ladysnake/cca/api/v3/component/immutable/ImmutableComponentWrapper.java

@@ -0,0 +1,81 @@
+package org.ladysnake.cca.api.v3.component.immutable;
+
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.registry.RegistryWrapper;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.ladysnake.cca.api.v3.component.Component;
+import org.ladysnake.cca.api.v3.component.CopyableComponent;
+
+import java.util.function.BiFunction;
+import java.util.function.UnaryOperator;
+
+@ApiStatus.NonExtendable
+public abstract class ImmutableComponentWrapper<C extends ImmutableComponent, O> implements
+    Component,
+    CopyableComponent<ImmutableComponentWrapper<C, O>> {
+    private final ImmutableComponentKey<C> key;
+    private final O owner;
+    private @NotNull C data;
+
+    protected ImmutableComponentWrapper(ImmutableComponentKey<C> key, O owner, C data) {
+        this.key = key;
+        this.owner = owner;
+        this.data = data;
+    }
+
+    @Override
+    public void writeToNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
+        // overridden if key.mapCodec != null
+    }
+
+    @Override
+    public void readFromNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) {
+        // overridden if key.mapCodec != null
+    }
+
+    @Override
+    public void copyFrom(ImmutableComponentWrapper<C, O> other, RegistryWrapper.WrapperLookup registryLookup) {
+        this.data = other.data;
+    }
+
+    public ImmutableComponentKey<C> getKey() {
+        return key;
+    }
+
+    public O getOwner() {
+        return owner;
+    }
+
+    public C getData() {
+        return this.data;
+    }
+
+    public void setData(C data) {
+        this.data = data;
+    }
+
+    public void setAndSync(C data) {
+        boolean shouldSync = !this.data.equals(data);
+        this.setData(this.data);
+        if (shouldSync) {
+            this.key.sync(this.owner);
+        }
+    }
+
+    public void update(UnaryOperator<C> operator) {
+        this.setData(operator.apply(this.data));
+    }
+
+    public void updateAndSync(UnaryOperator<C> operator) {
+        this.setAndSync(operator.apply(this.data));
+    }
+
+    public void update(ImmutableComponent.Modifier<C, O> modifier) {
+        this.setData(modifier.modify(this.data, this.owner));
+    }
+
+    public void updateAndSync(ImmutableComponent.Modifier<C, O> modifier) {
+        this.setAndSync(modifier.modify(this.data, this.owner));
+    }
+}