backported fastutil implementation of the item list

src/api/java/appeng/api/storage/data/IAEItemStack.java

@@ -112,4 +112,13 @@ public interface IAEItemStack extends IAEStack<IAEItemStack>
 	 * @return definition stack
 	 */
 	ItemStack getDefinition();
+
+	/**
+	 * Compare this AE item stack to another item stack, but ignores
+	 * the amount. It checks the item type, NBT and damage values.
+	 *
+	 * @param is An item stack
+	 */
+	boolean equals(ItemStack is);
+
 }

src/main/java/appeng/me/cluster/implementations/CraftingCPUCluster.java

@@ -23,6 +23,7 @@ import java.util.*;
 import java.util.Map.Entry;
 import java.util.stream.Collectors;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 
 import net.minecraft.inventory.InventoryCrafting;
@@ -233,8 +234,9 @@ public final class CraftingCPUCluster implements IAECluster, ICraftingCPU
 
 	public IAEItemStack injectItems( final IAEItemStack input, final Actionable type, final IActionSource src )
 	{
-		if( !( input instanceof IAEItemStack ) )
+		// also stop accepting items when the job is complete, i.e. to prevent re-insertion when pushing out
-		{
+		// items during storeItems
+		if (input == null || isComplete) {
 			return input;
 		}
 
@@ -431,6 +433,11 @@ public final class CraftingCPUCluster implements IAECluster, ICraftingCPU
 			AELog.crafting( LOG_MARK_AS_COMPLETE, logStack );
 		}
 
+		// Waiting for can potentially contain items at this point, if the user has a 64xplank->64xbutton processing
+		// recipe for example, but only requested 1xbutton. We just ignore the rest since it will be dumped
+		// back into the network inventory regardless. For this to work it's important that injectItems in this CPU
+		// does not accept any further items if isComplete is true.
+		this.waitingFor.resetStatus();
 		this.remainingItemCount = 0;
 		this.startItemCount = 0;
 		this.lastTime = 0;
@@ -828,6 +835,7 @@ public final class CraftingCPUCluster implements IAECluster, ICraftingCPU
 
 	private void storeItems()
 	{
+		Preconditions.checkState(isComplete, "CPU should be complete to prevent re-insertion when dumping items");
 		final IGrid g = this.getGrid();
 
 		if( g == null )
@@ -838,23 +846,24 @@ public final class CraftingCPUCluster implements IAECluster, ICraftingCPU
 		final IStorageGrid sg = g.getCache( IStorageGrid.class );
 		final IMEInventory<IAEItemStack> ii = sg.getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) );
 
-		for( IAEItemStack is : this.inventory.getItemList() )
+		IItemList<IAEItemStack> itemList = this.inventory.getItemList();
-		{
+		for( IAEItemStack is : itemList )
-			is = this.inventory.extractItems( is.copy(), Actionable.MODULATE, this.machineSrc );
-
-			if( is != null )
 		{
 			this.postChange( is, this.machineSrc );
-				is = ii.injectItems( is, Actionable.MODULATE, this.machineSrc );
+			IAEItemStack remainder = ii.injectItems( is.copy(), Actionable.MODULATE, this.machineSrc );
-			}
 
-			if( is != null )
+			// The network was unable to receive all of the items, i.e. no or not enough storage space left
+			if( remainder != null )
 			{
-				this.inventory.injectItems( is, Actionable.MODULATE, this.machineSrc );
+				is.setStackSize( remainder.getStackSize() );
+			}
+			else
+			{
+				is.reset();
 			}
 		}
 
-		if( this.inventory.getItemList().isEmpty() )
+		if( itemList.isEmpty() )
 		{
 			this.inventory = new MECraftingInventory();
 		}

src/main/java/appeng/util/item/AEItemStack.java

@@ -1,6 +1,6 @@
 /*
  * This file is part of Applied Energistics 2.
- * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
+ * Copyright (c) 2013 - 2020, AlgorithmX2, All rights reserved.
  *
  * Applied Energistics 2 is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -18,7 +18,6 @@
 
 package appeng.util.item;
 
-
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
@@ -27,92 +26,84 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 import io.netty.buffer.ByteBuf;
-
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.fml.common.network.ByteBufUtils;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 import net.minecraftforge.items.ItemHandlerHelper;
 
-import appeng.api.AEApi;
 import appeng.api.config.FuzzyMode;
 import appeng.api.storage.IStorageChannel;
 import appeng.api.storage.channels.IItemStorageChannel;
 import appeng.api.storage.data.IAEItemStack;
+import appeng.core.Api;
 import appeng.util.Platform;
 
+public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemStack {
+    private static final String NBT_STACKSIZE = "Cnt";
+    private static final String NBT_REQUESTABLE = "Req";
+    private static final String NBT_CRAFTABLE = "Craft";
 
-public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemStack
+    private final AESharedItemStack sharedStack;
-{
-	private AESharedItemStack sharedStack;
     private Optional<OreReference> oreReference;
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private String displayName;
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
     private List<String> tooltip;
-	@SideOnly( Side.CLIENT )
-	private ResourceLocation uniqueID;
 
-	private AEItemStack( final AEItemStack is )
+    private AEItemStack(final AEItemStack is) {
-	{
+        this.setStackSize(is.getStackSize());
-		this.setStackSize( is.getStackSize() );
+        this.setCraftable(is.isCraftable());
-		this.setCraftable( is.isCraftable() );
+        this.setCountRequestable(is.getCountRequestable());
-		this.setCountRequestable( is.getCountRequestable() );
         this.sharedStack = is.sharedStack;
         this.oreReference = is.oreReference;
     }
 
-	private AEItemStack( final AESharedItemStack is, long size )
+    private AEItemStack(final AESharedItemStack is, long size) {
-	{
         this.sharedStack = is;
-		this.setStackSize( size );
+        this.setStackSize(size);
-		this.setCraftable( false );
+        this.setCraftable(false);
-		this.setCountRequestable( 0 );
+        this.setCountRequestable(0);
         this.oreReference = OreHelper.INSTANCE.getOre( is.getDefinition() );
     }
 
     @Nullable
-	public static AEItemStack fromItemStack( @Nonnull final ItemStack stack )
+    public static AEItemStack fromItemStack(@Nonnull final ItemStack stack) {
-	{
+        if (stack.isEmpty()) {
-		if( stack.isEmpty() )
-		{
             return null;
         }
 
-		return new AEItemStack( AEItemStackRegistry.getRegisteredStack( stack ), stack.getCount() );
+        return new AEItemStack(AEItemStackRegistry.getRegisteredStack(stack), stack.getCount());
     }
 
-	public static IAEItemStack fromNBT( final NBTTagCompound i )
+    public static IAEItemStack fromNBT(final NBTTagCompound i) {
-	{
+        if (i == null) {
-		if( i == null )
-		{
             return null;
         }
 
-		final ItemStack itemstack = new ItemStack( i );
+        final ItemStack itemstack = new ItemStack(i);
-		if( itemstack.isEmpty() )
+        final AEItemStack item = AEItemStack.fromItemStack(itemstack);
-		{
+        if (item == null) {
             return null;
         }
 
-		final AEItemStack item = AEItemStack.fromItemStack( itemstack );
+        item.setStackSize(i.getLong(NBT_STACKSIZE));
-		item.setStackSize( i.getLong( "Cnt" ) );
+        item.setCountRequestable(i.getLong(NBT_REQUESTABLE));
-		item.setCountRequestable( i.getLong( "Req" ) );
+        item.setCraftable(i.getBoolean(NBT_CRAFTABLE));
-		item.setCraftable( i.getBoolean( "Craft" ) );
         return item;
     }
 
     @Override
-	public void writeToNBT( final NBTTagCompound i )
+    public void writeToNBT(final NBTTagCompound i) {
-	{
+        final NBTTagCompound itemStack = new NBTTagCompound();
-		this.getDefinition().writeToNBT( i );
+        this.getDefinition().writeToNBT(itemStack);
-		i.setLong( "Cnt", this.getStackSize() );
+
-		i.setLong( "Req", this.getCountRequestable() );
+        i.setLong(NBT_STACKSIZE, this.getStackSize());
-		i.setBoolean( "Craft", this.isCraftable() );
+        i.setLong(NBT_REQUESTABLE, this.getCountRequestable());
+        i.setBoolean(NBT_CRAFTABLE, this.isCraftable());
     }
 
     public static AEItemStack fromPacket( final ByteBuf data )
@@ -150,36 +141,27 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
     }
 
     @Override
-	public void add( final IAEItemStack option )
+    public void add(final IAEItemStack option) {
-	{
+        if (option == null) {
-		if( option == null )
-		{
             return;
         }
 
-		this.incStackSize( option.getStackSize() );
+        this.incStackSize(option.getStackSize());
-		this.setCountRequestable( this.getCountRequestable() + option.getCountRequestable() );
+        this.setCountRequestable(this.getCountRequestable() + option.getCountRequestable());
-		this.setCraftable( this.isCraftable() || option.isCraftable() );
+        this.setCraftable(this.isCraftable() || option.isCraftable());
     }
 
     @Override
-	public boolean fuzzyComparison( final IAEItemStack other, final FuzzyMode mode )
+    public boolean fuzzyComparison(final IAEItemStack other, final FuzzyMode mode) {
-	{
-		if( mode == FuzzyMode.IGNORE_ALL && OreHelper.INSTANCE.sameOre( this, other ) )
-		{
-			return true;
-		}
-
         final ItemStack itemStack = this.getDefinition();
         final ItemStack otherStack = other.getDefinition();
 
-		return this.fuzzyItemStackComparison( itemStack, otherStack, mode );
+        return this.fuzzyItemStackComparison(itemStack, otherStack, mode);
     }
 
     @Override
-	public IAEItemStack copy()
+    public IAEItemStack copy() {
-	{
+        return new AEItemStack(this);
-		return new AEItemStack( this );
     }
 
     @Override
@@ -195,26 +177,23 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
     }
 
     @Override
-	public IStorageChannel<IAEItemStack> getChannel()
+    public IStorageChannel<IAEItemStack> getChannel() {
-	{
+        return Api.INSTANCE.storage().getStorageChannel(IItemStorageChannel.class);
-		return AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class );
     }
 
     @Override
-	public ItemStack createItemStack()
+    public ItemStack createItemStack() {
-	{
+        return ItemHandlerHelper.copyStackWithSize(this.getDefinition(),
-		return ItemHandlerHelper.copyStackWithSize( this.getDefinition(), (int) Math.min( Integer.MAX_VALUE, this.getStackSize() ) );
+                (int) Math.min(Integer.MAX_VALUE, this.getStackSize()));
     }
 
     @Override
-	public Item getItem()
+    public Item getItem() {
-	{
         return this.getDefinition().getItem();
     }
 
     @Override
-	public int getItemDamage()
+    public int getItemDamage() {
-	{
         return this.sharedStack.getItemDamage();
     }
 
@@ -225,92 +204,73 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
     }
 
     @Override
-	public boolean isSameType( final IAEItemStack otherStack )
+    public boolean isSameType(final IAEItemStack otherStack) {
-	{
+        if (otherStack == null) {
-		if( otherStack == null )
-		{
             return false;
         }
 
-		return Objects.equals( this.sharedStack, ( (AEItemStack) otherStack ).sharedStack );
+        return Objects.equals(this.sharedStack, ((AEItemStack) otherStack).sharedStack);
     }
 
     @Override
-	public boolean isSameType( final ItemStack otherStack )
+    public boolean isSameType(final ItemStack otherStack) {
-	{
+        if (otherStack.isEmpty()) {
-		if( otherStack.isEmpty() )
-		{
             return false;
         }
         int oldSize = otherStack.getCount();
 
-		otherStack.setCount( 1 );
+        otherStack.setCount(1);
-		boolean ret = ItemStack.areItemStacksEqual( this.getDefinition(), otherStack );
+        boolean ret = ItemStack.areItemStacksEqual(this.getDefinition(), otherStack);
-		otherStack.setCount( oldSize );
+        otherStack.setCount(oldSize);
 
         return ret;
     }
 
     @Override
-	public int hashCode()
+    public int hashCode() {
-	{
         return this.sharedStack.hashCode();
     }
 
     @Override
-	public boolean equals( final Object ia )
+    public boolean equals(final Object ia) {
-	{
+        if (ia instanceof AEItemStack) {
-		if( ia instanceof AEItemStack )
+            return this.isSameType((AEItemStack) ia);
-		{
+        } else if (ia instanceof ItemStack) {
-			return this.isSameType( (AEItemStack) ia );
+            // this actually breaks the equals contract (being equals to unrelated classes)
-		}
+            return equals((ItemStack) ia);
-		else if( ia instanceof ItemStack )
-		{
-			return this.isSameType( (ItemStack) ia );
         }
         return false;
     }
 
     @Override
-	public String toString()
+    public boolean equals(final ItemStack is) {
-	{
+        return this.isSameType(is);
-		return this.getStackSize() + "x" + this.getDefinition().getItem().getUnlocalizedName() + "@" + this.getDefinition().getItemDamage();
     }
 
-	@SideOnly( Side.CLIENT )
+    @Override
-	public List<String> getToolTip()
+    public String toString() {
-	{
+        return this.getStackSize() + "x" + this.getDefinition().getItem().getRegistryName();
-		if( this.tooltip == null )
+    }
-		{
+
-			this.tooltip = Platform.getTooltip( this.asItemStackRepresentation() );
+    @SideOnly(Side.CLIENT)
+    public List<String> getToolTip() {
+        if (this.tooltip == null) {
+            this.tooltip = Platform.getTooltip(this.asItemStackRepresentation());
         }
         return this.tooltip;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public String getDisplayName()
+    public String getDisplayName() {
-	{
+        if (this.displayName == null) {
-		if( this.displayName == null )
+            this.displayName = Platform.getItemDisplayName(this.asItemStackRepresentation());
-		{
-			this.displayName = Platform.getItemDisplayName( this.asItemStackRepresentation() );
         }
         return this.displayName;
     }
 
-	@SideOnly( Side.CLIENT )
+    @SideOnly(Side.CLIENT)
-	public String getModID()
+    public String getModID() {
-	{
+        return this.getDefinition().getItem().getRegistryName().getResourceDomain();
-		if( this.uniqueID == null )
-		{
-			this.uniqueID = Item.REGISTRY.getNameForObject( this.getDefinition().getItem() );
-		}
-
-		if( this.uniqueID == null )
-		{
-			return "** Null";
-		}
-
-		return this.uniqueID.getResourceDomain() == null ? "** Null" : this.uniqueID.getResourceDomain();
     }
 
     public Optional<OreReference> getOre()
@@ -319,55 +279,38 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
     }
 
     @Override
-	public boolean hasTagCompound()
+    public boolean hasTagCompound() {
-	{
         return this.getDefinition().hasTagCompound();
     }
 
     @Override
-	public ItemStack asItemStackRepresentation()
+    public ItemStack asItemStackRepresentation() {
-	{
         return this.getDefinition().copy();
     }
 
     @Override
-	public ItemStack getDefinition()
+    public ItemStack getDefinition() {
-	{
         return this.sharedStack.getDefinition();
     }
 
-	AESharedItemStack getSharedStack()
+    AESharedItemStack getSharedStack() {
-	{
         return this.sharedStack;
     }
 
-	private boolean fuzzyItemStackComparison( ItemStack a, ItemStack b, FuzzyMode mode )
+    private boolean fuzzyItemStackComparison(ItemStack a, ItemStack b, FuzzyMode mode) {
-	{
+        if (a.getItem() == b.getItem() && a.getItem().isDamageable()) {
-		if( a.getItem() == b.getItem() )
+            if (mode == FuzzyMode.IGNORE_ALL) {
-		{
-			if( a.getItem().isDamageable() )
-			{
-				if( mode == FuzzyMode.IGNORE_ALL )
-				{
                 return true;
-				}
+            } else if (mode == FuzzyMode.PERCENT_99) {
-				else if( mode == FuzzyMode.PERCENT_99 )
+                return a.getItemDamage() > 1 == b.getItemDamage() > 1;
-				{
+            } else {
-					return ( a.getItemDamage() > 1 ) == ( b.getItemDamage() > 1 );
+                final float percentDamageOfA = (float) a.getItemDamage() / a.getMaxDamage();
-				}
+                final float percentDamageOfB = (float) b.getItemDamage() / b.getMaxDamage();
-				else
-				{
-					final float percentDamageOfA = (float) a.getItemDamage() / (float) a.getMaxDamage();
-					final float percentDamageOfB = (float) b.getItemDamage() / (float) b.getMaxDamage();
 
-					return ( percentDamageOfA > mode.breakPoint ) == ( percentDamageOfB > mode.breakPoint );
+                return percentDamageOfA > mode.breakPoint == percentDamageOfB > mode.breakPoint;
             }
         }
 
-			return a.getMetadata() == b.getMetadata();
-		}
-
         return false;
     }
-
 }

src/main/java/appeng/util/item/AEItemStackRegistry.java

@@ -23,7 +23,6 @@
 
 package appeng.util.item;
 
-
 import java.lang.ref.WeakReference;
 import java.util.WeakHashMap;
 
@@ -31,55 +30,33 @@ import javax.annotation.Nonnull;
 
 import net.minecraft.item.ItemStack;
 
-import appeng.util.Platform;
+public final class AEItemStackRegistry {
+    private static final WeakHashMap<AESharedItemStack, WeakReference<AESharedItemStack>> REGISTRY = new WeakHashMap<>();
 
-
+    private AEItemStackRegistry() {
-public final class AEItemStackRegistry
-{
-	private static final WeakHashMap<AESharedItemStack, WeakReference<AESharedItemStack>> SERVER_REGISTRY = new WeakHashMap<>();
-	private static final WeakHashMap<AESharedItemStack, WeakReference<AESharedItemStack>> CLIENT_REGISTRY = new WeakHashMap<>();
-
-	private AEItemStackRegistry()
-	{
     }
 
-	private static WeakHashMap<AESharedItemStack, WeakReference<AESharedItemStack>> registry()
+    static synchronized AESharedItemStack getRegisteredStack(final @Nonnull ItemStack itemStack) {
-	{
+        if (itemStack.isEmpty()) {
-		if( Platform.isClient() )
+            throw new IllegalArgumentException("stack cannot be empty");
-		{
-			return CLIENT_REGISTRY;
-		}
-		else
-		{
-			return SERVER_REGISTRY;
-		}
-	}
-
-	static synchronized AESharedItemStack getRegisteredStack( final @Nonnull ItemStack itemStack )
-	{
-		if( itemStack.isEmpty() )
-		{
-			throw new IllegalArgumentException( "stack cannot be empty" );
         }
 
         int oldStackSize = itemStack.getCount();
-		itemStack.setCount( 1 );
+        itemStack.setCount(1);
 
-		AESharedItemStack search = new AESharedItemStack( itemStack );
+        AESharedItemStack search = new AESharedItemStack(itemStack);
-		WeakReference<AESharedItemStack> weak = registry().get( search );
+        WeakReference<AESharedItemStack> weak = REGISTRY.get(search);
         AESharedItemStack ret = null;
 
-		if( weak != null )
+        if (weak != null) {
-		{
             ret = weak.get();
         }
 
-		if( ret == null )
+        if (ret == null) {
-		{
+            ret = new AESharedItemStack(itemStack.copy());
-			ret = new AESharedItemStack( itemStack.copy() );
+            REGISTRY.put(ret, new WeakReference<>(ret));
-			registry().put( ret, new WeakReference<>( ret ) );
         }
-		itemStack.setCount( oldStackSize );
+        itemStack.setCount(oldStackSize);
 
         return ret;
     }

src/main/java/appeng/util/item/AESharedItemStack.java

@@ -18,263 +18,76 @@
 
 package appeng.util.item;
 
-
 import java.util.Objects;
 
 import com.google.common.base.Preconditions;
 
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
 
-import appeng.api.config.FuzzyMode;
+final class AESharedItemStack {
-
-
-final class AESharedItemStack implements Comparable<AESharedItemStack>
-{
-	private static final NBTTagCompound LOW_TAG = new NBTTagCompound();
-	private static final NBTTagCompound HIGH_TAG = new NBTTagCompound();
 
     private final ItemStack itemStack;
     private final int itemId;
     private final int itemDamage;
     private final int hashCode;
 
-	public AESharedItemStack( final ItemStack itemStack )
+    public AESharedItemStack(final ItemStack itemStack) {
-	{
+        this(itemStack, itemStack.getItemDamage());
+    }
+
+    /**
+     * A constructor to explicitly set the damage value and not fetch it from the {@link ItemStack}
+     *
+     * @param itemStack The {@link ItemStack} to filter
+     * @param damage    The damage of the item
+     */
+    private AESharedItemStack(ItemStack itemStack, int damage) {
         this.itemStack = itemStack;
-		this.itemId = Item.getIdFromItem( itemStack.getItem() );
+        this.itemId = Item.getIdFromItem(itemStack.getItem());
-		this.itemDamage = itemStack.getItemDamage();
+        this.itemDamage = damage;
+
+        // Ensure this is always called last.
         this.hashCode = this.makeHashCode();
     }
 
-	Bounds getBounds( final FuzzyMode fuzzy, final boolean ignoreMeta )
+    ItemStack getDefinition() {
-	{
-		return new Bounds( this.itemStack, fuzzy, ignoreMeta );
-	}
-
-	ItemStack getDefinition()
-	{
         return this.itemStack;
     }
 
-	int getItemDamage()
+    int getItemDamage() {
-	{
         return this.itemDamage;
     }
 
-	int getItemID()
-	{
-		return this.itemId;
-	}
-
     @Override
-	public int hashCode()
+    public int hashCode() {
-	{
         return this.hashCode;
     }
 
     @Override
-	public boolean equals( final Object obj )
+    public boolean equals(final Object obj) {
-	{
+        if (this == obj) {
-		if( obj instanceof AESharedItemStack )
-		{
-			final AESharedItemStack other = (AESharedItemStack) obj;
-
-			Preconditions.checkState( this.itemStack.getCount() == 1, "ItemStack#getCount() has to be 1" );
-			Preconditions.checkArgument( other.getDefinition().getCount() == 1, "ItemStack#getCount() has to be 1" );
-
-			if( this.itemStack == other.itemStack )
-			{
             return true;
         }
-			return ItemStack.areItemStacksEqual( this.itemStack, other.itemStack );
+        if (!(obj instanceof AESharedItemStack)) {
-		}
             return false;
         }
 
-	@Override
+        final AESharedItemStack other = (AESharedItemStack) obj;
-	public int compareTo( final AESharedItemStack b )
+        Preconditions.checkState(this.itemStack.getCount() == 1, "ItemStack#getCount() has to be 1");
-	{
+        Preconditions.checkArgument(other.getDefinition().getCount() == 1, "ItemStack#getCount() has to be 1");
-		Preconditions.checkState( this.itemStack.getCount() == 1, "ItemStack#getCount() has to be 1" );
-		Preconditions.checkArgument( b.getDefinition().getCount() == 1, "ItemStack#getCount() has to be 1" );
 
-		if( this.itemStack == b.getDefinition() )
+        if (this.itemStack == other.itemStack) {
-		{
+            return true;
-			return 0;
+        }
+        return ItemStack.areItemStacksEqual(this.itemStack, other.itemStack);
     }
 
-		final int id = this.itemId - b.itemId;
+    private int makeHashCode() {
-		if( id != 0 )
+        return Objects.hash(
-		{
+                this.itemId,
-			return id;
+                this.itemDamage,
+                this.itemStack.hasTagCompound() ? this.itemStack.getTagCompound() : 0);
     }
 
-		final int damageValue = this.itemDamage - b.itemDamage;
-		if( damageValue != 0 )
-		{
-			return damageValue;
-		}
-
-		final int nbt = this.compareNBT( b.getDefinition() );
-		if( nbt != 0 )
-		{
-			return nbt;
-		}
-
-		if( !this.itemStack.areCapsCompatible( b.getDefinition() ) )
-		{
-			return System.identityHashCode( this.itemStack ) - System.identityHashCode( b.getDefinition() );
-		}
-		return 0;
-	}
-
-	private int compareNBT( final ItemStack b )
-	{
-		if( this.itemStack.getTagCompound() == b.getTagCompound() )
-		{
-			return 0;
-		}
-		if( this.itemStack.getTagCompound() == LOW_TAG || b.getTagCompound() == HIGH_TAG )
-		{
-			return -1;
-		}
-		if( this.itemStack.getTagCompound() == HIGH_TAG || b.getTagCompound() == LOW_TAG )
-		{
-			return 1;
-		}
-		return System.identityHashCode( this.itemStack.getTagCompound() ) - System.identityHashCode( b.getTagCompound() );
-	}
-
-	private int makeHashCode()
-	{
-		return Objects.hash( this.itemId, this.itemDamage, this.itemStack.hasTagCompound() ? this.itemStack.getTagCompound() : 0 );
-	}
-
-	/**
-	 * Creates the lower and upper bounds for a specific shared itemstack.
-	 */
-	public static final class Bounds
-	{
-		/**
-		 * Bounds enforced by {@link ItemStack#isEmpty()}
-		 */
-		private static final int MIN_DAMAGE_VALUE = 0;
-		private static final int MAX_DAMAGE_VALUE = 65535;
-
-		private final AESharedItemStack lower;
-		private final AESharedItemStack upper;
-
-		public Bounds( final ItemStack stack, final FuzzyMode fuzzy, final boolean ignoreMeta )
-		{
-			Preconditions.checkState( !stack.isEmpty(), "ItemStack#isEmpty() has to be false" );
-			Preconditions.checkState( stack.getCount() == 1, "ItemStack#getCount() has to be 1" );
-
-			final NBTTagCompound tag = stack.hasTagCompound() ? stack.getTagCompound() : null;
-
-			this.lower = this.makeLowerBound( stack, tag, fuzzy, ignoreMeta );
-			this.upper = this.makeUpperBound( stack, tag, fuzzy, ignoreMeta );
-		}
-
-		public AESharedItemStack lower()
-		{
-			return this.lower;
-		}
-
-		public AESharedItemStack upper()
-		{
-			return this.upper;
-		}
-
-		private AESharedItemStack makeLowerBound( final ItemStack itemStack, final NBTTagCompound tag, final FuzzyMode fuzzy, final boolean ignoreMeta )
-		{
-			final ItemStack newDef = itemStack.copy();
-
-			if( ignoreMeta )
-			{
-				newDef.setItemDamage( MIN_DAMAGE_VALUE );
-				newDef.setTagCompound( tag );
-			}
-			else
-			{
-				if( newDef.getItem().isDamageable() )
-				{
-					if (itemStack.getMaxDamage() == 0)
-					{
-						newDef.setItemDamage(itemStack.getItemDamage() );
-					}
-					else if ( fuzzy == FuzzyMode.IGNORE_ALL )
-					{
-						newDef.setItemDamage( MIN_DAMAGE_VALUE );
-					}
-					else if( fuzzy == FuzzyMode.PERCENT_99 )
-					{
-						if( itemStack.getItemDamage() == MIN_DAMAGE_VALUE )
-						{
-							newDef.setItemDamage( MIN_DAMAGE_VALUE );
-						}
-						else
-						{
-							newDef.setItemDamage( MIN_DAMAGE_VALUE + 1 );
-						}
-					}
-					else
-					{
-						final int breakpoint = fuzzy.calculateBreakPoint( itemStack.getMaxDamage() );
-						final int damage = breakpoint <= itemStack.getItemDamage() ? breakpoint : 0;
-						newDef.setItemDamage( damage );
-					}
-				}
-				newDef.setTagCompound( LOW_TAG );
-			}
-
-			return new AESharedItemStack( newDef );
-		}
-
-		private AESharedItemStack makeUpperBound( final ItemStack itemStack, final NBTTagCompound tag, final FuzzyMode fuzzy, final boolean ignoreMeta )
-		{
-			final ItemStack newDef = itemStack.copy();
-
-			if( ignoreMeta )
-			{
-				newDef.setItemDamage( MAX_DAMAGE_VALUE );
-				newDef.setTagCompound( tag );
-			}
-			else
-			{
-				if( newDef.getItem().isDamageable() )
-				{
-					if (itemStack.getMaxDamage() == 0)
-					{
-						newDef.setItemDamage(itemStack.getItemDamage() );
-					}
-					else if ( fuzzy == FuzzyMode.IGNORE_ALL )
-					{
-						newDef.setItemDamage( itemStack.getMaxDamage() + 1 );
-					}
-					else if( fuzzy == FuzzyMode.PERCENT_99 )
-					{
-						if( itemStack.getItemDamage() == MIN_DAMAGE_VALUE )
-						{
-							newDef.setItemDamage( MIN_DAMAGE_VALUE );
-						}
-						else
-						{
-							newDef.setItemDamage( itemStack.getMaxDamage() + 1 );
-						}
-					}
-					else
-					{
-						final int breakpoint = fuzzy.calculateBreakPoint( itemStack.getMaxDamage() );
-						final int damage = itemStack.getItemDamage() < breakpoint ? breakpoint - 1 : itemStack.getMaxDamage() + 1;
-						newDef.setItemDamage( damage );
-					}
-				}
-				newDef.setTagCompound( HIGH_TAG );
-			}
-
-			return new AESharedItemStack( newDef );
-		}
-
-	}
 }

src/main/java/appeng/util/item/AEStack.java

@@ -18,14 +18,11 @@
 
 package appeng.util.item;
 
-
+import appeng.api.storage.data.IAEStack;
 import io.netty.buffer.ByteBuf;
 
-import appeng.api.storage.data.IAEStack;
 
-
+public abstract class AEStack<T extends IAEStack<T>> implements IAEStack<T> {
-public abstract class AEStack<StackType extends IAEStack<StackType>> implements IAEStack<StackType>
-{
 
     private boolean isCraftable;
     private long stackSize;
@@ -56,89 +53,75 @@ public abstract class AEStack<StackType extends IAEStack<StackType>> implements
     }
 
     @Override
-	public long getStackSize()
+    public long getStackSize() {
-	{
         return this.stackSize;
     }
 
     @Override
-	public StackType setStackSize( final long ss )
+    public T setStackSize(final long ss) {
-	{
         this.stackSize = ss;
-		return (StackType) this;
+        return (T) this;
     }
 
     @Override
-	public long getCountRequestable()
+    public long getCountRequestable() {
-	{
         return this.countRequestable;
     }
 
     @Override
-	public StackType setCountRequestable( final long countRequestable )
+    public T setCountRequestable(final long countRequestable) {
-	{
         this.countRequestable = countRequestable;
-		return (StackType) this;
+        return (T) this;
     }
 
     @Override
-	public boolean isCraftable()
+    public boolean isCraftable() {
-	{
         return this.isCraftable;
     }
 
     @Override
-	public StackType setCraftable( final boolean isCraftable )
+    public T setCraftable(final boolean isCraftable) {
-	{
         this.isCraftable = isCraftable;
-		return (StackType) this;
+        return (T) this;
     }
 
     @Override
-	public StackType reset()
+    public T reset() {
-	{
         this.stackSize = 0;
-		// priority = Integer.MIN_VALUE;
+        this.setCountRequestable(0);
-		this.setCountRequestable( 0 );
+        this.setCraftable(false);
-		this.setCraftable( false );
+        return (T) this;
-		return (StackType) this;
     }
 
     @Override
-	public StackType empty()
+    public T empty() {
-	{
+        final T dup = this.copy();
-		final StackType dup = this.copy();
         dup.reset();
         return dup;
     }
 
     @Override
-	public boolean isMeaningful()
+    public boolean isMeaningful() {
-	{
         return this.stackSize != 0 || this.countRequestable > 0 || this.isCraftable;
     }
 
     @Override
-	public void incStackSize( final long i )
+    public void incStackSize(final long i) {
-	{
         this.stackSize += i;
     }
 
     @Override
-	public void decStackSize( final long i )
+    public void decStackSize(final long i) {
-	{
         this.stackSize -= i;
     }
 
     @Override
-	public void incCountRequestable( final long i )
+    public void incCountRequestable(final long i) {
-	{
         this.countRequestable += i;
     }
 
     @Override
-	public void decCountRequestable( final long i )
+    public void decCountRequestable(final long i) {
-	{
         this.countRequestable -= i;
     }
 

src/main/java/appeng/util/item/FuzzyItemVariantList.java

@@ -0,0 +1,190 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2021, TeamAppliedEnergistics, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.util.item;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+
+import com.google.common.base.Preconditions;
+
+import net.minecraft.item.ItemStack;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectAVLTreeMap;
+import it.unimi.dsi.fastutil.objects.Object2ObjectSortedMap;
+
+import appeng.api.config.FuzzyMode;
+import appeng.api.storage.data.IAEItemStack;
+
+/**
+ * This variant list is optimized for damageable items, and supports selecting durability ranges with
+ * {@link #findFuzzy(IAEItemStack, FuzzyMode)}.
+ */
+class FuzzyItemVariantList extends ItemVariantList {
+
+    static final SharedStackComparator COMPARATOR = new SharedStackComparator();
+
+    // NOTE: We only use Object as they key here so we can pass our special DamageBounds to the subMap method.
+    // We NEVER put any keys in this map that are not AESharedItemStacks.
+    private final Object2ObjectSortedMap<Object, IAEItemStack> records = new Object2ObjectAVLTreeMap<>(COMPARATOR);
+
+    @Override
+    public Collection<IAEItemStack> findFuzzy(final IAEItemStack filter, final FuzzyMode fuzzy) {
+        ItemStack itemStack = filter.getDefinition();
+
+        ItemDamageBound lowerBound = makeLowerBound(itemStack, fuzzy);
+        ItemDamageBound upperBound = makeUpperBound(itemStack, fuzzy);
+        Preconditions.checkState(lowerBound.itemDamage > upperBound.itemDamage);
+
+        return this.records.subMap(lowerBound, upperBound).values();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    Map<AESharedItemStack, IAEItemStack> getRecords() {
+        // We ensure on our end that we NEVER use anything but AESharedItemStack as the key in this map
+        return (Map<AESharedItemStack, IAEItemStack>) (Object) this.records;
+    }
+
+    static class ItemDamageBound {
+        final int itemDamage;
+
+        public ItemDamageBound(int itemDamage) {
+            this.itemDamage = itemDamage;
+        }
+    }
+
+    /**
+     * This comparator creates a strict and total ordering over all {@link AESharedItemStack} of the same item. To
+     * support selecting ranges of durability, it is defined for type {@link Object} and also accepts
+     * {@link ItemDamageBound} as an argument to compare against.
+     */
+    static class SharedStackComparator implements Comparator<Object> {
+        @Override
+        public int compare(Object a, Object b) {
+            // Either argument can either be a damage bound or a shared item stack
+            // Since we never put damage bounds into the map as keys, only one
+            // of the two arguments can possibly be a bound
+            ItemDamageBound boundA = null;
+            AESharedItemStack stackA = null;
+            int itemDamageA;
+            if (a instanceof ItemDamageBound) {
+                boundA = (ItemDamageBound) a;
+                itemDamageA = boundA.itemDamage;
+            } else {
+                stackA = (AESharedItemStack) a;
+                itemDamageA = stackA.getItemDamage();
+            }
+            ItemDamageBound boundB = null;
+            AESharedItemStack stackB = null;
+            int itemDamageB;
+            if (b instanceof ItemDamageBound) {
+                boundB = (ItemDamageBound) b;
+                itemDamageB = boundB.itemDamage;
+            } else {
+                stackB = (AESharedItemStack) b;
+                itemDamageB = stackB.getItemDamage();
+            }
+
+            // When either argument is a damage bound, we just compare the damage values because it is used
+            // only to get a certain damage range out of the map.
+            if (boundA != null || boundB != null) {
+                return Integer.compare(itemDamageB, itemDamageA);
+            }
+
+            ItemStack itemStackA = stackA.getDefinition();
+            ItemStack itemStackB = stackB.getDefinition();
+            Preconditions.checkState(itemStackA.getCount() == 1, "ItemStack#getCount() has to be 1");
+            Preconditions.checkArgument(itemStackB.getCount() == 1, "ItemStack#getCount() has to be 1");
+
+            if (itemStackA == itemStackB) {
+                return 0;
+            }
+
+            // Damaged items are sorted before undamaged items
+            final int damageValue = Integer.compare(itemDamageB, itemDamageA);
+            if (damageValue != 0) {
+                return damageValue;
+            }
+
+            // As a final tie breaker, order by the object identity of the item stack
+            // While this will order seemingly at random, we only need the order of
+            // damage values to be predictable, while still having to satisfy the
+            // complete order requirements of the sorted map
+            return Long.compare(System.identityHashCode(itemStackA), System.identityHashCode(itemStackB));
+        }
+    }
+
+    /**
+     * Minecraft reverses the damage values. So anything with a damage of 0 is undamaged and increases the more damaged
+     * the item is.
+     * <p>
+     * Further the used subMap follows [MAX_DAMAGE, MIN_DAMAGE), so to include undamaged items, we have to start with a
+     * lower damage value than 0, while it is fine to use {@link ItemStack#getMaxDamage()} for the upper bound.
+     */
+    private static final int MIN_DAMAGE_VALUE = -1;
+
+    /*
+     * Keep in mind that the stack order is from most damaged to least damaged, so this lower bound will actually be a
+     * higher number than the upper bound.
+     */
+    static ItemDamageBound makeLowerBound(final ItemStack stack, final FuzzyMode fuzzy)
+    {
+        Preconditions.checkState( stack.getItem().isDamageable(), "Item#isDamageable() has to be true" );
+
+        int damage;
+        if( fuzzy == FuzzyMode.IGNORE_ALL )
+        {
+            if( stack.getMaxDamage() == 0 )
+            {
+                damage = stack.getItemDamage();
+            }
+            else
+            {
+                damage = stack.getMaxDamage();
+            }
+        }
+        else
+        {
+            final int breakpoint = fuzzy.calculateBreakPoint( stack.getMaxDamage() );
+            damage = stack.getItemDamage() <= breakpoint ? breakpoint : stack.getMaxDamage();
+        }
+
+        return new ItemDamageBound( damage );
+    }
+
+    /*
+     * Keep in mind that the stack order is from most damaged to least damaged, so this upper bound will actually be a
+     * lower number than the lower bound. It also is exclusive.
+     */
+    static ItemDamageBound makeUpperBound(final ItemStack stack, final FuzzyMode fuzzy) {
+        Preconditions.checkState(stack.getItem().isDamageable(), "Item#isDamageable() has to be true");
+
+        int damage;
+        if (fuzzy == FuzzyMode.IGNORE_ALL) {
+            damage = MIN_DAMAGE_VALUE;
+        } else {
+            final int breakpoint = fuzzy.calculateBreakPoint(stack.getMaxDamage());
+            damage = stack.getItemDamage() <= breakpoint ? MIN_DAMAGE_VALUE : breakpoint;
+        }
+
+        return new ItemDamageBound(damage);
+    }
+
+}

src/main/java/appeng/util/item/ItemList.java

@@ -1,6 +1,6 @@
 /*
  * This file is part of Applied Energistics 2.
- * Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
+ * Copyright (c) 2013 - 2020, AlgorithmX2, All rights reserved.
  *
  * Applied Energistics 2 is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -18,175 +18,104 @@
 
 package appeng.util.item;
 
-
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.ConcurrentModificationException;
 import java.util.Iterator;
-import java.util.NavigableMap;
+import java.util.NoSuchElementException;
-import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
-import net.minecraftforge.oredict.OreDictionary;
+import net.minecraft.item.Item;
+
+import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
+import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
 
 import appeng.api.config.FuzzyMode;
 import appeng.api.storage.data.IAEItemStack;
 import appeng.api.storage.data.IItemList;
-import appeng.util.item.AESharedItemStack.Bounds;
 
+public final class ItemList implements IItemList<IAEItemStack> {
 
-public final class ItemList implements IItemList<IAEItemStack>
+    private final Reference2ObjectMap<Item, ItemVariantList> records = new Reference2ObjectOpenHashMap<>();
-{
+    /**
-
+     * We increment this version field everytime an attempt to mutate this item list (or potentially one of its
-	private final NavigableMap<AESharedItemStack, IAEItemStack> records = new ConcurrentSkipListMap<>();
+     * sub-lists) is made. Iterators will copy the version when they are created and compare it against the current
+     * version whenever they advance to trigger a {@link ConcurrentModificationException}.
+     */
+    private final AtomicInteger version = new AtomicInteger(0);
 
     @Override
-	public void add( final IAEItemStack option )
+    public IAEItemStack findPrecise(final IAEItemStack itemStack) {
-	{
+        if (itemStack == null) {
-		if( option == null )
-		{
-			return;
-		}
-
-		final IAEItemStack st = this.records.get( ( (AEItemStack) option ).getSharedStack() );
-
-		if( st != null )
-		{
-			st.add( option );
-			return;
-		}
-
-		final IAEItemStack opt = option.copy();
-
-		this.putItemRecord( opt );
-	}
-
-	@Override
-	public IAEItemStack findPrecise( final IAEItemStack itemStack )
-	{
-		if( itemStack == null )
-		{
             return null;
         }
 
-		return this.records.get( ( (AEItemStack) itemStack ).getSharedStack() );
+        ItemVariantList record = this.records.get(itemStack.getItem());
+        return record != null ? record.findPrecise(itemStack) : null;
     }
 
     @Override
-	public Collection<IAEItemStack> findFuzzy( final IAEItemStack filter, final FuzzyMode fuzzy )
+    public Collection<IAEItemStack> findFuzzy(final IAEItemStack filter, final FuzzyMode fuzzy) {
-	{
+        if (filter == null) {
-		if( filter == null )
-		{
             return Collections.emptyList();
         }
 
-		final AEItemStack ais = (AEItemStack) filter;
+        ItemVariantList record = this.records.get(filter.getItem());
-
+        return record != null ? record.findFuzzy(filter, fuzzy) : Collections.emptyList();
-		return ais.getOre().map( or ->
-		{
-			if( or.getAEEquivalents().size() == 1 )
-			{
-				final IAEItemStack is = or.getAEEquivalents().get( 0 );
-
-				return this.findFuzzyDamage( is, fuzzy, is.getItemDamage() == OreDictionary.WILDCARD_VALUE );
-			}
-			else
-			{
-				final Collection<IAEItemStack> output = new ArrayList<>();
-
-				for( final IAEItemStack is : or.getAEEquivalents() )
-				{
-					output.addAll( this.findFuzzyDamage( is, fuzzy, is.getItemDamage() == OreDictionary.WILDCARD_VALUE ) );
-				}
-
-				return output;
-			}
-		} ).orElse( this.findFuzzyDamage( ais, fuzzy, false ) );
     }
 
     @Override
-	public boolean isEmpty()
+    public boolean isEmpty() {
-	{
         return !this.iterator().hasNext();
     }
 
     @Override
-	public void addStorage( final IAEItemStack option )
+    public void add(final IAEItemStack itemStack) {
-	{
+        version.incrementAndGet();
-		if( option == null )
+
-		{
+        if (itemStack == null) {
             return;
         }
 
-		final IAEItemStack st = this.records.get( ( (AEItemStack) option ).getSharedStack() );
+        this.getOrCreateRecord(itemStack.getItem()).add(itemStack);
-
-		if( st != null )
-		{
-			st.incStackSize( option.getStackSize() );
-			return;
-		}
-
-		final IAEItemStack opt = option.copy();
-
-		this.putItemRecord( opt );
-	}
-
-	/*
-	 * public void clean() { Iterator<StackType> i = iterator(); while (i.hasNext()) { StackType AEI =
-	 * i.next(); if ( !AEI.isMeaningful() ) i.remove(); } }
-	 */
-
-	@Override
-	public void addCrafting( final IAEItemStack option )
-	{
-		if( option == null )
-		{
-			return;
-		}
-
-		final IAEItemStack st = this.records.get( ( (AEItemStack) option ).getSharedStack() );
-
-		if( st != null )
-		{
-			st.setCraftable( true );
-			return;
-		}
-
-		final IAEItemStack opt = option.copy();
-		opt.setStackSize( 0 );
-		opt.setCraftable( true );
-
-		this.putItemRecord( opt );
     }
 
     @Override
-	public void addRequestable( final IAEItemStack option )
+    public void addStorage(final IAEItemStack itemStack) {
-	{
+        version.incrementAndGet();
-		if( option == null )
+
-		{
+        if (itemStack == null) {
             return;
         }
 
-		final IAEItemStack st = this.records.get( ( (AEItemStack) option ).getSharedStack() );
+        this.getOrCreateRecord(itemStack.getItem()).addStorage(itemStack);
-
-		if( st != null )
-		{
-			st.setCountRequestable( st.getCountRequestable() + option.getCountRequestable() );
-			return;
-		}
-
-		final IAEItemStack opt = option.copy();
-		opt.setStackSize( 0 );
-		opt.setCraftable( false );
-		opt.setCountRequestable( option.getCountRequestable() );
-
-		this.putItemRecord( opt );
     }
 
     @Override
-	public IAEItemStack getFirstItem()
+    public void addCrafting(final IAEItemStack itemStack) {
-	{
+        version.incrementAndGet();
-		for( final IAEItemStack stackType : this )
+
-		{
+        if (itemStack == null) {
+            return;
+        }
+
+        this.getOrCreateRecord(itemStack.getItem()).addCrafting(itemStack);
+    }
+
+    @Override
+    public void addRequestable(final IAEItemStack itemStack) {
+        version.incrementAndGet();
+
+        if (itemStack == null) {
+            return;
+        }
+
+        this.getOrCreateRecord(itemStack.getItem()).addRequestable(itemStack);
+    }
+
+    @Override
+    public IAEItemStack getFirstItem() {
+        for (final IAEItemStack stackType : this) {
             return stackType;
         }
 
@@ -194,36 +123,91 @@ public final class ItemList implements IItemList<IAEItemStack>
     }
 
     @Override
-	public int size()
+    public int size() {
-	{
+        int size = 0;
-		return this.records.size();
+        for (ItemVariantList entry : records.values()) {
+            size += entry.size();
+        }
+
+        return size;
     }
 
     @Override
-	public Iterator<IAEItemStack> iterator()
+    public Iterator<IAEItemStack> iterator() {
-	{
+        return new ChainedIterator(this.records.values().iterator(), version);
-		return new MeaningfulItemIterator<>( this.records.values().iterator() );
     }
 
     @Override
-	public void resetStatus()
+    public void resetStatus() {
-	{
+        for (final IAEItemStack i : this) {
-		for( final IAEItemStack i : this )
-		{
             i.reset();
         }
     }
 
-	private IAEItemStack putItemRecord( final IAEItemStack itemStack )
+    private ItemVariantList getOrCreateRecord(Item item) {
-	{
+        return this.records.computeIfAbsent(item, this::makeRecordMap);
-		return this.records.put( ( (AEItemStack) itemStack ).getSharedStack(), itemStack );
     }
 
-	private Collection<IAEItemStack> findFuzzyDamage( final IAEItemStack filter, final FuzzyMode fuzzy, final boolean ignoreMeta )
+    private ItemVariantList makeRecordMap(Item item) {
-	{
+        if (item.isDamageable()) {
-		final AEItemStack itemStack = (AEItemStack) filter;
+            return new FuzzyItemVariantList();
-		final Bounds bounds = itemStack.getSharedStack().getBounds( fuzzy, ignoreMeta );
+        } else {
+            return new NormalItemVariantList();
+        }
+    }
 
-		return this.records.subMap( bounds.lower(), true, bounds.upper(), true ).descendingMap().values();
+    /**
+     * Iterates over multiple item lists as if they were one list.
+     */
+    private static class ChainedIterator implements Iterator<IAEItemStack> {
+
+        private final AtomicInteger parentVersion;
+        private final int version;
+        private final Iterator<ItemVariantList> parent;
+        private Iterator<IAEItemStack> next;
+
+        public ChainedIterator(Iterator<ItemVariantList> iterator, AtomicInteger parentVersion) {
+            this.parent = iterator;
+            this.parentVersion = parentVersion;
+            this.version = parentVersion.get();
+            this.ensureItems();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return next != null && next.hasNext();
+        }
+
+        @Override
+        public IAEItemStack next() {
+            if (this.next == null) {
+                throw new NoSuchElementException();
+            }
+            if (this.version != this.parentVersion.get()) {
+                throw new ConcurrentModificationException();
+            }
+
+            IAEItemStack result = this.next.next();
+            this.ensureItems();
+            return result;
+        }
+
+        private void ensureItems() {
+            if (hasNext()) {
+                return; // Still items left in the current one
+            }
+
+            // Find the next iterator willing to return some items...
+            while (this.parent.hasNext()) {
+                this.next = this.parent.next().iterator();
+
+                if (this.next.hasNext()) {
+                    return; // Found one!
+                }
+            }
+
+            // No more items
+            this.next = null;
+        }
     }
 }

src/main/java/appeng/util/item/ItemVariantList.java

@@ -0,0 +1,118 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2021, TeamAppliedEnergistics, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.util.item;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import appeng.api.config.FuzzyMode;
+import appeng.api.storage.data.IAEItemStack;
+
+/**
+ * Stores variants of a single type of {@link net.minecraft.item.Item}, i.e. versions with different durability, or
+ * different NBT or capabilities.
+ */
+abstract class ItemVariantList {
+
+    public void add(final IAEItemStack option) {
+        final IAEItemStack st = this.getRecords().get(((AEItemStack) option).getSharedStack());
+
+        if (st != null) {
+            st.add(option);
+            return;
+        }
+
+        final IAEItemStack opt = option.copy();
+
+        this.putItemRecord(opt);
+    }
+
+    public IAEItemStack findPrecise(final IAEItemStack itemStack) {
+        return this.getRecords().get(((AEItemStack) itemStack).getSharedStack());
+    }
+
+    public void addStorage(final IAEItemStack option) {
+        final IAEItemStack st = this.getRecords().get(((AEItemStack) option).getSharedStack());
+
+        if (st != null) {
+            st.incStackSize(option.getStackSize());
+            return;
+        }
+
+        final IAEItemStack opt = option.copy();
+
+        this.putItemRecord(opt);
+    }
+
+    public void addCrafting(final IAEItemStack option) {
+        final IAEItemStack st = this.getRecords().get(((AEItemStack) option).getSharedStack());
+
+        if (st != null) {
+            st.setCraftable(true);
+            return;
+        }
+
+        final IAEItemStack opt = option.copy();
+        opt.setStackSize(0);
+        opt.setCraftable(true);
+
+        this.putItemRecord(opt);
+    }
+
+    public void addRequestable(final IAEItemStack option) {
+        final IAEItemStack st = this.getRecords().get(((AEItemStack) option).getSharedStack());
+
+        if (st != null) {
+            st.setCountRequestable(st.getCountRequestable() + option.getCountRequestable());
+            return;
+        }
+
+        final IAEItemStack opt = option.copy();
+        opt.setStackSize(0);
+        opt.setCraftable(false);
+        opt.setCountRequestable(option.getCountRequestable());
+
+        this.putItemRecord(opt);
+    }
+
+    public int size() {
+        int size = 0;
+        for (IAEItemStack entry : getRecords().values()) {
+            if (entry.isMeaningful()) {
+                size++;
+            }
+        }
+
+        return size;
+    }
+
+    public Iterator<IAEItemStack> iterator() {
+        return new MeaningfulItemIterator<>(this.getRecords().values());
+    }
+
+    private void putItemRecord(final IAEItemStack itemStack) {
+        this.getRecords().put(((AEItemStack) itemStack).getSharedStack(), itemStack);
+    }
+
+    abstract Map<AESharedItemStack, IAEItemStack> getRecords();
+
+    public abstract Collection<IAEItemStack> findFuzzy(final IAEItemStack filter, final FuzzyMode fuzzy);
+
+}

src/main/java/appeng/util/item/MeaningfulItemIterator.java

@@ -1,6 +1,6 @@
 /*
  * This file is part of Applied Energistics 2.
- * Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
+ * Copyright (c) 2021, TeamAppliedEnergistics, All rights reserved.
  *
  * Applied Energistics 2 is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as published by
@@ -18,59 +18,53 @@
 
 package appeng.util.item;
 
-
+import java.util.Collection;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
 import appeng.api.storage.data.IAEItemStack;
 
-
+/**
-public class MeaningfulItemIterator<T extends IAEItemStack> implements Iterator<T>
+ * This iterator will only return items from a collection that are meaningful (w.r.t.
-{
+ * {@link IAEItemStack#isMeaningful()}. Items that are not meaningful are automatically removed from the collection as
-
+ * it is being iterated.
+ */
+public class MeaningfulItemIterator<T extends IAEItemStack> implements Iterator<T> {
     private final Iterator<T> parent;
     private T next;
 
-	public MeaningfulItemIterator( final Iterator<T> iterator )
+    public MeaningfulItemIterator(final Collection<T> collection) {
-	{
+        this.parent = collection.iterator();
-		this.parent = iterator;
+        this.next = seekNext();
     }
 
     @Override
-	public boolean hasNext()
+    public boolean hasNext() {
-	{
+        return this.next != null;
-		while( this.parent.hasNext() )
-		{
-			this.next = this.parent.next();
-
-			if( this.next.isMeaningful() )
-			{
-				return true;
-			}
-			else
-			{
-				this.parent.remove(); // self cleaning :3
-			}
-		}
-
-		this.next = null;
-		return false;
     }
 
     @Override
-	public T next()
+    public T next() {
-	{
+        if (this.next == null) {
-		if( this.next == null )
-		{
             throw new NoSuchElementException();
         }
 
-		return this.next;
+        T result = this.next;
+        this.next = this.seekNext();
+        return result;
     }
 
-	@Override
+    private T seekNext() {
-	public void remove()
+        while (this.parent.hasNext()) {
-	{
+            T item = this.parent.next();
+
+            if (item.isMeaningful()) {
+                return item;
+            } else {
                 this.parent.remove();
             }
+        }
+
+        return null;
+    }
 }

src/main/java/appeng/util/item/NormalItemVariantList.java

@@ -0,0 +1,51 @@
+/*
+ * This file is part of Applied Energistics 2.
+ * Copyright (c) 2021, TeamAppliedEnergistics, All rights reserved.
+ *
+ * Applied Energistics 2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Applied Energistics 2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
+ */
+
+package appeng.util.item;
+
+import java.util.Collection;
+import java.util.Map;
+
+import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
+import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
+
+import appeng.api.config.FuzzyMode;
+import appeng.api.storage.data.IAEItemStack;
+
+/**
+ * This variant list is optimized for items that cannot be damaged and thus do not support querying durability ranges
+ * via {@link #findFuzzy(IAEItemStack, FuzzyMode)}.
+ */
+class NormalItemVariantList extends ItemVariantList {
+
+    private final Reference2ObjectMap<AESharedItemStack, IAEItemStack> records = new Reference2ObjectOpenHashMap<>();
+
+    @Override
+    Map<AESharedItemStack, IAEItemStack> getRecords() {
+        return this.records;
+    }
+
+    /**
+     * For items that do not support durability, we just return all variants to a fuzzy search.
+     */
+    @Override
+    public Collection<IAEItemStack> findFuzzy(IAEItemStack filter, FuzzyMode fuzzy) {
+        return this.getRecords().values();
+    }
+
+}