dave/refinedstorage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Protect against null in cyclops storage

Browse Source
This commit is contained in:
raoulvdberge
2017-01-28 21:11:59 +01:00
parent 310f94fd36
commit 605e4f4ec6
2 changed files with 40 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -73,7 +73,7 @@ public class StorageItemCyclops extends StorageItemExternal {
public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) { public ItemStack insert(@Nonnull ItemStack stack, int size, boolean simulate) {
InventoryTileEntityBase inv = cyclopsInv.get(); InventoryTileEntityBase inv = cyclopsInv.get();
if (IFilterable.canTake(externalStorage.getItemFilters(), externalStorage.getMode(), externalStorage.getCompare(), stack)) { if (inv != null && IFilterable.canTake(externalStorage.getItemFilters(), externalStorage.getMode(), externalStorage.getCompare(), stack)) {
return SlotlessItemHandlerHelper.insertItem(inv, opposite, stack, size, simulate); return SlotlessItemHandlerHelper.insertItem(inv, opposite, stack, size, simulate);
} }
@@ -84,16 +84,24 @@ public class StorageItemCyclops extends StorageItemExternal {
@Override @Override
public ItemStack extract(@Nonnull ItemStack stack, int size, int flags, boolean simulate) { public ItemStack extract(@Nonnull ItemStack stack, int size, int flags, boolean simulate) {
InventoryTileEntityBase inv = cyclopsInv.get(); InventoryTileEntityBase inv = cyclopsInv.get();
return SlotlessItemHandlerHelper.extractItem(inv, opposite, stack, size, flags, simulate);
return inv != null ? SlotlessItemHandlerHelper.extractItem(inv, opposite, stack, size, flags, simulate) : null;
} }
private NonNullList<ItemStack> getStacks(@Nullable InventoryTileEntityBase inv) { private NonNullList<ItemStack> getStacks(@Nullable InventoryTileEntityBase inv) {
if (inv != null) { if (inv != null) {
if (inv.getInventory() instanceof IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) { if (inv.getInventory() instanceof IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) {
return ((IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) inv.getInventory()) return ((IndexedSlotlessItemHandlerWrapper.IInventoryIndexReference) inv.getInventory())
.getIndex().values().stream().flatMap(m -> m.valueCollection().stream()).map(ItemStack::copy).collect(RSUtils.toNonNullList()); .getIndex()
.values()
.stream()
.flatMap(m -> m.valueCollection().stream())
.map(ItemStack::copy)
.collect(RSUtils.toNonNullList());
} else { } else {
return Arrays.stream(((SimpleInventory) inv.getInventory()).getItemStacks()).map(ItemStack::copy).collect(RSUtils.toNonNullList()); return Arrays.stream(((SimpleInventory) inv.getInventory()).getItemStacks())
.map(ItemStack::copy)
.collect(RSUtils.toNonNullList());
} }
} else { } else {
return RSUtils.emptyNonNullList(); return RSUtils.emptyNonNullList();

52
src/main/java/com/raoulvdberge/refinedstorage/integration/cyclopscore/SlotlessItemHandlerHelper.java
View File

@@ -15,45 +15,48 @@ public class SlotlessItemHandlerHelper {
return entity != null && entity.hasCapability(SlotlessItemHandlerConfig.CAPABILITY, facing); return entity != null && entity.hasCapability(SlotlessItemHandlerConfig.CAPABILITY, facing);
} }
public static ISlotlessItemHandler getSlotlessHandler(TileEntity entity, EnumFacing facing) { public static ISlotlessItemHandler getSlotlessHandler(TileEntity tile, EnumFacing facing) {
return entity.getCapability(SlotlessItemHandlerConfig.CAPABILITY, facing); return tile.getCapability(SlotlessItemHandlerConfig.CAPABILITY, facing);
} }
public static ItemStack insertItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, boolean simulate) { public static ItemStack insertItem(TileEntity tile, EnumFacing facing, @Nonnull ItemStack stack, boolean simulate) {
return insertItem(getSlotlessHandler(entity, facing), stack, stack.getCount(), simulate); return insertItem(getSlotlessHandler(tile, facing), stack, stack.getCount(), simulate);
} }
public static ItemStack insertItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) { public static ItemStack insertItem(TileEntity tile, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) {
return insertItem(getSlotlessHandler(entity, facing), stack, size, simulate); return insertItem(getSlotlessHandler(tile, facing), stack, size, simulate);
} }
public static ItemStack insertItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, boolean simulate) { public static ItemStack insertItem(ISlotlessItemHandler handler, @Nonnull ItemStack stack, int size, boolean simulate) {
ItemStack remainder = slotlessItemHandler.insertItem(ItemHandlerHelper.copyStackWithSize(stack, size), simulate); ItemStack remainder = handler.insertItem(ItemHandlerHelper.copyStackWithSize(stack, size), simulate);
int remainderCount = -1; int remainderCount = -1;
while (!remainder.isEmpty() && remainder.getCount() != remainderCount)
{ while (!remainder.isEmpty() && remainder.getCount() != remainderCount) {
remainderCount = remainder.getCount(); remainderCount = remainder.getCount();
remainder = slotlessItemHandler.insertItem(remainder.copy(), simulate); remainder = handler.insertItem(remainder.copy(), simulate);
} }
return remainder; return remainder;
} }
public static ItemStack extractItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, int flags, boolean simulate) { public static ItemStack extractItem(TileEntity tile, EnumFacing facing, @Nonnull ItemStack stack, int size, int flags, boolean simulate) {
return extractItem(getSlotlessHandler(entity, facing), stack, size, flags, simulate); return extractItem(getSlotlessHandler(tile, facing), stack, size, flags, simulate);
} }
public static ItemStack extractItem(TileEntity entity, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) { public static ItemStack extractItem(TileEntity tile, EnumFacing facing, @Nonnull ItemStack stack, int size, boolean simulate) {
return extractItem(getSlotlessHandler(entity, facing), stack, size, simulate); return extractItem(getSlotlessHandler(tile, facing), stack, size, simulate);
} }
public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, boolean simulate) { public static ItemStack extractItem(ISlotlessItemHandler handler, @Nonnull ItemStack stack, int size, boolean simulate) {
return extractItem(slotlessItemHandler, stack, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, simulate); return extractItem(handler, stack, size, IComparer.COMPARE_DAMAGE | IComparer.COMPARE_NBT, simulate);
} }
public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, @Nonnull ItemStack stack, int size, int flags, boolean simulate) { public static ItemStack extractItem(ISlotlessItemHandler handler, @Nonnull ItemStack stack, int size, int flags, boolean simulate) {
ItemStack extracted = slotlessItemHandler.extractItem(ItemHandlerHelper.copyStackWithSize(stack, size), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate); ItemStack extracted = handler.extractItem(ItemHandlerHelper.copyStackWithSize(stack, size), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate);
while (!extracted.isEmpty() && extracted.getCount() < size) { while (!extracted.isEmpty() && extracted.getCount() < size) {
ItemStack extraExtract = slotlessItemHandler.extractItem(ItemHandlerHelper.copyStackWithSize(extracted, size - extracted.getCount()), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate); ItemStack extraExtract = handler.extractItem(ItemHandlerHelper.copyStackWithSize(extracted, size - extracted.getCount()), CyclopsComparer.comparerFlagsToItemMatch(flags), simulate);
if (!extraExtract.isEmpty()) { if (!extraExtract.isEmpty()) {
extracted.grow(extraExtract.getCount()); extracted.grow(extraExtract.getCount());
} else { } else {
@@ -61,14 +64,15 @@ public class SlotlessItemHandlerHelper {
break; break;
} }
} }
return extracted; return extracted;
} }
public static ItemStack extractItem(TileEntity entity, EnumFacing facing, int size, boolean simulate) { public static ItemStack extractItem(TileEntity tile, EnumFacing facing, int size, boolean simulate) {
return extractItem(getSlotlessHandler(entity, facing), size, simulate); return extractItem(getSlotlessHandler(tile, facing), size, simulate);
} }
public static ItemStack extractItem(ISlotlessItemHandler slotlessItemHandler, int size, boolean simulate) { public static ItemStack extractItem(ISlotlessItemHandler handler, int size, boolean simulate) {
return slotlessItemHandler.extractItem(size, simulate); return handler.extractItem(size, simulate);
} }
} }