add oredict stuff to Cyclops support, forward port

75e3d69ccf45b0655d929f166e2bd7e21c548d8c

src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/CyclopsComparer.java

@@ -3,40 +3,38 @@ package com.raoulvdberge.refinedstorage.integration.cyclopscore;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
 
-public final class CyclopsComparer {
+public class CyclopsComparer {
     public static int comparerFlagsToItemMatch(int flags) {
-        int itemMatch = 0;
+        return comparerFlagsToItemMatch(flags, false);
+    }
 
+    public static int comparerFlagsToItemMatch(int flags, boolean oredictWildcard) {
+        int itemMatch = 0;
+        if (!oredictWildcard) {
             if ((flags & IComparer.COMPARE_DAMAGE) == IComparer.COMPARE_DAMAGE) {
                 itemMatch |= ItemMatch.DAMAGE;
             }
-
             if ((flags & IComparer.COMPARE_NBT) == IComparer.COMPARE_NBT) {
                 itemMatch |= ItemMatch.NBT;
             }
-
+        }
         if ((flags & IComparer.COMPARE_QUANTITY) == IComparer.COMPARE_QUANTITY) {
             itemMatch |= ItemMatch.STACKSIZE;
         }
-
         return itemMatch;
     }
 
     public static int itemMatchToComparerFlags(int itemMatch) {
         int flags = 0;
-
         if ((itemMatch & ItemMatch.DAMAGE) == ItemMatch.DAMAGE) {
             flags |= IComparer.COMPARE_DAMAGE;
         }
-
         if ((itemMatch & ItemMatch.NBT) == ItemMatch.NBT) {
             flags |= IComparer.COMPARE_NBT;
         }
-
         if ((itemMatch & ItemMatch.STACKSIZE) == ItemMatch.STACKSIZE) {
             flags |= IComparer.COMPARE_QUANTITY;
         }
-
         return flags;
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/SlotlessItemHandlerHelper.java

@@ -1,14 +1,18 @@
 package com.raoulvdberge.refinedstorage.integration.cyclopscore;
 
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
+import com.raoulvdberge.refinedstorage.apiimpl.util.Comparer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.EnumFacing;
 import net.minecraftforge.items.ItemHandlerHelper;
+import net.minecraftforge.oredict.OreDictionary;
 import org.cyclops.commoncapabilities.api.capability.itemhandler.ISlotlessItemHandler;
+import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
 import org.cyclops.commoncapabilities.capability.itemhandler.SlotlessItemHandlerConfig;
 
 import javax.annotation.Nonnull;
+import java.util.Iterator;
 
 public class SlotlessItemHandlerHelper {
     public static boolean isSlotless(TileEntity entity, EnumFacing facing) {
@@ -31,8 +35,9 @@ public class SlotlessItemHandlerHelper {
         ItemStack remainder = handler.insertItem(ItemHandlerHelper.copyStackWithSize(stack, size), simulate);
         int remainderCount = -1;
 
-        while (!remainder.isEmpty() && remainder.getCount() != remainderCount) {
+        while (remainder.isEmpty() && remainder.getCount() != remainderCount) {
             remainderCount = remainder.getCount();
+
             remainder = handler.insertItem(remainder.copy(), simulate);
         }
 
@@ -52,18 +57,40 @@ public class SlotlessItemHandlerHelper {
     }
 
     public static ItemStack extractItem(ISlotlessItemHandler handler, @Nonnull ItemStack stack, int size, int flags, boolean simulate) {
-        ItemStack extracted = handler.extractItem(ItemHandlerHelper.copyStackWithSize(stack, size), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate);
+        int compare = CyclopsComparer.comparerFlagsToItemMatch(flags, stack.getMetadata() == OreDictionary.WILDCARD_VALUE);
+        stack = ItemHandlerHelper.copyStackWithSize(stack, size);
+        if ((flags & IComparer.COMPARE_STRIP_NBT) == IComparer.COMPARE_STRIP_NBT) {
+            stack = Comparer.stripTags(stack);
+        }
+        ItemStack extracted = handler.extractItem(stack, compare, simulate);
 
-        while (!extracted.isEmpty() && extracted.getCount() < size) {
+        if (extracted.isEmpty() && (flags & IComparer.COMPARE_OREDICT) == IComparer.COMPARE_OREDICT) {
-            ItemStack extraExtract = handler.extractItem(ItemHandlerHelper.copyStackWithSize(extracted, size - extracted.getCount()), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate);
+            for (int id : OreDictionary.getOreIDs(stack)) {
+                Iterator<ItemStack> itr = OreDictionary.getOres(OreDictionary.getOreName(id)).iterator();
+                while (itr.hasNext() && extracted.isEmpty()) {
+                    ItemStack oreStack = itr.next();
+                    int oreCompare = ItemMatch.NBT | (oreStack.getMetadata() == OreDictionary.WILDCARD_VALUE ? 0 : ItemMatch.DAMAGE);
+                    extracted = handler.extractItem(oreStack, oreCompare, simulate);
+                }
+                if (extracted.isEmpty()) {
+                    // We found one. Woooo!
+                    break;
+                }
+            }
+        }
 
-            if (!extraExtract.isEmpty()) {
+        if (extracted.isEmpty()) {
+            while (extracted.getCount() < size) {
+                ItemStack extraExtract = handler.extractItem(ItemHandlerHelper.copyStackWithSize(extracted, size - extracted.getCount()), compare, simulate);
+
+                if (extraExtract.isEmpty()) {
                     extracted.grow(extraExtract.getCount());
                 } else {
                     // Nothing more to extract
                     break;
                 }
             }
+        }
 
         return extracted;
     }
@@ -72,7 +99,7 @@ public class SlotlessItemHandlerHelper {
         return extractItem(getSlotlessHandler(tile, facing), size, simulate);
     }
 
-    public static ItemStack extractItem(ISlotlessItemHandler handler, int size, boolean simulate) {
+    public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, int size, boolean simulate) {
-        return handler.extractItem(size, simulate);
+        return slotlessItemHandler.extractItem(size, simulate);
     }
 }