Add loadIfPresent method for use where the section should definitely exist and be FULL

worldedit-core/src/main/java/com/fastasyncworldedit/core/extent/processor/heightmap/HeightmapProcessor.java

@@ -61,8 +61,9 @@ public class HeightmapProcessor implements IBatchProcessor {
             if (!(hasSectionSet || hasSectionGet)) {
                 continue;
             }
-            char[] setSection = hasSectionSet ? set.load(layer) : null;
+            char[] setSection = hasSectionSet ? set.loadIfPresent(layer) : null;
-            if (Arrays.equals(setSection, FaweCache.IMP.EMPTY_CHAR_4096) || Arrays.equals(setSection, AIR_LAYER)) {
+            if (setSection == null || Arrays.equals(setSection, FaweCache.IMP.EMPTY_CHAR_4096) ||
+                    Arrays.equals(setSection, AIR_LAYER)) {
                 hasSectionSet = false;
             }
             if (!hasSectionSet && !hasSectionGet) {

worldedit-core/src/main/java/com/fastasyncworldedit/core/history/changeset/AbstractChangeSet.java

@@ -33,6 +33,7 @@ import com.sk89q.worldedit.world.block.BlockState;
 import java.io.IOException;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.Future;
@@ -170,7 +171,8 @@ public abstract class AbstractChangeSet implements ChangeSet, IBatchProcessor {
                 System.arraycopy(tmp, 0, (blocksGet = new char[4096]), 0, 4096);
             }
             char[] blocksSet;
-            System.arraycopy(set.load(layer), 0, (blocksSet = new char[4096]), 0, 4096);
+            // loadIfPresent shouldn't be null if set.hasSection(layer) is true
+            System.arraycopy(Objects.requireNonNull(set.loadIfPresent(layer)), 0, (blocksSet = new char[4096]), 0, 4096);
 
             // Account for negative layers
             int by = layer << 4;

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/IBatchProcessor.java

@@ -44,11 +44,15 @@ public interface IBatchProcessor {
         for (int layer = set.getMinSectionPosition(); layer <= minLayer; layer++) {
             if (set.hasSection(layer)) {
                 if (layer == minLayer) {
-                    char[] arr = set.load(layer);
+                    char[] arr = set.loadIfPresent(layer);
+                    if (arr != null) {
                         int index = (minY & 15) << 8;
                         for (int i = 0; i < index; i++) {
                             arr[i] = 0;
                         }
+                    } else {
+                        arr = new char[4096];
+                    }
                     set.setBlocks(layer, arr);
                 } else {
                     set.setBlocks(layer, null);
@@ -59,11 +63,15 @@ public interface IBatchProcessor {
         for (int layer = maxLayer; layer < set.getMaxSectionPosition(); layer++) {
             if (set.hasSection(layer)) {
                 if (layer == minLayer) {
-                    char[] arr = set.load(layer);
+                    char[] arr = set.loadIfPresent(layer);
+                    if (arr != null) {
                         int index = ((maxY + 1) & 15) << 8;
                         for (int i = index; i < arr.length; i++) {
                             arr[i] = 0;
                         }
+                    } else {
+                        arr = new char[4096];
+                    }
                     set.setBlocks(layer, arr);
                 } else {
                     set.setBlocks(layer, null);

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/IBlocks.java

@@ -12,6 +12,7 @@ import com.sk89q.worldedit.world.biome.BiomeType;
 import com.sk89q.worldedit.world.block.BlockState;
 import com.sk89q.worldedit.world.registry.BlockRegistry;
 
+import javax.annotation.Nullable;
 import java.io.IOException;
 import java.util.Map;
 import java.util.Set;
@@ -31,8 +32,26 @@ public interface IBlocks extends Trimable {
      */
     boolean hasSection(int layer);
 
+    /**
+     * Obtain the specified chunk section stored as an array of ordinals. Uses normal minecraft chunk-section position indices
+     * (length 4096). Operations synchronises on the section and will load the section into memory if not present. For chunk
+     * GET operations, this will load the data from the world. For chunk SET, this will create a new empty array.
+     *
+     * @param layer chunk section layer (may be negative)
+     * @return char array of ordinals of the chunk section
+     */
     char[] load(int layer);
 
+    /**
+     * Obtain the specified chunk section stored as an array of ordinals if present or null. Uses normal minecraft chunk-section
+     * position indices (length 4096). Does not synchronise to the section layer as it will not attempt to load into memory.
+     *
+     * @param layer chunk section layer (may be negative)
+     * @return char array of ordinals of the chunk section if present
+     */
+    @Nullable
+    char[] loadIfPresent(int layer);
+
     BlockState getBlock(int x, int y, int z);
 
     Map<BlockVector3, CompoundTag> getTiles();

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/implementation/blocks/BitSetBlocks.java

@@ -10,6 +10,7 @@ import com.sk89q.worldedit.world.biome.BiomeType;
 import com.sk89q.worldedit.world.block.BlockState;
 import com.sk89q.worldedit.world.block.BlockStateHolder;
 
+import javax.annotation.Nullable;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Map;
@@ -38,7 +39,6 @@ public class BitSetBlocks implements IChunkSet {
         return row.rows[layer] != MemBlockSet.NULL_ROW_Y;
     }
 
-
     @Override
     public boolean setBiome(int x, int y, int z, BiomeType biome) {
         return false;
@@ -153,6 +153,13 @@ public class BitSetBlocks implements IChunkSet {
         return arr;
     }
 
+    // No need to do anything different
+    @Nullable
+    @Override
+    public char[] loadIfPresent(final int layer) {
+        return load(layer);
+    }
+
     @Override
     public BiomeType[] getBiomes() {
         return null;

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/implementation/blocks/CharBlocks.java

@@ -147,6 +147,16 @@ public abstract class CharBlocks implements IBlocks {
         }
     }
 
+    @Nullable
+    @Override
+    public char[] loadIfPresent(int layer) {
+        if (layer < minSectionPosition || layer > maxSectionPosition) {
+            return null;
+        }
+        layer -= minSectionPosition;
+        return sections[layer].isFull() ? blocks[layer] : null;
+    }
+
     @Override
     public BlockState getBlock(int x, int y, int z) {
         return BlockTypesCache.states[get(x, y, z)];

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/implementation/blocks/NullChunkGet.java

@@ -127,6 +127,12 @@ public final class NullChunkGet implements IChunkGet {
         return FaweCache.IMP.EMPTY_CHAR_4096;
     }
 
+    @Nullable
+    @Override
+    public char[] loadIfPresent(final int layer) {
+        return null;
+    }
+
     public boolean hasSection(int layer) {
         return false;
     }

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/implementation/chunk/ChunkHolder.java

@@ -121,6 +121,12 @@ public class ChunkHolder<T extends Future<T>> implements IQueueChunk<T> {
         return getOrCreateGet().load(layer);
     }
 
+    @Nullable
+    @Override
+    public char[] loadIfPresent(final int layer) {
+        return getOrCreateGet().loadIfPresent(layer);
+    }
+
     @Override
     public boolean isFastMode() {
         return fastmode;

worldedit-core/src/main/java/com/fastasyncworldedit/core/queue/implementation/chunk/NullChunk.java

@@ -172,6 +172,12 @@ public final class NullChunk implements IQueueChunk {
         return null;
     }
 
+    @Nullable
+    @Override
+    public char[] loadIfPresent(final int layer) {
+        return null;
+    }
+
     @Nullable
     public CompoundTag getEntity(@Nonnull UUID uuid) {
         return null;

worldedit-core/src/main/java/com/sk89q/worldedit/regions/CuboidRegion.java

@@ -37,6 +37,7 @@ import javax.annotation.Nonnull;
 import java.util.AbstractSet;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.Objects;
 import java.util.Set;
 
 import static com.google.common.base.Preconditions.checkArgument;
@@ -769,7 +770,7 @@ public class CuboidRegion extends AbstractRegion implements FlatRegion {
 
             for (int layer = get.getMinSectionPosition(); layer < get.getMaxSectionPosition(); layer++) {
                 if (set.hasSection(layer)) {
-                    char[] arr = set.load(layer);
+                    char[] arr = Objects.requireNonNull(set.loadIfPresent(layer)); // This shouldn't be null if above is true
                     if (trimX || trimZ) {
                         int indexY = 0;
                         for (int y = 0; y < 16; y++, indexY += 256) { // For each y layer within a chunk section