import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
@Override
protected void onContentsChanged(int slot) {
    if (te.getWorld().isRemote || slot != CHARGE_INVENTORY_INDEX) return;

    if (te.chargeableInventory != null) {
        te.chargeableInventory.saveInventory();
        te.setChargeableInventory(null);
    }

    ItemStack stack = getStackInSlot(slot);
    if (stack.getItem() instanceof IChargingStationGUIHolderItem) {
        te.chargeableInventory = new ChargeableItemHandler(te);
        te.invWrapper = new CombinedInvWrapper(te.inventory, te.chargeableInventory);
    }
    List<EntityPlayer> players = te.getWorld().playerEntities;
    for(EntityPlayer player : players) {
        if (player.openContainer instanceof ContainerChargingStationItemInventory && ((ContainerChargingStationItemInventory) player.openContainer).te == te) {
            if (stack.getItem() instanceof IChargingStationGUIHolderItem) {
                // player.openGui(PneumaticCraft.instance, CommonProxy.GUI_ID_PNEUMATIC_ARMOR, getWorld(), getPos().getX(), getPos().getY(), getPos().getZ());
            } else {
                player.openGui(PneumaticCraftRepressurized.instance, EnumGuiId.CHARGING_STATION.ordinal(), te.getWorld(), te.getPos().getX(), te.getPos().getY(), te.getPos().getZ());
            }
        }
    }
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
@Nullable
private IItemHandlerModifiable getItemHandlerCapability(@Nullable EnumFacing facing)
{
    Capability<IItemHandler> capability = CapabilityItemHandler.ITEM_HANDLER_CAPABILITY;

    List<IItemHandlerModifiable> handlers = Lists.newLinkedList();

    for (TileEntityModule module : modules.values())
    {
        if (module.hasCapability(capability, facing))
            handlers.add((IItemHandlerModifiable) module.getCapability(capability, facing));
    }

    if (handlers.size() == 1)
        return handlers.get(0);
    else if (handlers.size() > 1)
        return new CombinedInvWrapper(handlers.toArray(new IItemHandlerModifiable[handlers.size()]));
    else
        return null;
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
private Optional<IItemHandler> handlerForSide(EnumFacing facing)
{
    List<IItemHandlerModifiable> handlers = Lists.newArrayList();
    if (ArrayUtils.contains(supplier.sidesInput, facing))
        handlers.add(invHandler.getInputHandler());
    if (ArrayUtils.contains(supplier.sidesOutput, facing))
        handlers.add(invHandler.getOutputHandler());
    if (ArrayUtils.contains(supplier.sidesFuel, facing))
        handlers.add(invHandler.getFuelHandler());

    return Optional.ofNullable(handlers.isEmpty() ? null : new CombinedInvWrapper(handlers.toArray(new IItemHandlerModifiable[handlers.size()])));
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
public ItemHandlerFurnace(TileEntityIronFurnace tile)
{
    super(tile.getType().getNumSlots());

    this.tile = tile;
    type = tile.getType();

    fuelHandler = type.fuelSlots > 0
                  ? new ItemHandlerMoveStacks(this,
                                              type.getFirstFuelSlot(),
                                              type.getLastFuelSlot(),
                                              0)
                  : new EmptyHandler();
    inputHandlers = new ItemHandlerMoveStacks[type.parallelSmelting];
    outputHandlers = new ItemHandlerMoveStacks[type.parallelSmelting];

    for (int i = 0; i < type.parallelSmelting; i++)
    {
        inputHandlers[i] = new ItemHandlerMoveStacks(this,
                                                     type.getFirstInputSlot(i),
                                                     type.getLastInputSlot(i),
                                                     0);

        int firstOutput = type.getFirstOutputSlot(i);
        int lastOutput = type.getLastOutputSlot(i);
        outputHandlers[i] = new ItemHandlerMoveStacks(this,
                                                      firstOutput, lastOutput,
                                                      range(1, lastOutput - firstOutput + 1));
    }

    bottomSideHandler = createBottomSideHandler();
    topSideHandler = new CombinedInvWrapper(inputHandlers);
    sidesSideHandler = fuelHandler;
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
private CombinedInvWrapper createBottomSideHandler()
{
    IItemHandlerModifiable[] handlers = new IItemHandlerModifiable[outputHandlers.length + 1];
    System.arraycopy(outputHandlers, 0, handlers, 0, outputHandlers.length);
    handlers[handlers.length - 1] = fuelHandler;

    return new CombinedInvWrapper(handlers);
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
public GenericContainer addPlayerSlots(final InventoryPlayer playerInv, final Set<Integer> lockedSlots) {
	playerSlotsStart = inventorySlots.size();
	CombinedInvWrapper playerItemHandler =
			new CombinedInvWrapper(new PlayerMainInvWrapper(playerInv), new PlayerOffhandInvWrapper(playerInv));
	addSlots(playerItemHandler, 9, 8, 84, 9, 3);
	addSlots(8, 142, 9, 1, (slot, x, y) -> {
		if (lockedSlots.contains(slot))
			return new SlotLocked(playerItemHandler, slot, x, y);
		else
			return new SlotItemHandlerBase(playerItemHandler, slot, x, y);
	});
	return this;
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
/**
 * Adds one more of each item in the recipe into the crafting grid, if possible
 * @param invId
 * @param recipeId
 */
protected boolean addOneSetOfRecipeItemsIntoGrid(IItemHandler invCrafting, int invId, int recipeId, EntityPlayer player)
{
    invId = MathHelper.clamp(invId, 0, 1);
    int maskOreDict = invId == 1 ? MODE_BIT_RIGHT_CRAFTING_OREDICT : MODE_BIT_LEFT_CRAFTING_OREDICT;
    boolean useOreDict = (this.modeMask & maskOreDict) != 0;

    IItemHandlerModifiable playerInv = (IItemHandlerModifiable) player.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP);
    IItemHandler invWrapper = new CombinedInvWrapper(this.itemInventory, playerInv);

    NonNullList<ItemStack> template = this.getRecipeItems(invId);
    InventoryUtils.clearInventoryToMatchTemplate(invCrafting, invWrapper, template);

    return InventoryUtils.restockInventoryBasedOnTemplate(invCrafting, invWrapper, template, 1, true, useOreDict);
}
 

import net.minecraftforge.items.wrapper.CombinedInvWrapper; //导入依赖的package包/类
protected void fillCraftingGrid(IItemHandler invCrafting, int invId, int recipeId, EntityPlayer player)
{
    invId = MathHelper.clamp(invId, 0, 1);
    int largestStack = InventoryUtils.getLargestExistingStackSize(invCrafting);

    // If all stacks only have one item, then try to fill them all the way to maxStackSize
    if (largestStack == 1)
    {
        largestStack = 64;
    }

    NonNullList<ItemStack> template = InventoryUtils.createInventorySnapshot(invCrafting);
    int maskOreDict = invId == 1 ? MODE_BIT_RIGHT_CRAFTING_OREDICT : MODE_BIT_LEFT_CRAFTING_OREDICT;
    boolean useOreDict = (this.modeMask & maskOreDict) != 0;

    Map<ItemType, Integer> slotCounts = InventoryUtils.getSlotCountPerItem(invCrafting);

    // Clear old contents and then fill all the slots back up
    if (InventoryUtils.tryMoveAllItems(invCrafting, this.itemInventory) == InvResult.MOVED_ALL)
    {
        IItemHandlerModifiable playerInv = (IItemHandlerModifiable) player.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP);
        IItemHandler invWrapper = new CombinedInvWrapper(this.itemInventory, playerInv);

        // Next we find out how many items we have available for each item type on the crafting grid
        // and we cap the max stack size to that value, so the stacks will be balanced
        Iterator<Entry<ItemType, Integer>> iter = slotCounts.entrySet().iterator();

        while (iter.hasNext())
        {
            Entry<ItemType, Integer> entry = iter.next();
            ItemType item = entry.getKey();

            if (item.getStack().getMaxStackSize() == 1)
            {
                continue;
            }

            int numFound = InventoryUtils.getNumberOfMatchingItemsInInventory(invWrapper, item.getStack(), useOreDict);
            int numSlots = entry.getValue();
            int maxSize = numFound / numSlots;

            if (maxSize < largestStack)
            {
                largestStack = maxSize;
            }
        }

        InventoryUtils.restockInventoryBasedOnTemplate(invCrafting, invWrapper, template, largestStack, false, useOreDict);
    }
}