forward port cyclops support

also fixes #873

build.gradle

@@ -28,7 +28,7 @@ sourceCompatibility = 1.8
 targetCompatibility = 1.8
 
 minecraft {
-    version = "1.11-13.19.1.2188"
+    version = "1.11.2-13.20.0.2226"
     runDir = "run"
     useDepAts = true
     mappings = "snapshot_20161206"
@@ -41,12 +41,18 @@ repositories {
     maven {
         url "http://maven.epoxide.xyz"
     }
+    maven {
+        name "Cyclops Repo"
+        url "https://dl.bintray.com/cyclopsmc/dev/"
+    }
 }
 
 dependencies {
-    deobfCompile "mezz.jei:jei_1.11:4.0.4.199:api"
+    deobfCompile "mezz.jei:jei_1.11.2:4.2.4.226:api"
-    runtime "mezz.jei:jei_1.11:4.0.4.199"
+    runtime "mezz.jei:jei_1.11.2:4.2.4.226"
     deobfCompile "net.darkhax.tesla:Tesla:1.11-1.3.0.51"
+    deobfCompile "org.cyclops.cyclopscore:CyclopsCore:1.11.2-0.9.1-476"
+    deobfCompile "org.cyclops.commoncapabilities:CommonCapabilities:1.11.2-1.3.0-81"
 }
 
 processResources {

src/main/java/com/raoulvdberge/refinedstorage/RSUtils.java

@@ -54,11 +54,12 @@ import javax.annotation.Nullable;
 import java.math.RoundingMode;
 import java.text.DecimalFormat;
 import java.text.DecimalFormatSymbols;
-import java.util.Collection;
+import java.util.*;
-import java.util.Collections;
+import java.util.function.BiConsumer;
-import java.util.List;
+import java.util.function.BinaryOperator;
-import java.util.Locale;
 import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
 
 public final class RSUtils {
     private static final NonNullList EMPTY_NON_NULL_LIST = new NonNullList<Object>(Collections.emptyList(), null) {
@@ -527,4 +528,42 @@ public final class RSUtils {
         vertexBuffer.pos(xCoord, yCoord + maskTop, zLevel).tex(uMin, vMin).endVertex();
         tessellator.draw();
     }
+
+    public static <T> Collector<T, ?, NonNullList<T>> toNonNullList() {
+        return new Collector<T, NonNullList<T>, NonNullList<T>>() {
+            @Override
+            public Supplier<NonNullList<T>> supplier() {
+                return NonNullList::create;
+            }
+
+            @Override
+            public BiConsumer<NonNullList<T>, T> accumulator() {
+                return (list, item) -> {
+                    if (item != null) {
+                        list.add(item);
+                    }
+                };
+            }
+
+            @Override
+            public BinaryOperator<NonNullList<T>> combiner() {
+                return (a, b) -> {
+                    NonNullList<T> list = NonNullList.create();
+                    a.forEach(list::add);
+                    b.forEach(list::add);
+                    return list;
+                };
+            }
+
+            @Override
+            public Function<NonNullList<T>, NonNullList<T>> finisher() {
+                return (list) -> list;
+            }
+
+            @Override
+            public Set<Characteristics> characteristics() {
+                return EnumSet.of(Characteristics.IDENTITY_FINISH);
+            }
+        };
+    }
 }

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeExporter.java

@@ -5,6 +5,8 @@ import com.raoulvdberge.refinedstorage.RSUtils;
 import com.raoulvdberge.refinedstorage.api.autocrafting.task.ICraftingTask;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.IntegrationCyclopsCore;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.SlotlessItemHandlerHelper;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
@@ -116,12 +118,19 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
                                 continue;
                             }
 
-                            ItemStack took = network.extractItem(slot, stackSize, compare, true);
+                            ItemStack took = network.extractItem(slot, Math.min(slot.getMaxStackSize(), stackSize), compare, true);
 
                             if (took == null) {
                                 if (upgrades.hasUpgrade(ItemUpgrade.TYPE_CRAFTING)) {
                                     network.getCraftingManager().schedule(slot, 1, compare);
                                 }
+                            } else {
+                                if (IntegrationCyclopsCore.isLoaded()
+                                        && SlotlessItemHandlerHelper.isSlotless(getFacingTile(), holder.getDirection().getOpposite())
+                                        && SlotlessItemHandlerHelper.insertItem(getFacingTile(), holder.getDirection().getOpposite(), took, true).isEmpty()) {
+                                    took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false);
+
+                                    SlotlessItemHandlerHelper.insertItem(getFacingTile(), holder.getDirection().getOpposite(), took, false);
                                 } else if (ItemHandlerHelper.insertItem(handler, took, true).isEmpty()) {
                                     took = network.extractItem(slot, upgrades.getItemInteractCount(), compare, false);
 
@@ -130,6 +139,7 @@ public class NetworkNodeExporter extends NetworkNode implements IComparable, ITy
                             }
                         }
                     }
+                }
             } else if (type == IType.FLUIDS) {
                 IFluidHandler handler = RSUtils.getFluidHandler(getFacingTile(), holder.getDirection().getOpposite());
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/NetworkNodeImporter.java

@@ -3,19 +3,16 @@ package com.raoulvdberge.refinedstorage.apiimpl.network.node;
 import com.raoulvdberge.refinedstorage.RS;
 import com.raoulvdberge.refinedstorage.RSUtils;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.ImportingBehaviorCyclops;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.IntegrationCyclopsCore;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.SlotlessItemHandlerHelper;
-import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.inventory.*;
 import com.raoulvdberge.refinedstorage.item.ItemUpgrade;
-import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
 import com.raoulvdberge.refinedstorage.tile.TileImporter;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
-import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.fluids.capability.IFluidHandler;
@@ -57,34 +54,11 @@ public class NetworkNodeImporter extends NetworkNode implements IComparable, IFi
         }
         
         if (type == IType.ITEMS) {
-            TileEntity tile = getFacingTile();
+            IImportingBehavior behavior = ImportingBehaviorItemHandler.INSTANCE;
-            IItemHandler handler = RSUtils.getItemHandler(tile, holder.getDirection().getOpposite());
+            if (IntegrationCyclopsCore.isLoaded() && SlotlessItemHandlerHelper.isSlotless(getFacingTile(), holder.getDirection().getOpposite())) {
-
+                behavior = ImportingBehaviorCyclops.INSTANCE;
-            if (handler == null || tile instanceof TileDiskDrive) {
-                return;
-            }
-
-            if (currentSlot >= handler.getSlots()) {
-                currentSlot = 0;
-            }
-
-            if (handler.getSlots() > 0) {
-                ItemStack stack = handler.getStackInSlot(currentSlot);
-
-                if (stack.isEmpty() || !IFilterable.canTake(itemFilters, mode, compare, stack)) {
-                    currentSlot++;
-                } else if (ticks % upgrades.getSpeed() == 0) {
-                    ItemStack result = handler.extractItem(currentSlot, upgrades.getItemInteractCount(), true);
-
-                    if (!result.isEmpty() && network.insertItem(result, result.getCount(), true) == null) {
-                        network.insertItemTracked(result, result.getCount());
-
-                        handler.extractItem(currentSlot, upgrades.getItemInteractCount(), false);
-                    } else {
-                        currentSlot++;
-                    }
-                }
             }
+            currentSlot = behavior.doImport(getFacingTile(), holder.getDirection().getOpposite(), currentSlot, itemFilters, mode, compare, ticks, upgrades, network);
         } else if (type == IType.FLUIDS && ticks % upgrades.getSpeed() == 0) {
             IFluidHandler handler = RSUtils.getFluidHandler(getFacingTile(), holder.getDirection().getOpposite());
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/NetworkNodeExternalStorage.java

@@ -11,6 +11,7 @@ import com.raoulvdberge.refinedstorage.api.storage.IStorage;
 import com.raoulvdberge.refinedstorage.api.storage.IStorageProvider;
 import com.raoulvdberge.refinedstorage.api.util.IComparer;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNode;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.IntegrationCyclopsCore;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerBasic;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerListenerNetworkNode;
@@ -196,6 +197,8 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
                 itemStorages.add(new StorageItemDrawer(this, () -> (IDrawer) getFacingTile()));
             } else if (facing instanceof IDeepStorageUnit) {
                 itemStorages.add(new StorageItemDSU(this, () -> (IDeepStorageUnit) getFacingTile()));
+            } else if (IntegrationCyclopsCore.isLoaded() && StorageItemCyclops.isValid(facing, holder.getDirection().getOpposite())) {
+                itemStorages.add(new StorageItemCyclops(this));
             } else if (!(facing instanceof TileNode)) {
                 IItemHandler itemHandler = RSUtils.getItemHandler(facing, holder.getDirection().getOpposite());
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/externalstorage/StorageItemCyclops.java

@@ -0,0 +1,104 @@
+package com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage;
+
+import com.raoulvdberge.refinedstorage.RSUtils;
+import com.raoulvdberge.refinedstorage.api.network.INetworkMaster;
+import com.raoulvdberge.refinedstorage.integration.cyclopscore.SlotlessItemHandlerHelper;
+import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.NonNullList;
+import net.minecraftforge.items.ItemHandlerHelper;
+import org.cyclops.cyclopscore.inventory.IndexedSlotlessItemHandlerWrapper;
+import org.cyclops.cyclopscore.inventory.SimpleInventory;
+import org.cyclops.cyclopscore.tileentity.InventoryTileEntityBase;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.*;
+import java.util.function.Supplier;
+
+public class StorageItemCyclops extends StorageItemExternal {
+    private NetworkNodeExternalStorage externalStorage;
+    private EnumFacing opposite;
+    private Supplier<InventoryTileEntityBase> cyclopsInv;
+    private int oldInventoryHash = -1;
+
+    public StorageItemCyclops(NetworkNodeExternalStorage externalStorage) {
+        this.externalStorage = externalStorage;
+        this.opposite = externalStorage.getHolder().getDirection().getOpposite();
+        this.cyclopsInv = () -> (InventoryTileEntityBase) externalStorage.getFacingTile();
+    }
+
+    @Override
+    public void detectChanges(INetworkMaster network) {
+        InventoryTileEntityBase inv = cyclopsInv.get();
+        if (inv != null) {
+            int inventoryHash = inv.getInventoryHash();
+            if (inventoryHash != oldInventoryHash) {
+                super.detectChanges(network);
+                oldInventoryHash = inventoryHash;
+            }
+        }
+    }
+
+    @Override
+    public NonNullList<ItemStack> getStacks() {
+        return getStacks(cyclopsInv.get());
+    }
+
+    @Override
+    public int getStored() {
+        return getStacks(cyclopsInv.get()).stream().mapToInt(s -> s.getCount()).sum();
+    }
+
+    @Override
+    public int getPriority() {
+        return this.externalStorage.getPriority();
+    }
+
+    @Override
+    public int getCapacity() {
+        InventoryTileEntityBase inv = cyclopsInv.get();
+
+        return inv != null ? inv.getInventory().getSizeInventory() * 64 : 0;
+    }
+
+    @Nullable
+    @Override
+    public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) {
+        InventoryTileEntityBase inv = cyclopsInv.get();
+
+        if (IFilterable.canTake(externalStorage.getItemFilters(), externalStorage.getMode(), externalStorage.getCompare(), stack)) {
+            return SlotlessItemHandlerHelper.insertItem(inv, opposite, stack, size, simulate);
+        }
+
+        return ItemHandlerHelper.copyStackWithSize(stack, size);
+    }
+
+    @Nullable
+    @Override
+    public ItemStack extract(@Nonnull ItemStack stack, int size, int flags, boolean simulate) {
+        InventoryTileEntityBase inv = cyclopsInv.get();
+        return SlotlessItemHandlerHelper.extractItem(inv, opposite, stack, size, flags, simulate);
+    }
+
+    private NonNullList<ItemStack> getStacks(@Nullable InventoryTileEntityBase inv) {
+        if (inv != null) {
+            if (inv.getInventory() instanceof IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) {
+                return ((IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) inv.getInventory())
+                        .getIndex().values().stream().flatMap(m -> m.valueCollection().stream()).map(ItemStack::copy).collect(RSUtils.toNonNullList());
+            } else {
+                return Arrays.stream(((SimpleInventory)inv.getInventory()).getItemStacks()).map(ItemStack::copy).collect(RSUtils.toNonNullList());
+            }
+        } else {
+            return RSUtils.emptyNonNullList();
+        }
+    }
+
+    public static boolean isValid(TileEntity facingTE, EnumFacing facing) {
+        return facingTE instanceof InventoryTileEntityBase
+                && (SlotlessItemHandlerHelper.isSlotless(facingTE, facing)
+                    || ((InventoryTileEntityBase) facingTE).getInventory() instanceof SimpleInventory);
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java

@@ -159,7 +159,7 @@ public class BlockCable extends BlockNode {
 
     @Override
     @SuppressWarnings("deprecation")
-    public void addCollisionBoxToList(IBlockState state, World world, BlockPos pos, AxisAlignedBB entityBox, List<AxisAlignedBB> collidingBoxes, Entity entityIn) {
+    public void addCollisionBoxToList(IBlockState state, World world, BlockPos pos, AxisAlignedBB entityBox, List<AxisAlignedBB> collidingBoxes, Entity entityIn, boolean p_185477_7_) {
         for (AxisAlignedBB aabb : getCollisionBoxes(this.getActualState(state, world, pos))) {
             addCollisionBoxToList(pos, entityBox, collidingBoxes, aabb);
         }

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

@@ -0,0 +1,34 @@
+package com.raoulvdberge.refinedstorage.integration.cyclopscore;
+
+import com.raoulvdberge.refinedstorage.api.util.IComparer;
+import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
+
+public class CyclopsComparer {
+    public static int comparerFlagsToItemMatch(int flags) {
+        int itemMatch = 0;
+        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/ImportingBehaviorCyclops.java

@@ -0,0 +1,32 @@
+package com.raoulvdberge.refinedstorage.integration.cyclopscore;
+
+import com.raoulvdberge.refinedstorage.api.network.INetworkMaster;
+import com.raoulvdberge.refinedstorage.inventory.IImportingBehavior;
+import com.raoulvdberge.refinedstorage.inventory.ImportingBehaviorItemHandler;
+import com.raoulvdberge.refinedstorage.inventory.ItemHandlerUpgrade;
+import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.items.IItemHandler;
+
+public class ImportingBehaviorCyclops implements IImportingBehavior {
+
+    public static final IImportingBehavior INSTANCE = new ImportingBehaviorCyclops();
+
+    @Override
+    public int doImport(TileEntity entity, EnumFacing facing, int currentSlot, IItemHandler itemFilters, int mode, int compare, int ticks, ItemHandlerUpgrade upgrades, INetworkMaster network) {
+        if (IFilterable.isEmpty(itemFilters)) {
+            if (ticks % upgrades.getSpeed() == 0) {
+                ItemStack result = SlotlessItemHandlerHelper.extractItem(entity, facing, upgrades.getItemInteractCount(), true);
+                if (result != null && !result.isEmpty() && network.insertItem(result, result.getCount(), true) == null) {
+                    network.insertItem(result, result.getCount(), false);
+                    SlotlessItemHandlerHelper.extractItem(entity, facing, result.copy(), upgrades.getItemInteractCount(), false);
+                }
+            }
+        } else {
+            return ImportingBehaviorItemHandler.INSTANCE.doImport(entity, facing, currentSlot, itemFilters, mode, compare, ticks, upgrades, network);
+        }
+        return 0;
+    }
+}

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

@@ -0,0 +1,9 @@
+package com.raoulvdberge.refinedstorage.integration.cyclopscore;
+
+import net.minecraftforge.fml.common.Loader;
+
+public final class IntegrationCyclopsCore {
+    public static boolean isLoaded() {
+        return Loader.isModLoaded("cyclopscore");
+    }
+}

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

@@ -0,0 +1,74 @@
+package com.raoulvdberge.refinedstorage.integration.cyclopscore;
+
+import com.raoulvdberge.refinedstorage.api.util.IComparer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.items.ItemHandlerHelper;
+import org.cyclops.commoncapabilities.api.capability.itemhandler.ISlotlessItemHandler;
+import org.cyclops.commoncapabilities.capability.itemhandler.SlotlessItemHandlerConfig;
+
+import javax.annotation.Nonnull;
+
+public class SlotlessItemHandlerHelper {
+    public static boolean isSlotless(TileEntity entity, EnumFacing facing) {
+        return entity != null && entity.hasCapability(SlotlessItemHandlerConfig.CAPABILITY, facing);
+    }
+
+    public static ISlotlessItemHandler getSlotlessHandler(TileEntity entity, EnumFacing facing) {
+        return entity.getCapability(SlotlessItemHandlerConfig.CAPABILITY, facing);
+    }
+
+    public static ItemStack insertItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, boolean simulate) {
+        return insertItem(getSlotlessHandler(entity, facing), stack, stack.getCount(), simulate);
+    }
+
+    public static ItemStack insertItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) {
+        return insertItem(getSlotlessHandler(entity, facing), stack, size, simulate);
+    }
+
+    public static ItemStack insertItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, boolean simulate) {
+        ItemStack remainder = slotlessItemHandler.insertItem(ItemHandlerHelper.copyStackWithSize(stack, size), simulate);
+        int remainderCount = -1;
+        while (!remainder.isEmpty() && remainder.getCount() != remainderCount)
+        {
+            remainderCount = remainder.getCount();
+            remainder = slotlessItemHandler.insertItem(remainder.copy(), simulate);
+        }
+        return remainder;
+    }
+
+    public static ItemStack extractItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, int flags, boolean simulate) {
+        return extractItem(getSlotlessHandler(entity, facing), stack, size, flags, simulate);
+    }
+
+    public static ItemStack extractItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) {
+        return extractItem(getSlotlessHandler(entity, facing), stack, size, simulate);
+    }
+
+    public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, boolean simulate) {
+        return extractItem(slotlessItemHandler, stack, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, simulate);
+    }
+
+    public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, int flags, boolean simulate) {
+        ItemStack extracted = slotlessItemHandler.extractItem(ItemHandlerHelper.copyStackWithSize(stack, size), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate);
+        while (!extracted.isEmpty() && extracted.getCount() < size) {
+            ItemStack extraExtract = slotlessItemHandler.extractItem(ItemHandlerHelper.copyStackWithSize(extracted, size - extracted.getCount()), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate);
+            if (!extraExtract.isEmpty()) {
+                extracted.grow(extraExtract.getCount());
+            } else {
+                // Nothing more to extract
+                break;
+            }
+        }
+        return extracted;
+    }
+
+    public static ItemStack extractItem(TileEntity entity, EnumFacing facing, int size, boolean simulate) {
+        return extractItem(getSlotlessHandler(entity, facing), size, simulate);
+    }
+
+    public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, int size, boolean simulate) {
+        return slotlessItemHandler.extractItem(size, simulate);
+    }
+}

src/main/java/com/raoulvdberge/refinedstorage/inventory/IImportingBehavior.java

@@ -0,0 +1,10 @@
+package com.raoulvdberge.refinedstorage.inventory;
+
+import com.raoulvdberge.refinedstorage.api.network.INetworkMaster;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.items.IItemHandler;
+
+public interface IImportingBehavior {
+    int doImport(TileEntity entity, EnumFacing facing, int currentSlot, IItemHandler itemFilters, int mode, int compare, int ticks, ItemHandlerUpgrade upgrades, INetworkMaster network);
+}

src/main/java/com/raoulvdberge/refinedstorage/inventory/ImportingBehaviorItemHandler.java

@@ -0,0 +1,48 @@
+package com.raoulvdberge.refinedstorage.inventory;
+
+import com.raoulvdberge.refinedstorage.RSUtils;
+import com.raoulvdberge.refinedstorage.api.network.INetworkMaster;
+import com.raoulvdberge.refinedstorage.tile.TileDiskDrive;
+import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.items.IItemHandler;
+
+public class ImportingBehaviorItemHandler implements IImportingBehavior {
+
+    public static final IImportingBehavior INSTANCE = new ImportingBehaviorItemHandler();
+
+    @Override
+    public int doImport(TileEntity entity, EnumFacing facing, int currentSlot, IItemHandler itemFilters, int mode, int compare, int ticks, ItemHandlerUpgrade upgrades, INetworkMaster network) {
+        IItemHandler handler = RSUtils.getItemHandler(entity, facing);
+
+        if (entity instanceof TileDiskDrive || handler == null) {
+            return currentSlot;
+        }
+
+        if (currentSlot >= handler.getSlots()) {
+            currentSlot = 0;
+        }
+
+        if (handler.getSlots() > 0) {
+            ItemStack stack = handler.getStackInSlot(currentSlot);
+
+            if (stack == null || stack.isEmpty() || !IFilterable.canTake(itemFilters, mode, compare, stack)) {
+                currentSlot++;
+            } else if (ticks % upgrades.getSpeed() == 0) {
+                ItemStack result = handler.extractItem(currentSlot, upgrades.getItemInteractCount(), true);
+
+                if (result != null && !stack.isEmpty() && network.insertItem(result, result.getCount(), true) == null) {
+                    network.insertItem(result, result.getCount(), false);
+
+                    handler.extractItem(currentSlot, upgrades.getItemInteractCount(), false);
+                } else {
+                    currentSlot++;
+                }
+            }
+        }
+
+        return currentSlot;
+    }
+}