Reduce memory impact of empty components by just using a single empty instance and initializing as needed

Author: pupnewfster

src/api/java/mekanism/api/chemical/BasicChemicalTank.java

@@ -185,7 +185,10 @@ public long setStackSize(long amount, Action action) {
     @Override
     public long growStack(long amount, Action action) {
         long current = getStored();
-        if (amount > 0) {
+        if (current == 0) {
+            //"Fail quick" if our stack is empty, so we can't grow it
+            return 0;
+        } else if (amount > 0) {
             //Cap adding amount at how much we need, so that we don't risk long overflow
             amount = Math.min(Math.min(amount, getNeeded()), getRate(null));
         } else if (amount < 0) {

src/api/java/mekanism/api/chemical/IChemicalTank.java

@@ -220,7 +220,10 @@ default long setStackSize(long amount, Action action) {
      */
     default long growStack(long amount, Action action) {
         long current = getStored();
-        if (amount > 0) {
+        if (current == 0) {
+            //"Fail quick" if our stack is empty, so we can't grow it
+            return 0;
+        } else if (amount > 0) {
             //Cap adding amount at how much we need, so that we don't risk long overflow
             amount = Math.min(amount, getNeeded());
         }

src/api/java/mekanism/api/fluid/IExtendedFluidTank.java

@@ -167,7 +167,10 @@ default int setStackSize(int amount, Action action) {
      */
     default int growStack(int amount, Action action) {
         int current = getFluidAmount();
-        if (amount > 0) {
+        if (current == 0) {
+            //"Fail quick" if our stack is empty, so we can't grow it
+            return 0;
+        } else if (amount > 0) {
             //Cap adding amount at how much we need, so that we don't risk integer overflow
             amount = Math.min(amount, getNeeded());
         }

src/api/java/mekanism/api/inventory/IInventorySlot.java

@@ -235,7 +235,10 @@ default int setStackSize(int amount, Action action) {
      */
     default int growStack(int amount, Action action) {
         int current = getCount();
-        if (amount > 0) {
+        if (current == 0) {
+            //"Fail quick" if our stack is empty, so we can't grow it
+            return 0;
+        } else if (amount > 0) {
             //Cap adding amount at how much we need, so that we don't risk integer overflow
             amount = Math.min(amount, getLimit(getStack()));
         }

src/main/java/mekanism/common/attachments/containers/ComponentBackedContainer.java

@@ -1,11 +1,10 @@
 package mekanism.common.attachments.containers;
 
-import java.util.function.Supplier;
 import mekanism.api.IContentsListener;
-import net.minecraft.core.component.DataComponentType;
+import mekanism.api.annotations.NothingNullByDefault;
 import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.Nullable;
 
+@NothingNullByDefault
 public abstract class ComponentBackedContainer<TYPE, ATTACHED extends IAttachedContainers<TYPE, ATTACHED>> implements IContentsListener {
 
     protected final ItemStack attachedTo;
@@ -20,37 +19,39 @@ protected ComponentBackedContainer(ItemStack attachedTo, int containerIndex) {
 
     protected abstract boolean isEmpty(TYPE value);
 
-    protected abstract Supplier<? extends DataComponentType<ATTACHED>> dataComponentType();
+    protected abstract ContainerType<?, ATTACHED, ?> containerType();
 
-    @Nullable
     protected ATTACHED getAttached() {
-        return attachedTo.get(dataComponentType());
+        return containerType().getOrEmpty(attachedTo);
     }
 
     protected TYPE getContents(ATTACHED attached) {
-        return attached.get(containerIndex);
+        return attached.getOrDefault(containerIndex);
     }
 
-    protected void setContents(TYPE value) {
-        //TODO - 1.20.5: Comment about why we have the overload that accepts attachedItems
-        ATTACHED attached = getAttached();
-        if (attached != null) {
-            setContents(attached, value);
+    protected void setContents(ATTACHED attached, TYPE value) {
+        //If we don't actually have an attachment present yet, we need to ensure we try to create a new one
+        if (attached.isEmpty()) {
+            //If we don't have an attachment, attempt to create a new one
+            attached = containerType().createNewAttachment(attachedTo);
+            if (attached.isEmpty()) {
+                //If we can't figure out how to handle the attachment for the item, just exit
+                // Note: We don't need to consider removing an existing attachment as we know we don't have one
+                return;
+            }
+        }
+        if (shouldUpdate(attached, value)) {
+            attachedTo.set(containerType().getComponentType(), attached.with(containerIndex, copy(value)));
+            onContentsChanged();
         }
-        //TODO - 1.20.5: Else initialize to whatever the default size is meant to be?
-        // I think we might always end up actually doing so when accessing this from the container type?
-        // Though maybe not if it isn't going through capability systems
     }
 
-    protected void setContents(ATTACHED attached, TYPE value) {
+    protected boolean shouldUpdate(ATTACHED attached, TYPE value) {
         //If both stacks are empty we don't do anything
-        if (!isEmpty(value) || !isEmpty(getContents(attached))) {
-            //TODO - 1.20.5: Do we want to do a matches check instead of just seeing if both are empty
-            // Or maybe only do that in the non overloaded setStack so as a way to potentially avoid the extra lookup here when we know
-            // we only call this method if something has changed
-            attachedTo.set(dataComponentType(), attached.with(containerIndex, copy(value)));
-            onContentsChanged();
-        }
+        //TODO - 1.20.5: Do we want to do a matches check instead of just seeing if both are empty
+        // Or maybe only do that in the non overloaded setStack so as a way to potentially avoid the extra lookup here when we know
+        // we only call this method if something has changed
+        return !isEmpty(value) || !isEmpty(getContents(attached));
     }
 
     @Override

src/main/java/mekanism/common/attachments/containers/ComponentBackedHandler.java

@@ -1,7 +1,6 @@
 package mekanism.common.attachments.containers;
 
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import mekanism.api.IContentsListener;
 import mekanism.api.annotations.NothingNullByDefault;
@@ -14,33 +13,41 @@
 public abstract class ComponentBackedHandler<TYPE, CONTAINER extends INBTSerializable<CompoundTag>, ATTACHED extends IAttachedContainers<TYPE, ATTACHED>>
       implements IContentsListener {
 
-    private final List<CONTAINER> containers;
     protected final ItemStack attachedTo;
+    private final int totalContainers;
+
+    @Nullable
+    private List<CONTAINER> containers;
     private int numNotInitialized;
 
     //TODO - 1.20.5: Do we want to validate slot indices are within range?
-    protected ComponentBackedHandler(ItemStack attachedTo) {
+    protected ComponentBackedHandler(ItemStack attachedTo, int totalContainers) {
         this.attachedTo = attachedTo;
-        ATTACHED attached = getAttached();
-        if (attached == null || attached.isEmpty()) {
-            //TODO - 1.20.5: Is this meant to be zero if there is no attachment, or is it meant to be what the default is?
-            numNotInitialized = 0;
-            containers = Collections.emptyList();
-        } else {
-            numNotInitialized = attached.size();
-            //Note: Use an Arrays#asList to allow for null elements and force it to be the size we want it to be
-            containers = Arrays.asList((CONTAINER[]) new INBTSerializable[numNotInitialized]);
-        }
+        this.totalContainers = totalContainers;
     }
 
     protected abstract ContainerType<CONTAINER, ATTACHED, ?> containerType();
 
-    @Nullable
     protected ATTACHED getAttached() {
-        return attachedTo.get(containerType().getComponentType());
+        return containerType().getOrEmpty(attachedTo);
+    }
+
+    protected TYPE getContents(int index) {
+        return getAttached().getOrDefault(index);
+    }
+
+    private List<CONTAINER> containers() {
+        //Lazily initialize the list of containers
+        if (containers == null) {
+            //Note: Use an Arrays#asList to allow for null elements and force it to be the size we want it to be
+            containers = Arrays.asList((CONTAINER[]) new INBTSerializable[totalContainers]);
+            numNotInitialized = totalContainers;
+        }
+        return containers;
     }
 
     public List<CONTAINER> getContainers() {
+        List<CONTAINER> containers = containers();
         //Ensure all our containers are initialized. This short circuits if they are, and if they aren't it initializes any ones that haven't been initialized yet
         for (int i = 0, size = containers.size(); numNotInitialized > 0 && i < size; i++) {
             if (containers.get(i) == null) {
@@ -51,22 +58,21 @@ public List<CONTAINER> getContainers() {
     }
 
     private CONTAINER initializeContainer(int index) {
-        //TODO - 1.20.5: ??
+        //Create a new container for the given index, and set it as initialized
         CONTAINER container = containerType().createContainer(attachedTo, index);
-        containers.set(index, container);
+        containers().set(index, container);
         numNotInitialized--;
         return container;
     }
 
     protected CONTAINER getContainer(int index) {
-        CONTAINER container = containers.get(index);
+        CONTAINER container = containers().get(index);
         //Lazily initialize the containers
         return container == null ? initializeContainer(index) : container;
     }
 
     protected int containerCount() {
-        ATTACHED attached = getAttached();
-        return attached == null ? 0 : attached.size();
+        return totalContainers;
     }
 
     @Override