Use Lazy<BlockState> for the lazy blockstate codec instead of a supplier

Author: Swedz

src/main/java/aztech/modern_industrialization/machines/multiblocks/structure/StructureMultiblockInputFormatters.java

@@ -41,6 +41,7 @@
 import net.minecraft.tags.BlockTags;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockState;
+import net.neoforged.neoforge.common.util.Lazy;
 import org.jetbrains.annotations.Nullable;
 
 public final class StructureMultiblockInputFormatters {
@@ -128,7 +129,7 @@ public static List<StructureMemberTest> members(String input) {
             } else {
                 try {
                     var blockResult = BlockStateParser.parseForBlock(registry, part, true);
-                    members.add(new StateStructureMemberTest(blockResult::blockState));
+                    members.add(new StateStructureMemberTest(Lazy.of(blockResult::blockState)));
                 } catch (CommandSyntaxException ignored) {
                     return null;
                 }

src/main/java/aztech/modern_industrialization/machines/multiblocks/structure/member/HatchStructureMember.java

@@ -38,14 +38,14 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Supplier;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.block.state.BlockState;
+import net.neoforged.neoforge.common.util.Lazy;
 
 public final class HatchStructureMember extends SimpleStructureMember {
     public static final MapCodec<HatchStructureMember> CODEC = RecordCodecBuilder.mapCodec(instance -> instance
             .group(
-                    MIExtraCodecs.LAZY_BLOCK_STATE.fieldOf("preview").forGetter(member -> member.previewSupplier),
+                    MIExtraCodecs.LAZY_BLOCK_STATE.fieldOf("preview").forGetter(member -> member.preview),
                     StructureMemberTest.CODEC.listOf().fieldOf("tests").forGetter(HatchStructureMember::tests),
                     MachineCasing.CODEC.fieldOf("casing").forGetter(HatchStructureMember::casing),
                     HatchFlags.CODEC.fieldOf("hatch_flags").forGetter(HatchStructureMember::hatchFlags))
@@ -54,7 +54,7 @@ public final class HatchStructureMember extends SimpleStructureMember {
     private final MachineCasing casing;
     private final HatchFlags hatchFlags;
 
-    public HatchStructureMember(Supplier<BlockState> previewSupplier, List<StructureMemberTest> tests, MachineCasing casing, HatchFlags hatchFlags) {
+    public HatchStructureMember(Lazy<BlockState> previewSupplier, List<StructureMemberTest> tests, MachineCasing casing, HatchFlags hatchFlags) {
         super(previewSupplier, tests);
         Objects.requireNonNull(casing);
         Objects.requireNonNull(hatchFlags);

src/main/java/aztech/modern_industrialization/machines/multiblocks/structure/member/LiteralStructureMember.java

@@ -30,15 +30,15 @@
 import com.mojang.serialization.MapCodec;
 import java.util.List;
 import java.util.Optional;
-import java.util.function.Supplier;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.block.state.BlockState;
+import net.neoforged.neoforge.common.util.Lazy;
 
 public final class LiteralStructureMember extends SimpleStructureMember {
     public static final MapCodec<LiteralStructureMember> CODEC = MIExtraCodecs.LAZY_BLOCK_STATE
-            .xmap(LiteralStructureMember::new, member -> member.previewSupplier).fieldOf("state");
+            .xmap(LiteralStructureMember::new, member -> member.preview).fieldOf("state");
 
-    public LiteralStructureMember(Supplier<BlockState> previewSupplier) {
+    public LiteralStructureMember(Lazy<BlockState> previewSupplier) {
         super(previewSupplier, List.of(new StateStructureMemberTest(previewSupplier)));
     }
 

src/main/java/aztech/modern_industrialization/machines/multiblocks/structure/member/SimpleStructureMember.java

@@ -37,27 +37,24 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Supplier;
 import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockState;
+import net.neoforged.neoforge.common.util.Lazy;
 
 public sealed class SimpleStructureMember extends StructureMember permits HatchStructureMember, LiteralStructureMember {
     public static final MapCodec<SimpleStructureMember> CODEC = RecordCodecBuilder.mapCodec(instance -> instance
             .group(
-                    MIExtraCodecs.LAZY_BLOCK_STATE.fieldOf("preview").forGetter(member -> member.previewSupplier),
+                    MIExtraCodecs.LAZY_BLOCK_STATE.fieldOf("preview").forGetter(member -> member.preview),
                     StructureMemberTest.CODEC.listOf().fieldOf("tests").forGetter(SimpleStructureMember::tests))
             .apply(instance, SimpleStructureMember::new));
 
-    protected final Supplier<BlockState> previewSupplier;
-
-    protected BlockState preview;
+    protected final Lazy<BlockState> preview;
     protected final List<StructureMemberTest> tests;
 
-    public SimpleStructureMember(Supplier<BlockState> previewSupplier, List<StructureMemberTest> tests) {
-        Objects.requireNonNull(previewSupplier);
+    public SimpleStructureMember(Lazy<BlockState> preview, List<StructureMemberTest> tests) {
+        Objects.requireNonNull(preview);
         Objects.requireNonNull(tests);
-        this.previewSupplier = previewSupplier;
+        this.preview = preview;
         this.tests = tests;
     }
 
@@ -96,13 +93,7 @@ public boolean matchesState(BlockState state) {
 
     @Override
     public BlockState getPreviewState() {
-        if (preview == null) {
-            preview = previewSupplier.get();
-            if (preview == null) {
-                preview = Blocks.AIR.defaultBlockState();
-            }
-        }
-        return preview;
+        return preview.get();
     }
 
     @Override

src/main/java/aztech/modern_industrialization/machines/multiblocks/structure/member/StructureMember.java

@@ -36,6 +36,7 @@
 import java.util.function.Supplier;
 import net.minecraft.core.BlockPos;
 import net.minecraft.world.level.block.state.BlockState;
+import net.neoforged.neoforge.common.util.Lazy;
 
 public sealed abstract class StructureMember implements SimpleMember permits SimpleStructureMember, VariableStructureMember {
     public static final Codec<StructureMember> CODEC = Codec.STRING.flatComapMap(
@@ -47,16 +48,16 @@ public sealed abstract class StructureMember implements SimpleMember permits Sim
     public abstract Optional<Pair<BlockState, FastBlockEntity>> asStructureBlock(BlockPos pos, boolean required);
 
     public static SimpleStructureMember simple(Supplier<BlockState> preview, List<StructureMemberTest> tests) {
-        return new SimpleStructureMember(preview, tests);
+        return new SimpleStructureMember(Lazy.of(preview), tests);
     }
 
     public static LiteralStructureMember literal(Supplier<BlockState> blockState) {
-        return new LiteralStructureMember(blockState);
+        return new LiteralStructureMember(Lazy.of(blockState));
     }
 
     public static HatchStructureMember hatch(Supplier<BlockState> preview, List<StructureMemberTest> tests, MachineCasing casing,
             HatchFlags hatchFlags) {
-        return new HatchStructureMember(preview, tests, casing, hatchFlags);
+        return new HatchStructureMember(Lazy.of(preview), tests, casing, hatchFlags);
     }
 
     public static VariableStructureMember variable(String name) {

src/main/java/aztech/modern_industrialization/machines/multiblocks/structure/member/test/StateStructureMemberTest.java

@@ -27,33 +27,24 @@
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import java.util.Objects;
-import java.util.function.Supplier;
-import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockState;
+import net.neoforged.neoforge.common.util.Lazy;
 
 public final class StateStructureMemberTest extends StructureMemberTest {
     public static final MapCodec<StateStructureMemberTest> CODEC = RecordCodecBuilder.mapCodec(instance -> instance
             .group(
-                    MIExtraCodecs.LAZY_BLOCK_STATE.fieldOf("state").forGetter(test -> test.blockStateSupplier))
+                    MIExtraCodecs.LAZY_BLOCK_STATE.fieldOf("state").forGetter(test -> test.blockState))
             .apply(instance, StateStructureMemberTest::new));
 
-    private final Supplier<BlockState> blockStateSupplier;
+    private final Lazy<BlockState> blockState;
 
-    private BlockState blockState;
-
-    public StateStructureMemberTest(Supplier<BlockState> blockStateSupplier) {
-        Objects.requireNonNull(blockStateSupplier);
-        this.blockStateSupplier = blockStateSupplier;
+    public StateStructureMemberTest(Lazy<BlockState> blockState) {
+        Objects.requireNonNull(blockState);
+        this.blockState = blockState;
     }
 
     public BlockState blockState() {
-        if (blockState == null) {
-            blockState = blockStateSupplier.get();
-            if (blockState == null) {
-                blockState = Blocks.AIR.defaultBlockState();
-            }
-        }
-        return blockState;
+        return blockState.get();
     }
 
     @Override

src/main/java/aztech/modern_industrialization/util/MIExtraCodecs.java

@@ -32,23 +32,23 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
-import java.util.function.Supplier;
 import net.minecraft.world.level.block.state.BlockState;
 import net.neoforged.neoforge.common.conditions.ConditionalOps;
+import net.neoforged.neoforge.common.util.Lazy;
 import net.neoforged.neoforge.common.util.NeoForgeExtraCodecs;
 
 public class MIExtraCodecs {
     public static final Codec<Float> FLOAT_01 = Codec.floatRange(0, 1);
     public static final Codec<Long> NON_NEGATIVE_LONG = longRange(0, Long.MAX_VALUE);
     public static final Codec<Long> POSITIVE_LONG = longRange(1, Long.MAX_VALUE);
-    public static final Codec<Supplier<BlockState>> LAZY_BLOCK_STATE = new Codec<>() {
+    public static final Codec<Lazy<BlockState>> LAZY_BLOCK_STATE = new Codec<>() {
         @Override
-        public <T> DataResult<Pair<Supplier<BlockState>, T>> decode(DynamicOps<T> ops, T input) {
-            return DataResult.success(Pair.of(() -> BlockState.CODEC.decode(ops, input).getOrThrow().getFirst(), input));
+        public <T> DataResult<Pair<Lazy<BlockState>, T>> decode(DynamicOps<T> ops, T input) {
+            return DataResult.success(Pair.of(Lazy.of(() -> BlockState.CODEC.decode(ops, input).getOrThrow().getFirst()), input));
         }
 
         @Override
-        public <T> DataResult<T> encode(Supplier<BlockState> input, DynamicOps<T> ops, T prefix) {
+        public <T> DataResult<T> encode(Lazy<BlockState> input, DynamicOps<T> ops, T prefix) {
             return BlockState.CODEC.encode(input.get(), ops, prefix);
         }
     };