Cleanup of the tile data syncing system

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

@@ -10,9 +10,9 @@ public interface IGuiReaderWriter {
 
     void setChannel(String channel);
 
-    TileDataParameter<String> getChannelParameter();
+    TileDataParameter<String, ?> getChannelParameter();
 
-    TileDataParameter<Integer> getRedstoneModeParameter();
+    TileDataParameter<Integer, ?> getRedstoneModeParameter();
 
     INetwork getNetwork();
 

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

@@ -6,19 +6,19 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 public interface IGuiStorage {
     String getGuiTitle();
 
-    TileDataParameter<Integer> getTypeParameter();
+    TileDataParameter<Integer, ?> getTypeParameter();
 
-    TileDataParameter<Integer> getRedstoneModeParameter();
+    TileDataParameter<Integer, ?> getRedstoneModeParameter();
 
-    TileDataParameter<Integer> getCompareParameter();
+    TileDataParameter<Integer, ?> getCompareParameter();
 
-    TileDataParameter<Integer> getFilterParameter();
+    TileDataParameter<Integer, ?> getFilterParameter();
 
-    TileDataParameter<Integer> getPriorityParameter();
+    TileDataParameter<Integer, ?> getPriorityParameter();
 
-    TileDataParameter<AccessType> getAccessTypeParameter();
+    TileDataParameter<AccessType, ?> getAccessTypeParameter();
 
-    TileDataParameter<Boolean> getVoidExcessParameter();
+    TileDataParameter<Boolean, ?> getVoidExcessParameter();
 
     String getVoidExcessType();
 

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

@@ -70,7 +70,7 @@ public class NetworkNodeCraftingMonitor extends NetworkNode implements ICrafting
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileCraftingMonitor.REDSTONE_MODE;
     }
 

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

@@ -243,37 +243,37 @@ public class NetworkNodeFluidStorage extends NetworkNode implements IGuiStorage,
     }
 
     @Override
-    public TileDataParameter<Integer> getTypeParameter() {
+    public TileDataParameter<Integer, ?> getTypeParameter() {
         return null;
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileFluidStorage.REDSTONE_MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getCompareParameter() {
+    public TileDataParameter<Integer, ?> getCompareParameter() {
         return TileFluidStorage.COMPARE;
     }
 
     @Override
-    public TileDataParameter<Integer> getFilterParameter() {
+    public TileDataParameter<Integer, ?> getFilterParameter() {
         return TileFluidStorage.MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getPriorityParameter() {
+    public TileDataParameter<Integer, ?> getPriorityParameter() {
         return TileFluidStorage.PRIORITY;
     }
 
     @Override
-    public TileDataParameter<Boolean> getVoidExcessParameter() {
+    public TileDataParameter<Boolean, ?> getVoidExcessParameter() {
         return TileFluidStorage.VOID_EXCESS;
     }
 
     @Override
-    public TileDataParameter<AccessType> getAccessTypeParameter() {
+    public TileDataParameter<AccessType, ?> getAccessTypeParameter() {
         return TileFluidStorage.ACCESS_TYPE;
     }
 

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

@@ -532,7 +532,7 @@ public class NetworkNodeGrid extends NetworkNode implements IGrid {
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeConfig() {
+    public TileDataParameter<Integer, ?> getRedstoneModeConfig() {
         return TileGrid.REDSTONE_MODE;
     }
 

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

@@ -47,12 +47,12 @@ public class NetworkNodeReader extends NetworkNode implements IReader, IGuiReade
     }
 
     @Override
-    public TileDataParameter<String> getChannelParameter() {
+    public TileDataParameter<String, ?> getChannelParameter() {
         return TileReader.CHANNEL;
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileReader.REDSTONE_MODE;
     }
 

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

@@ -250,37 +250,37 @@ public class NetworkNodeStorage extends NetworkNode implements IGuiStorage, ISto
     }
 
     @Override
-    public TileDataParameter<Integer> getTypeParameter() {
+    public TileDataParameter<Integer, ?> getTypeParameter() {
         return null;
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileStorage.REDSTONE_MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getCompareParameter() {
+    public TileDataParameter<Integer, ?> getCompareParameter() {
         return TileStorage.COMPARE;
     }
 
     @Override
-    public TileDataParameter<Integer> getFilterParameter() {
+    public TileDataParameter<Integer, ?> getFilterParameter() {
         return TileStorage.MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getPriorityParameter() {
+    public TileDataParameter<Integer, ?> getPriorityParameter() {
         return TileStorage.PRIORITY;
     }
 
     @Override
-    public TileDataParameter<Boolean> getVoidExcessParameter() {
+    public TileDataParameter<Boolean, ?> getVoidExcessParameter() {
         return TileStorage.VOID_EXCESS;
     }
 
     @Override
-    public TileDataParameter<AccessType> getAccessTypeParameter() {
+    public TileDataParameter<AccessType, ?> getAccessTypeParameter() {
         return TileStorage.ACCESS_TYPE;
     }
 

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

@@ -79,12 +79,12 @@ public class NetworkNodeWriter extends NetworkNode implements IWriter, IGuiReade
     }
 
     @Override
-    public TileDataParameter<String> getChannelParameter() {
+    public TileDataParameter<String, ?> getChannelParameter() {
         return TileWriter.CHANNEL;
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileWriter.REDSTONE_MODE;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/diskdrive/NetworkNodeDiskDrive.java

@@ -263,37 +263,37 @@ public class NetworkNodeDiskDrive extends NetworkNode implements IGuiStorage, IS
     }
 
     @Override
-    public TileDataParameter<Integer> getTypeParameter() {
+    public TileDataParameter<Integer, ?> getTypeParameter() {
         return TileDiskDrive.TYPE;
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileDiskDrive.REDSTONE_MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getCompareParameter() {
+    public TileDataParameter<Integer, ?> getCompareParameter() {
         return TileDiskDrive.COMPARE;
     }
 
     @Override
-    public TileDataParameter<Integer> getFilterParameter() {
+    public TileDataParameter<Integer, ?> getFilterParameter() {
         return TileDiskDrive.MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getPriorityParameter() {
+    public TileDataParameter<Integer, ?> getPriorityParameter() {
         return TileDiskDrive.PRIORITY;
     }
 
     @Override
-    public TileDataParameter<Boolean> getVoidExcessParameter() {
+    public TileDataParameter<Boolean, ?> getVoidExcessParameter() {
         return TileDiskDrive.VOID_EXCESS;
     }
 
     @Override
-    public TileDataParameter<AccessType> getAccessTypeParameter() {
+    public TileDataParameter<AccessType, ?> getAccessTypeParameter() {
         return TileDiskDrive.ACCESS_TYPE;
     }
 

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

@@ -239,32 +239,32 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return TileExternalStorage.REDSTONE_MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getCompareParameter() {
+    public TileDataParameter<Integer, ?> getCompareParameter() {
         return TileExternalStorage.COMPARE;
     }
 
     @Override
-    public TileDataParameter<Integer> getFilterParameter() {
+    public TileDataParameter<Integer, ?> getFilterParameter() {
         return TileExternalStorage.MODE;
     }
 
     @Override
-    public TileDataParameter<Integer> getPriorityParameter() {
+    public TileDataParameter<Integer, ?> getPriorityParameter() {
         return TileExternalStorage.PRIORITY;
     }
 
     @Override
-    public TileDataParameter<Boolean> getVoidExcessParameter() {
+    public TileDataParameter<Boolean, ?> getVoidExcessParameter() {
         return null;
     }
 
     @Override
-    public TileDataParameter<AccessType> getAccessTypeParameter() {
+    public TileDataParameter<AccessType, ?> getAccessTypeParameter() {
         return TileExternalStorage.ACCESS_TYPE;
     }
 
@@ -301,7 +301,7 @@ public class NetworkNodeExternalStorage extends NetworkNode implements IStorageP
     }
 
     @Override
-    public TileDataParameter<Integer> getTypeParameter() {
+    public TileDataParameter<Integer, ?> getTypeParameter() {
         return TileExternalStorage.TYPE;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/gui/GuiPriority.java

@@ -9,9 +9,9 @@ import net.minecraft.inventory.Container;
 import net.minecraft.util.Tuple;
 
 public class GuiPriority extends GuiCraftingStart {
-    private TileDataParameter<Integer> priority;
+    private TileDataParameter<Integer, ?> priority;
 
-    public GuiPriority(GuiBase parent, TileDataParameter<Integer> priority) {
+    public GuiPriority(GuiBase parent, TileDataParameter<Integer, ?> priority) {
         super(parent, null, new Container() {
             @Override
             public boolean canInteractWith(EntityPlayer player) {

src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonAccessType.java

@@ -8,9 +8,9 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.text.TextFormatting;
 
 public class SideButtonAccessType extends SideButton {
-    private TileDataParameter<AccessType> parameter;
+    private TileDataParameter<AccessType, ?> parameter;
 
-    public SideButtonAccessType(GuiBase gui, TileDataParameter<AccessType> parameter) {
+    public SideButtonAccessType(GuiBase gui, TileDataParameter<AccessType, ?> parameter) {
         super(gui);
 
         this.parameter = parameter;

src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonCompare.java

@@ -7,10 +7,10 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.text.TextFormatting;
 
 public class SideButtonCompare extends SideButton {
-    private TileDataParameter<Integer> parameter;
+    private TileDataParameter<Integer, ?> parameter;
     private int mask;
 
-    public SideButtonCompare(GuiBase gui, TileDataParameter<Integer> parameter, int mask) {
+    public SideButtonCompare(GuiBase gui, TileDataParameter<Integer, ?> parameter, int mask) {
         super(gui);
 
         this.parameter = parameter;

src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonMode.java

@@ -7,9 +7,9 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.text.TextFormatting;
 
 public class SideButtonMode extends SideButton {
-    private TileDataParameter<Integer> parameter;
+    private TileDataParameter<Integer, ?> parameter;
 
-    public SideButtonMode(GuiBase gui, TileDataParameter<Integer> parameter) {
+    public SideButtonMode(GuiBase gui, TileDataParameter<Integer, ?> parameter) {
         super(gui);
 
         this.parameter = parameter;

src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonRedstoneMode.java

@@ -6,9 +6,9 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.text.TextFormatting;
 
 public class SideButtonRedstoneMode extends SideButton {
-    private TileDataParameter<Integer> parameter;
+    private TileDataParameter<Integer, ?> parameter;
 
-    public SideButtonRedstoneMode(GuiBase gui, TileDataParameter<Integer> parameter) {
+    public SideButtonRedstoneMode(GuiBase gui, TileDataParameter<Integer, ?> parameter) {
         super(gui);
 
         this.parameter = parameter;

src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonType.java

@@ -7,9 +7,9 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.text.TextFormatting;
 
 public class SideButtonType extends SideButton {
-    private TileDataParameter<Integer> type;
+    private TileDataParameter<Integer, ?> type;
 
-    public SideButtonType(GuiBase gui, TileDataParameter<Integer> type) {
+    public SideButtonType(GuiBase gui, TileDataParameter<Integer, ?> type) {
         super(gui);
 
         this.type = type;

src/main/java/com/raoulvdberge/refinedstorage/gui/sidebutton/SideButtonVoidExcess.java

@@ -6,10 +6,10 @@ import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.text.TextFormatting;
 
 public class SideButtonVoidExcess extends SideButton {
-    private TileDataParameter<Boolean> parameter;
+    private TileDataParameter<Boolean, ?> parameter;
     private String type;
 
-    public SideButtonVoidExcess(GuiBase gui, TileDataParameter<Boolean> parameter, String type) {
+    public SideButtonVoidExcess(GuiBase gui, TileDataParameter<Boolean, ?> parameter, String type) {
         super(gui);
 
         this.parameter = parameter;

src/main/java/com/raoulvdberge/refinedstorage/item/ItemPattern.java

@@ -28,10 +28,6 @@ import javax.annotation.Nullable;
 import java.util.*;
 
 public class ItemPattern extends ItemBase implements ICraftingPatternProvider {
-    /**
-     * A cache that maps a stack to a crafting pattern.
-     * Only used client side for rendering and tooltips, to avoid crafting pattern allocations and crafting pattern output calculation (which is expensive).
-     */
     private static Map<ItemStack, CraftingPattern> PATTERN_CACHE = new HashMap<>();
 
     private static final String NBT_SLOT = "Slot_%d";
@@ -82,6 +78,7 @@ public class ItemPattern extends ItemBase implements ICraftingPatternProvider {
         } else {
             tooltip.add(TextFormatting.RED + I18n.format("misc.refinedstorage:pattern.invalid") + TextFormatting.RESET);
 
+            // @todo: Removal in a future version
             // Display a helpful message stating the outputs if this is a legacy pattern
             if (stack.hasTagCompound() && stack.getTagCompound().hasKey("Inputs") && stack.getTagCompound().hasKey("Outputs")) {
                 tooltip.add(TextFormatting.WHITE + "This pattern is a legacy pattern made before RS 1.0, please re-make!" + TextFormatting.RESET);

src/main/java/com/raoulvdberge/refinedstorage/network/MessageTileDataParameter.java

@@ -40,7 +40,7 @@ public class MessageTileDataParameter implements IMessage, IMessageHandler<Messa
     public void toBytes(ByteBuf buf) {
         buf.writeInt(parameter.getId());
 
-        parameter.getSerializer().write((PacketBuffer) buf, parameter.getValueProducer().getValue(tile));
+        parameter.getSerializer().write((PacketBuffer) buf, parameter.getValueProducer().apply(tile));
     }
 
     @Override

src/main/java/com/raoulvdberge/refinedstorage/network/MessageTileDataParameterUpdate.java

@@ -1,7 +1,6 @@
 package com.raoulvdberge.refinedstorage.network;
 
 import com.raoulvdberge.refinedstorage.container.ContainerBase;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataManager;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import io.netty.buffer.ByteBuf;
@@ -10,6 +9,8 @@ import net.minecraft.inventory.Container;
 import net.minecraft.network.PacketBuffer;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 
+import java.util.function.BiConsumer;
+
 public class MessageTileDataParameterUpdate extends MessageHandlerPlayerToServer<MessageTileDataParameterUpdate> implements IMessage {
     private TileDataParameter parameter;
     private Object value;
@@ -49,10 +50,10 @@ public class MessageTileDataParameterUpdate extends MessageHandlerPlayerToServer
         Container c = player.openContainer;
 
         if (c instanceof ContainerBase) {
-            ITileDataConsumer consumer = message.parameter.getValueConsumer();
+            BiConsumer consumer = message.parameter.getValueConsumer();
 
             if (consumer != null) {
-                consumer.setValue(((ContainerBase) c).getTile(), message.value);
+                consumer.accept(((ContainerBase) c).getTile(), message.value);
             }
         }
     }

src/main/java/com/raoulvdberge/refinedstorage/tile/TileConstructor.java

@@ -3,8 +3,6 @@ package com.raoulvdberge.refinedstorage.tile;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeConstructor;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -13,19 +11,11 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileConstructor extends TileNode<NetworkNodeConstructor> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-    public static final TileDataParameter<Boolean> DROP = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileConstructor>() {
-        @Override
-        public Boolean getValue(TileConstructor tile) {
-            return tile.getNode().isDrop();
-        }
-    }, new ITileDataConsumer<Boolean, TileConstructor>() {
-        @Override
-        public void setValue(TileConstructor tile, Boolean value) {
-            tile.getNode().setDrop(value);
-            tile.getNode().markDirty();
-        }
+    public static final TileDataParameter<Integer, TileConstructor> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileConstructor> TYPE = IType.createParameter();
+    public static final TileDataParameter<Boolean, TileConstructor> DROP = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isDrop(), (t, v) -> {
+        t.getNode().setDrop(v);
+        t.getNode().markDirty();
     });
 
     public TileConstructor() {

src/main/java/com/raoulvdberge/refinedstorage/tile/TileController.java

@@ -41,7 +41,6 @@ import com.raoulvdberge.refinedstorage.integration.forgeenergy.EnergyForge;
 import com.raoulvdberge.refinedstorage.network.*;
 import com.raoulvdberge.refinedstorage.tile.config.IRedstoneConfigurable;
 import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.RSSerializers;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import com.raoulvdberge.refinedstorage.tile.grid.IGrid;
@@ -69,66 +68,6 @@ import java.util.*;
 import java.util.function.Predicate;
 
 public class TileController extends TileBase implements ITickable, INetwork, IRedstoneConfigurable, INetworkNode, INetworkNodeProxy<TileController> {
-    public static final TileDataParameter<Integer> REDSTONE_MODE = RedstoneMode.createParameter();
-
-    public static final TileDataParameter<Integer> ENERGY_USAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileController>() {
-        @Override
-        public Integer getValue(TileController tile) {
-            return tile.getEnergyUsage();
-        }
-    });
-
-    public static final TileDataParameter<Integer> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileController>() {
-        @Override
-        public Integer getValue(TileController tile) {
-            return tile.energy.getEnergyStored();
-        }
-    });
-
-    public static final TileDataParameter<Integer> ENERGY_CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileController>() {
-        @Override
-        public Integer getValue(TileController tile) {
-            return tile.energy.getMaxEnergyStored();
-        }
-    });
-
-    public static final TileDataParameter<List<ClientNode>> NODES = new TileDataParameter<>(RSSerializers.CLIENT_NODE_SERIALIZER, new ArrayList<>(), new ITileDataProducer<List<ClientNode>, TileController>() {
-        @Override
-        public List<ClientNode> getValue(TileController tile) {
-            List<ClientNode> nodes = new ArrayList<>();
-
-            for (INetworkNode node : tile.nodeGraph.all()) {
-                if (node.canUpdate()) {
-                    ItemStack stack = node.getItemStack();
-
-                    if (stack.isEmpty()) {
-                        continue;
-                    }
-
-                    ClientNode clientNode = new ClientNode(stack, 1, node.getEnergyUsage());
-
-                    if (nodes.contains(clientNode)) {
-                        ClientNode other = nodes.get(nodes.indexOf(clientNode));
-
-                        other.setAmount(other.getAmount() + 1);
-                    } else {
-                        nodes.add(clientNode);
-                    }
-                }
-            }
-
-            nodes.sort(CLIENT_NODE_COMPARATOR);
-
-            return nodes;
-        }
-    });
-
-    public static final String NBT_ENERGY = "Energy";
-    public static final String NBT_ENERGY_CAPACITY = "EnergyCapacity";
-
-    private static final String NBT_READER_WRITER_CHANNELS = "ReaderWriterChannels";
-    private static final String NBT_READER_WRITER_NAME = "Name";
-
     private static final Comparator<ClientNode> CLIENT_NODE_COMPARATOR = (left, right) -> {
         if (left.getEnergyUsage() == right.getEnergyUsage()) {
             return 0;
@@ -137,6 +76,44 @@ public class TileController extends TileBase implements ITickable, INetwork, IRe
         return (left.getEnergyUsage() > right.getEnergyUsage()) ? -1 : 1;
     };
 
+    public static final TileDataParameter<Integer, TileController> REDSTONE_MODE = RedstoneMode.createParameter();
+    public static final TileDataParameter<Integer, TileController> ENERGY_USAGE = new TileDataParameter<>(DataSerializers.VARINT, 0, TileController::getEnergyUsage);
+    public static final TileDataParameter<Integer, TileController> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getEnergy().getEnergyStored());
+    public static final TileDataParameter<Integer, TileController> ENERGY_CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getEnergy().getMaxEnergyStored());
+    public static final TileDataParameter<List<ClientNode>, TileController> NODES = new TileDataParameter<>(RSSerializers.CLIENT_NODE_SERIALIZER, new ArrayList<>(), t -> {
+        List<ClientNode> nodes = new ArrayList<>();
+
+        for (INetworkNode node : t.nodeGraph.all()) {
+            if (node.canUpdate()) {
+                ItemStack stack = node.getItemStack();
+
+                if (stack.isEmpty()) {
+                    continue;
+                }
+
+                ClientNode clientNode = new ClientNode(stack, 1, node.getEnergyUsage());
+
+                if (nodes.contains(clientNode)) {
+                    ClientNode other = nodes.get(nodes.indexOf(clientNode));
+
+                    other.setAmount(other.getAmount() + 1);
+                } else {
+                    nodes.add(clientNode);
+                }
+            }
+        }
+
+        nodes.sort(CLIENT_NODE_COMPARATOR);
+
+        return nodes;
+    });
+
+    public static final String NBT_ENERGY = "Energy";
+    public static final String NBT_ENERGY_CAPACITY = "EnergyCapacity";
+
+    private static final String NBT_READER_WRITER_CHANNELS = "ReaderWriterChannels";
+    private static final String NBT_READER_WRITER_NAME = "Name";
+
     private IItemGridHandler itemGridHandler = new ItemGridHandler(this);
     private IFluidGridHandler fluidGridHandler = new FluidGridHandler(this);
 

src/main/java/com/raoulvdberge/refinedstorage/tile/TileDestructor.java

@@ -4,8 +4,6 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDestructo
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -14,20 +12,12 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileDestructor extends TileNode<NetworkNodeDestructor> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-    public static final TileDataParameter<Boolean> PICKUP = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileDestructor>() {
-        @Override
-        public Boolean getValue(TileDestructor tile) {
-            return tile.getNode().isPickupItem();
-        }
-    }, new ITileDataConsumer<Boolean, TileDestructor>() {
-        @Override
-        public void setValue(TileDestructor tile, Boolean value) {
-            tile.getNode().setPickupItem(value);
-            tile.getNode().markDirty();
-        }
+    public static final TileDataParameter<Integer, TileDestructor> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileDestructor> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<Integer, TileDestructor> TYPE = IType.createParameter();
+    public static final TileDataParameter<Boolean, TileDestructor> PICKUP = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isPickupItem(), (t, v) -> {
+        t.getNode().setPickupItem(v);
+        t.getNode().markDirty();
     });
 
     public TileDestructor() {

src/main/java/com/raoulvdberge/refinedstorage/tile/TileDetector.java

@@ -4,8 +4,6 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeDetector;
 import com.raoulvdberge.refinedstorage.gui.GuiDetector;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
@@ -21,41 +19,23 @@ import javax.annotation.Nonnull;
 public class TileDetector extends TileNode<NetworkNodeDetector> {
     private static final String NBT_POWERED = "Powered";
 
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-
-    public static final TileDataParameter<Integer> MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileDetector>() {
-        @Override
-        public Integer getValue(TileDetector tile) {
-            return tile.getNode().getMode();
-        }
-    }, new ITileDataConsumer<Integer, TileDetector>() {
-        @Override
-        public void setValue(TileDetector tile, Integer value) {
-            if (value == NetworkNodeDetector.MODE_UNDER || value == NetworkNodeDetector.MODE_EQUAL || value == NetworkNodeDetector.MODE_ABOVE || value == NetworkNodeDetector.MODE_AUTOCRAFTING) {
-                tile.getNode().setMode(value);
-                tile.getNode().markDirty();
-            }
+    public static final TileDataParameter<Integer, TileDetector> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileDetector> TYPE = IType.createParameter();
+    public static final TileDataParameter<Integer, TileDetector> MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getMode(), (t, v) -> {
+        if (v == NetworkNodeDetector.MODE_UNDER || v == NetworkNodeDetector.MODE_EQUAL || v == NetworkNodeDetector.MODE_ABOVE || v == NetworkNodeDetector.MODE_AUTOCRAFTING) {
+            t.getNode().setMode(v);
+            t.getNode().markDirty();
         }
     });
-
-    public static final TileDataParameter<Integer> AMOUNT = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileDetector>() {
-        @Override
-        public Integer getValue(TileDetector tile) {
-            return tile.getNode().getAmount();
-        }
-    }, new ITileDataConsumer<Integer, TileDetector>() {
-        @Override
-        public void setValue(TileDetector tile, Integer value) {
-            tile.getNode().setAmount(value);
-            tile.getNode().markDirty();
-        }
-    }, parameter -> {
+    public static final TileDataParameter<Integer, TileDetector> AMOUNT = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getAmount(), (t, v) -> {
+        t.getNode().setAmount(v);
+        t.getNode().markDirty();
+    }, p -> {
         if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) {
             GuiScreen gui = Minecraft.getMinecraft().currentScreen;
 
             if (gui instanceof GuiDetector) {
-                ((GuiDetector) gui).AMOUNT.setText(String.valueOf(parameter.getValue()));
+                GuiDetector.AMOUNT.setText(String.valueOf(p));
             }
         }
     });

src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskDrive.java

@@ -4,7 +4,6 @@ import com.raoulvdberge.refinedstorage.api.storage.AccessType;
 import com.raoulvdberge.refinedstorage.api.storage.IStorageDisk;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskdrive.NetworkNodeDiskDrive;
 import com.raoulvdberge.refinedstorage.tile.config.*;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.datasync.DataSerializers;
@@ -18,59 +17,53 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileDiskDrive extends TileNode<NetworkNodeDiskDrive> {
-    public static final TileDataParameter<Integer> PRIORITY = IPrioritizable.createParameter();
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-    public static final TileDataParameter<Boolean> VOID_EXCESS = IExcessVoidable.createParameter();
-    public static final TileDataParameter<AccessType> ACCESS_TYPE = IAccessType.createParameter();
-    public static final TileDataParameter<Integer> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileDiskDrive>() {
-        @Override
-        public Integer getValue(TileDiskDrive tile) {
-            int stored = 0;
+    public static final TileDataParameter<Integer, TileDiskDrive> PRIORITY = IPrioritizable.createParameter();
+    public static final TileDataParameter<Integer, TileDiskDrive> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileDiskDrive> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<Integer, TileDiskDrive> TYPE = IType.createParameter();
+    public static final TileDataParameter<Boolean, TileDiskDrive> VOID_EXCESS = IExcessVoidable.createParameter();
+    public static final TileDataParameter<AccessType, TileDiskDrive> ACCESS_TYPE = IAccessType.createParameter();
+    public static final TileDataParameter<Integer, TileDiskDrive> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> {
+        int stored = 0;
 
-            for (IStorageDisk storage : tile.getNode().getItemStorages()) {
-                if (storage != null) {
-                    stored += storage.getStored();
-                }
+        for (IStorageDisk storage : t.getNode().getItemStorages()) {
+            if (storage != null) {
+                stored += storage.getStored();
             }
-
-            for (IStorageDisk storage : tile.getNode().getFluidStorages()) {
-                if (storage != null) {
-                    stored += storage.getStored();
-                }
-            }
-
-            return stored;
         }
+
+        for (IStorageDisk storage : t.getNode().getFluidStorages()) {
+            if (storage != null) {
+                stored += storage.getStored();
+            }
+        }
+
+        return stored;
     });
-    public static final TileDataParameter<Integer> CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileDiskDrive>() {
-        @Override
-        public Integer getValue(TileDiskDrive tile) {
-            int capacity = 0;
+    public static final TileDataParameter<Integer, TileDiskDrive> CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> {
+        int capacity = 0;
 
-            for (IStorageDisk storage : tile.getNode().getItemStorages()) {
-                if (storage != null) {
-                    if (storage.getCapacity() == -1) {
-                        return -1;
-                    }
-
-                    capacity += storage.getCapacity();
+        for (IStorageDisk storage : t.getNode().getItemStorages()) {
+            if (storage != null) {
+                if (storage.getCapacity() == -1) {
+                    return -1;
                 }
+
+                capacity += storage.getCapacity();
             }
-
-            for (IStorageDisk storage : tile.getNode().getFluidStorages()) {
-                if (storage != null) {
-                    if (storage.getCapacity() == -1) {
-                        return -1;
-                    }
-
-                    capacity += storage.getCapacity();
-                }
-            }
-
-            return capacity;
         }
+
+        for (IStorageDisk storage : t.getNode().getFluidStorages()) {
+            if (storage != null) {
+                if (storage.getCapacity() == -1) {
+                    return -1;
+                }
+
+                capacity += storage.getCapacity();
+            }
+        }
+
+        return capacity;
     });
 
     private static final String NBT_DISK_STATE = "DiskState_%d";

src/main/java/com/raoulvdberge/refinedstorage/tile/TileDiskManipulator.java

@@ -4,8 +4,6 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.diskmanipulator.Netw
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IFilterable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.datasync.DataSerializers;
@@ -19,21 +17,12 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileDiskManipulator extends TileNode<NetworkNodeDiskManipulator> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-
-    public static final TileDataParameter<Integer> IO_MODE = new TileDataParameter<>(DataSerializers.VARINT, NetworkNodeDiskManipulator.IO_MODE_INSERT, new ITileDataProducer<Integer, TileDiskManipulator>() {
-        @Override
-        public Integer getValue(TileDiskManipulator tile) {
-            return tile.getNode().getIoMode();
-        }
-    }, new ITileDataConsumer<Integer, TileDiskManipulator>() {
-        @Override
-        public void setValue(TileDiskManipulator tile, Integer value) {
-            tile.getNode().setIoMode(value);
-            tile.getNode().markDirty();
-        }
+    public static final TileDataParameter<Integer, TileDiskManipulator> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileDiskManipulator> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<Integer, TileDiskManipulator> TYPE = IType.createParameter();
+    public static final TileDataParameter<Integer, TileDiskManipulator> IO_MODE = new TileDataParameter<>(DataSerializers.VARINT, NetworkNodeDiskManipulator.IO_MODE_INSERT, t -> t.getNode().getIoMode(), (t, v) -> {
+        t.getNode().setIoMode(v);
+        t.getNode().markDirty();
     });
 
     private Integer[] diskState = new Integer[6];

src/main/java/com/raoulvdberge/refinedstorage/tile/TileExporter.java

@@ -5,9 +5,6 @@ import com.raoulvdberge.refinedstorage.container.ContainerExporter;
 import com.raoulvdberge.refinedstorage.gui.GuiExporter;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
 import com.raoulvdberge.refinedstorage.tile.config.IType;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataListener;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.client.Minecraft;
 import net.minecraft.item.ItemStack;
@@ -18,57 +15,37 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileExporter extends TileNode<NetworkNodeExporter> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-    public static final TileDataParameter<Boolean> REGULATOR = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileExporter>() {
-        @Override
-        public Boolean getValue(TileExporter tile) {
-            return tile.getNode().isRegulator();
-        }
-    }, new ITileDataConsumer<Boolean, TileExporter>() {
-        @Override
-        public void setValue(TileExporter tile, Boolean value) {
-            NetworkNodeExporter exporter = tile.getNode();
+    public static final TileDataParameter<Integer, TileExporter> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileExporter> TYPE = IType.createParameter();
+    public static final TileDataParameter<Boolean, TileExporter> REGULATOR = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isRegulator(), (t, v) -> {
+        NetworkNodeExporter exporter = t.getNode();
 
-            for (int i = 0; i < exporter.getItemFilters().getSlots() + exporter.getFluidFilters().getSlots(); ++i) {
-                ItemStack slot = i >= exporter.getItemFilters().getSlots() ? exporter.getFluidFilters().getStackInSlot(i - exporter.getItemFilters().getSlots()) : exporter.getItemFilters().getStackInSlot(i);
+        for (int i = 0; i < exporter.getItemFilters().getSlots() + exporter.getFluidFilters().getSlots(); ++i) {
+            ItemStack slot = i >= exporter.getItemFilters().getSlots() ? exporter.getFluidFilters().getStackInSlot(i - exporter.getItemFilters().getSlots()) : exporter.getItemFilters().getStackInSlot(i);
 
-                if (!slot.isEmpty()) {
-                    slot.setCount(1);
-                }
+            if (!slot.isEmpty()) {
+                slot.setCount(1);
             }
-
-            exporter.setRegulator(value);
-            exporter.markDirty();
-
-            tile.world.getMinecraftServer().getPlayerList().getPlayers().stream()
-                .filter(player -> player.openContainer instanceof ContainerExporter && ((ContainerExporter) player.openContainer).getTile().getPos().equals(tile.getPos()))
-                .forEach(player -> {
-                    ((ContainerExporter) player.openContainer).initSlots();
-
-                    player.openContainer.detectAndSendChanges();
-                });
         }
-    }, new ITileDataListener<Boolean>() {
-        @Override
-        public void onChanged(TileDataParameter<Boolean> parameter) {
-            if (Minecraft.getMinecraft().currentScreen instanceof GuiExporter) {
-                ((ContainerExporter) ((GuiExporter) Minecraft.getMinecraft().currentScreen).inventorySlots).initSlots();
-            }
+
+        exporter.setRegulator(v);
+        exporter.markDirty();
+
+        t.world.getMinecraftServer().getPlayerList().getPlayers().stream()
+            .filter(player -> player.openContainer instanceof ContainerExporter && ((ContainerExporter) player.openContainer).getTile().getPos().equals(t.getPos()))
+            .forEach(player -> {
+                ((ContainerExporter) player.openContainer).initSlots();
+
+                player.openContainer.detectAndSendChanges();
+            });
+    }, p -> {
+        if (Minecraft.getMinecraft().currentScreen instanceof GuiExporter) {
+            ((ContainerExporter) ((GuiExporter) Minecraft.getMinecraft().currentScreen).inventorySlots).initSlots();
         }
     });
-
-    public static final TileDataParameter<Boolean> CRAFT_ONLY = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileExporter>() {
-        @Override
-        public Boolean getValue(TileExporter tile) {
-            return tile.getNode().isCraftOnly();
-        }
-    }, new ITileDataConsumer<Boolean, TileExporter>() {
-        @Override
-        public void setValue(TileExporter tile, Boolean value) {
-            tile.getNode().setCraftOnly(value);
-            tile.getNode().markDirty();
-        }
+    public static final TileDataParameter<Boolean, TileExporter> CRAFT_ONLY = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isCraftOnly(), (t, v) -> {
+        t.getNode().setCraftOnly(v);
+        t.getNode().markDirty();
     });
 
     public TileExporter() {

src/main/java/com/raoulvdberge/refinedstorage/tile/TileExternalStorage.java

@@ -5,7 +5,6 @@ import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.Netw
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.StorageFluidExternal;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.externalstorage.StorageItemExternal;
 import com.raoulvdberge.refinedstorage.tile.config.*;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -14,44 +13,36 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileExternalStorage extends TileNode<NetworkNodeExternalStorage> {
-    public static final TileDataParameter<Integer> PRIORITY = IPrioritizable.createParameter();
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-    public static final TileDataParameter<AccessType> ACCESS_TYPE = IAccessType.createParameter();
+    public static final TileDataParameter<Integer, TileExternalStorage> PRIORITY = IPrioritizable.createParameter();
+    public static final TileDataParameter<Integer, TileExternalStorage> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileExternalStorage> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<Integer, TileExternalStorage> TYPE = IType.createParameter();
+    public static final TileDataParameter<AccessType, TileExternalStorage> ACCESS_TYPE = IAccessType.createParameter();
+    public static final TileDataParameter<Integer, TileExternalStorage> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> {
+        int stored = 0;
 
-    public static final TileDataParameter<Integer> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileExternalStorage>() {
-        @Override
-        public Integer getValue(TileExternalStorage tile) {
-            int stored = 0;
-
-            for (StorageItemExternal storage : tile.getNode().getItemStorages()) {
-                stored += storage.getStored();
-            }
-
-            for (StorageFluidExternal storage : tile.getNode().getFluidStorages()) {
-                stored += storage.getStored();
-            }
-
-            return stored;
+        for (StorageItemExternal storage : t.getNode().getItemStorages()) {
+            stored += storage.getStored();
         }
+
+        for (StorageFluidExternal storage : t.getNode().getFluidStorages()) {
+            stored += storage.getStored();
+        }
+
+        return stored;
     });
+    public static final TileDataParameter<Integer, TileExternalStorage> CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> {
+        int capacity = 0;
 
-    public static final TileDataParameter<Integer> CAPACITY = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileExternalStorage>() {
-        @Override
-        public Integer getValue(TileExternalStorage tile) {
-            int capacity = 0;
-
-            for (StorageItemExternal storage : tile.getNode().getItemStorages()) {
-                capacity += storage.getCapacity();
-            }
-
-            for (StorageFluidExternal storage : tile.getNode().getFluidStorages()) {
-                capacity += storage.getCapacity();
-            }
-
-            return capacity;
+        for (StorageItemExternal storage : t.getNode().getItemStorages()) {
+            capacity += storage.getCapacity();
         }
+
+        for (StorageFluidExternal storage : t.getNode().getFluidStorages()) {
+            capacity += storage.getCapacity();
+        }
+
+        return capacity;
     });
 
     public TileExternalStorage() {

src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidInterface.java

@@ -2,7 +2,6 @@ package com.raoulvdberge.refinedstorage.tile;
 
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidInterface;
 import com.raoulvdberge.refinedstorage.tile.config.IComparable;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.RSSerializers;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.util.EnumFacing;
@@ -16,21 +15,9 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileFluidInterface extends TileNode<NetworkNodeFluidInterface> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-
-    public static final TileDataParameter<FluidStack> TANK_IN = new TileDataParameter<>(RSSerializers.FLUID_STACK_SERIALIZER, null, new ITileDataProducer<FluidStack, TileFluidInterface>() {
-        @Override
-        public FluidStack getValue(TileFluidInterface tile) {
-            return tile.getNode().getTankIn().getFluid();
-        }
-    });
-
-    public static final TileDataParameter<FluidStack> TANK_OUT = new TileDataParameter<>(RSSerializers.FLUID_STACK_SERIALIZER, null, new ITileDataProducer<FluidStack, TileFluidInterface>() {
-        @Override
-        public FluidStack getValue(TileFluidInterface tile) {
-            return tile.getNode().getTankOut().getFluid();
-        }
-    });
+    public static final TileDataParameter<Integer, TileFluidInterface> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<FluidStack, TileFluidInterface> TANK_IN = new TileDataParameter<>(RSSerializers.FLUID_STACK_SERIALIZER, null, t -> t.getNode().getTankIn().getFluid());
+    public static final TileDataParameter<FluidStack, TileFluidInterface> TANK_OUT = new TileDataParameter<>(RSSerializers.FLUID_STACK_SERIALIZER, null, t -> t.getNode().getTankOut().getFluid());
 
     public TileFluidInterface() {
         dataManager.addWatchedParameter(COMPARE);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileFluidStorage.java

@@ -3,7 +3,6 @@ package com.raoulvdberge.refinedstorage.tile;
 import com.raoulvdberge.refinedstorage.api.storage.AccessType;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeFluidStorage;
 import com.raoulvdberge.refinedstorage.tile.config.*;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -12,17 +11,12 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileFluidStorage extends TileNode<NetworkNodeFluidStorage> {
-    public static final TileDataParameter<Integer> PRIORITY = IPrioritizable.createParameter();
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Boolean> VOID_EXCESS = IExcessVoidable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<AccessType> ACCESS_TYPE = IAccessType.createParameter();
-    public static final TileDataParameter<Integer> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileFluidStorage>() {
-        @Override
-        public Integer getValue(TileFluidStorage tile) {
-            return tile.getNode().getStorage().getStored();
-        }
-    });
+    public static final TileDataParameter<Integer, TileFluidStorage> PRIORITY = IPrioritizable.createParameter();
+    public static final TileDataParameter<Integer, TileFluidStorage> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Boolean, TileFluidStorage> VOID_EXCESS = IExcessVoidable.createParameter();
+    public static final TileDataParameter<Integer, TileFluidStorage> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<AccessType, TileFluidStorage> ACCESS_TYPE = IAccessType.createParameter();
+    public static final TileDataParameter<Integer, TileFluidStorage> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getStorage().getStored());
 
     public TileFluidStorage() {
         dataManager.addWatchedParameter(PRIORITY);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileImporter.java

@@ -11,9 +11,9 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileImporter extends TileNode<NetworkNodeImporter> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
+    public static final TileDataParameter<Integer, TileImporter> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileImporter> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<Integer, TileImporter> TYPE = IType.createParameter();
 
     public TileImporter() {
         dataManager.addWatchedParameter(COMPARE);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileInterface.java

@@ -13,7 +13,7 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileInterface extends TileNode<NetworkNodeInterface> {
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileInterface> COMPARE = IComparable.createParameter();
 
     public TileInterface() {
         dataManager.addWatchedParameter(COMPARE);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileNetworkTransmitter.java

@@ -1,7 +1,6 @@
 package com.raoulvdberge.refinedstorage.tile;
 
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeNetworkTransmitter;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.EnumFacing;
@@ -14,28 +13,13 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileNetworkTransmitter extends TileNode<NetworkNodeNetworkTransmitter> {
-    public static final TileDataParameter<Integer> DISTANCE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileNetworkTransmitter>() {
-        @Override
-        public Integer getValue(TileNetworkTransmitter tile) {
-            NetworkNodeNetworkTransmitter transmitter = tile.getNode();
+    public static final TileDataParameter<Integer, TileNetworkTransmitter> DISTANCE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> {
+        NetworkNodeNetworkTransmitter transmitter = t.getNode();
 
-            return (transmitter.getReceiver() != null && transmitter.isSameDimension()) ? transmitter.getDistance() : -1;
-        }
-    });
-
-    public static final TileDataParameter<Integer> RECEIVER_DIMENSION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileNetworkTransmitter>() {
-        @Override
-        public Integer getValue(TileNetworkTransmitter tile) {
-            return tile.getNode().getReceiverDimension();
-        }
-    });
-
-    public static final TileDataParameter<Boolean> RECEIVER_DIMENSION_SUPPORTED = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileNetworkTransmitter>() {
-        @Override
-        public Boolean getValue(TileNetworkTransmitter tile) {
-            return tile.getNode().isDimensionSupported();
-        }
+        return (transmitter.getReceiver() != null && transmitter.isSameDimension()) ? transmitter.getDistance() : -1;
     });
+    public static final TileDataParameter<Integer, TileNetworkTransmitter> RECEIVER_DIMENSION = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getReceiverDimension());
+    public static final TileDataParameter<Boolean, TileNetworkTransmitter> RECEIVER_DIMENSION_SUPPORTED = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isDimensionSupported());
 
     public TileNetworkTransmitter() {
         dataManager.addWatchedParameter(DISTANCE);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileNode.java

@@ -20,14 +20,15 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public abstract class TileNode<N extends NetworkNode> extends TileBase implements INetworkNodeProxy<N>, IRedstoneConfigurable, IWrenchable {
-    public static final TileDataParameter<Integer> REDSTONE_MODE = RedstoneMode.createParameter();
+    public static final TileDataParameter<Integer, TileNode> REDSTONE_MODE = RedstoneMode.createParameter();
 
+    protected static final String NBT_ACTIVE = "Active";
+
+    // @todo: Remove in a later version
     private NBTTagCompound legacyTag;
 
     private N clientNode;
 
-    protected static final String NBT_ACTIVE = "Active";
-
     public TileNode() {
         dataManager.addWatchedParameter(REDSTONE_MODE);
     }

src/main/java/com/raoulvdberge/refinedstorage/tile/TileReader.java

@@ -8,8 +8,6 @@ import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.IGuiReaderWriter;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeReader;
 import com.raoulvdberge.refinedstorage.gui.GuiReaderWriter;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.client.Minecraft;
 import net.minecraft.network.datasync.DataSerializers;
@@ -24,27 +22,19 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileReader extends TileNode<NetworkNodeReader> {
-    static <T extends TileNode> TileDataParameter<String> createChannelParameter() {
-        return new TileDataParameter<>(DataSerializers.STRING, "", new ITileDataProducer<String, T>() {
-            @Override
-            public String getValue(T tile) {
-                return ((IGuiReaderWriter) tile.getNode()).getChannel();
-            }
-        }, new ITileDataConsumer<String, T>() {
-            @Override
-            public void setValue(T tile, String value) {
-                ((IGuiReaderWriter) tile.getNode()).setChannel(value);
+    static <T extends TileNode> TileDataParameter<String, T> createChannelParameter() {
+        return new TileDataParameter<>(DataSerializers.STRING, "", t -> ((IGuiReaderWriter) t.getNode()).getChannel(), (t, v) -> {
+            ((IGuiReaderWriter) t.getNode()).setChannel(v);
 
-                tile.getNode().markDirty();
-            }
-        }, parameter -> {
+            t.getNode().markDirty();
+        }, p -> {
             if (Minecraft.getMinecraft().currentScreen instanceof GuiReaderWriter) {
-                ((GuiReaderWriter) Minecraft.getMinecraft().currentScreen).updateSelection(parameter.getValue());
+                ((GuiReaderWriter) Minecraft.getMinecraft().currentScreen).updateSelection(p);
             }
         });
     }
 
-    public static final TileDataParameter<String> CHANNEL = createChannelParameter();
+    public static final TileDataParameter<String, TileReader> CHANNEL = createChannelParameter();
 
     public TileReader() {
         dataManager.addWatchedParameter(CHANNEL);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileSolderer.java

@@ -2,7 +2,6 @@ package com.raoulvdberge.refinedstorage.tile;
 
 import com.raoulvdberge.refinedstorage.api.solderer.ISoldererRecipe;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeSolderer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.datasync.DataSerializers;
@@ -16,28 +15,13 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileSolderer extends TileNode<NetworkNodeSolderer> {
-    public static final TileDataParameter<Integer> DURATION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileSolderer>() {
-        @Override
-        public Integer getValue(TileSolderer tile) {
-            ISoldererRecipe recipe = tile.getNode().getRecipe();
+    public static final TileDataParameter<Integer, TileSolderer> DURATION = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> {
+        ISoldererRecipe recipe = t.getNode().getRecipe();
 
-            return recipe == null ? 0 : recipe.getDuration();
-        }
-    });
-
-    public static final TileDataParameter<Integer> PROGRESS = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileSolderer>() {
-        @Override
-        public Integer getValue(TileSolderer tile) {
-            return tile.getNode().getProgress();
-        }
-    });
-
-    public static final TileDataParameter<Boolean> WORKING = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileSolderer>() {
-        @Override
-        public Boolean getValue(TileSolderer tile) {
-            return tile.getNode().isWorking();
-        }
+        return recipe == null ? 0 : recipe.getDuration();
     });
+    public static final TileDataParameter<Integer, TileSolderer> PROGRESS = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getProgress());
+    public static final TileDataParameter<Boolean, TileSolderer> WORKING = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isWorking());
 
     private boolean working;
 

src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorage.java

@@ -3,7 +3,6 @@ package com.raoulvdberge.refinedstorage.tile;
 import com.raoulvdberge.refinedstorage.api.storage.AccessType;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeStorage;
 import com.raoulvdberge.refinedstorage.tile.config.*;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -12,17 +11,12 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileStorage extends TileNode<NetworkNodeStorage> {
-    public static final TileDataParameter<Integer> PRIORITY = IPrioritizable.createParameter();
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> MODE = IFilterable.createParameter();
-    public static final TileDataParameter<AccessType> ACCESS_TYPE = IAccessType.createParameter();
-    public static final TileDataParameter<Integer> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileStorage>() {
-        @Override
-        public Integer getValue(TileStorage tile) {
-            return tile.getNode().getStorage().getStored();
-        }
-    });
-    public static final TileDataParameter<Boolean> VOID_EXCESS = IExcessVoidable.createParameter();
+    public static final TileDataParameter<Integer, TileStorage> PRIORITY = IPrioritizable.createParameter();
+    public static final TileDataParameter<Integer, TileStorage> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileStorage> MODE = IFilterable.createParameter();
+    public static final TileDataParameter<AccessType, TileStorage> ACCESS_TYPE = IAccessType.createParameter();
+    public static final TileDataParameter<Integer, TileStorage> STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getStorage().getStored());
+    public static final TileDataParameter<Boolean, TileStorage> VOID_EXCESS = IExcessVoidable.createParameter();
 
     public TileStorage() {
         dataManager.addWatchedParameter(PRIORITY);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileStorageMonitor.java

@@ -13,13 +13,13 @@ import net.minecraft.world.World;
 import javax.annotation.Nullable;
 
 public class TileStorageMonitor extends TileNode<NetworkNodeStorageMonitor> {
+    public static final TileDataParameter<Integer, TileStorageMonitor> COMPARE = IComparable.createParameter();
+    public static final TileDataParameter<Integer, TileStorageMonitor> TYPE = IType.createParameter();
+
     private static final String NBT_TYPE = "Type";
     private static final String NBT_STACK = "Stack";
     private static final String NBT_AMOUNT = "Amount";
 
-    public static final TileDataParameter<Integer> COMPARE = IComparable.createParameter();
-    public static final TileDataParameter<Integer> TYPE = IType.createParameter();
-
     private int type;
     private int amount;
     @Nullable

src/main/java/com/raoulvdberge/refinedstorage/tile/TileWirelessTransmitter.java

@@ -1,7 +1,6 @@
 package com.raoulvdberge.refinedstorage.tile;
 
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeWirelessTransmitter;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -10,12 +9,7 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileWirelessTransmitter extends TileNode<NetworkNodeWirelessTransmitter> {
-    public static final TileDataParameter<Integer> RANGE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileWirelessTransmitter>() {
-        @Override
-        public Integer getValue(TileWirelessTransmitter tile) {
-            return tile.getNode().getRange();
-        }
-    });
+    public static final TileDataParameter<Integer, TileWirelessTransmitter> RANGE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getRange());
 
     public TileWirelessTransmitter() {
         dataManager.addWatchedParameter(RANGE);

src/main/java/com/raoulvdberge/refinedstorage/tile/TileWriter.java

@@ -18,7 +18,7 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileWriter extends TileNode<NetworkNodeWriter> {
-    public static final TileDataParameter<String> CHANNEL = TileReader.createChannelParameter();
+    public static final TileDataParameter<String, TileWriter> CHANNEL = TileReader.createChannelParameter();
 
     public TileWriter() {
         dataManager.addWatchedParameter(CHANNEL);

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IAccessType.java

@@ -2,25 +2,13 @@ package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
 import com.raoulvdberge.refinedstorage.api.storage.AccessType;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.RSSerializers;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.tileentity.TileEntity;
 
 public interface IAccessType {
-    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<AccessType> createParameter() {
-        return new TileDataParameter<>(RSSerializers.ACCESS_TYPE_SERIALIZER, AccessType.INSERT_EXTRACT, new ITileDataProducer<AccessType, T>() {
-            @Override
-            public AccessType getValue(T tile) {
-                return ((IAccessType) tile.getNode()).getAccessType();
-            }
-        }, new ITileDataConsumer<AccessType, T>() {
-            @Override
-            public void setValue(T tile, AccessType value) {
-                ((IAccessType) tile.getNode()).setAccessType(value);
-            }
-        });
+    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<AccessType, T> createParameter() {
+        return new TileDataParameter<>(RSSerializers.ACCESS_TYPE_SERIALIZER, AccessType.INSERT_EXTRACT, t -> ((IAccessType) t.getNode()).getAccessType(), (t, v) -> ((IAccessType) t.getNode()).setAccessType(v));
     }
 
     AccessType getAccessType();

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IComparable.java

@@ -1,25 +1,13 @@
 package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.tileentity.TileEntity;
 
 public interface IComparable {
-    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer> createParameter() {
-        return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, T>() {
-            @Override
-            public Integer getValue(T tile) {
-                return ((IComparable) tile.getNode()).getCompare();
-            }
-        }, new ITileDataConsumer<Integer, T>() {
-            @Override
-            public void setValue(T tile, Integer value) {
-                ((IComparable) tile.getNode()).setCompare(value);
-            }
-        });
+    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer, T> createParameter() {
+        return new TileDataParameter<>(DataSerializers.VARINT, 0, t -> ((IComparable) t.getNode()).getCompare(), (t, v) -> ((IComparable) t.getNode()).setCompare(v));
     }
 
     int getCompare();

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IExcessVoidable.java

@@ -1,25 +1,13 @@
 package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.tileentity.TileEntity;
 
 public interface IExcessVoidable {
-    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Boolean> createParameter() {
-        return new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, T>() {
-            @Override
-            public Boolean getValue(T tile) {
-                return ((IExcessVoidable) tile.getNode()).getVoidExcess();
-            }
-        }, new ITileDataConsumer<Boolean, T>() {
-            @Override
-            public void setValue(T tile, Boolean value) {
-                ((IExcessVoidable) tile.getNode()).setVoidExcess(value);
-            }
-        });
+    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Boolean, T> createParameter() {
+        return new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> ((IExcessVoidable) t.getNode()).getVoidExcess(), (t, v) -> ((IExcessVoidable) t.getNode()).setVoidExcess(v));
     }
 
     boolean getVoidExcess();

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IFilterable.java

@@ -5,8 +5,6 @@ import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
 import com.raoulvdberge.refinedstorage.apiimpl.API;
 import com.raoulvdberge.refinedstorage.inventory.ItemHandlerFluid;
 import com.raoulvdberge.refinedstorage.item.filter.ItemFilter;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.item.ItemStack;
 import net.minecraft.network.datasync.DataSerializers;
@@ -18,18 +16,10 @@ public interface IFilterable {
     int WHITELIST = 0;
     int BLACKLIST = 1;
 
-    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer> createParameter() {
-        return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, T>() {
-            @Override
-            public Integer getValue(T tile) {
-                return ((IFilterable) tile.getNode()).getMode();
-            }
-        }, new ITileDataConsumer<Integer, T>() {
-            @Override
-            public void setValue(T tile, Integer value) {
-                if (value == WHITELIST || value == BLACKLIST) {
-                    ((IFilterable) tile.getNode()).setMode(value);
-                }
+    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer, T> createParameter() {
+        return new TileDataParameter<>(DataSerializers.VARINT, 0, t -> ((IFilterable) t.getNode()).getMode(), (t, v) -> {
+            if (v == WHITELIST || v == BLACKLIST) {
+                ((IFilterable) t.getNode()).setMode(v);
             }
         });
     }

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IPrioritizable.java

@@ -1,25 +1,13 @@
 package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.tileentity.TileEntity;
 
 public interface IPrioritizable {
-    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer> createParameter() {
-        return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, T>() {
-            @Override
-            public Integer getValue(T tile) {
-                return ((IPrioritizable) tile.getNode()).getPriority();
-            }
-        }, new ITileDataConsumer<Integer, T>() {
-            @Override
-            public void setValue(T tile, Integer value) {
-                ((IPrioritizable) tile.getNode()).setPriority(value);
-            }
-        });
+    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer, T> createParameter() {
+        return new TileDataParameter<>(DataSerializers.VARINT, 0, t -> ((IPrioritizable) t.getNode()).getPriority(), (t, v) -> ((IPrioritizable) t.getNode()).setPriority(v));
     }
 
     int getPriority();

src/main/java/com/raoulvdberge/refinedstorage/tile/config/IType.java

@@ -2,8 +2,6 @@ package com.raoulvdberge.refinedstorage.tile.config;
 
 import com.raoulvdberge.refinedstorage.api.network.node.INetworkNodeProxy;
 import com.raoulvdberge.refinedstorage.container.ContainerBase;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.tileentity.TileEntity;
@@ -13,22 +11,14 @@ public interface IType {
     int ITEMS = 0;
     int FLUIDS = 1;
 
-    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer> createParameter() {
-        return new TileDataParameter<>(DataSerializers.VARINT, ITEMS, new ITileDataProducer<Integer, T>() {
-            @Override
-            public Integer getValue(T tile) {
-                return ((IType) tile.getNode()).getType();
-            }
-        }, new ITileDataConsumer<Integer, T>() {
-            @Override
-            public void setValue(T tile, Integer value) {
-                if (value == 0 || value == 1) {
-                    ((IType) tile.getNode()).setType(value);
+    static <T extends TileEntity & INetworkNodeProxy> TileDataParameter<Integer, T> createParameter() {
+        return new TileDataParameter<>(DataSerializers.VARINT, ITEMS, t -> ((IType) t.getNode()).getType(), (t, v) -> {
+            if (v == 0 || v == 1) {
+                ((IType) t.getNode()).setType(v);
 
-                    tile.getWorld().playerEntities.stream()
-                        .filter(p -> p.openContainer instanceof ContainerBase && ((ContainerBase) p.openContainer).getTile().getPos().equals(tile.getPos()))
-                        .forEach(p -> p.openContainer.detectAndSendChanges());
-                }
+                t.getWorld().playerEntities.stream()
+                    .filter(p -> p.openContainer instanceof ContainerBase && ((ContainerBase) p.openContainer).getTile().getPos().equals(t.getPos()))
+                    .forEach(p -> p.openContainer.detectAndSendChanges());
             }
         });
     }

src/main/java/com/raoulvdberge/refinedstorage/tile/config/RedstoneMode.java

@@ -1,7 +1,5 @@
 package com.raoulvdberge.refinedstorage.tile.config;
 
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.network.datasync.DataSerializers;
@@ -43,17 +41,7 @@ public enum RedstoneMode {
         return id < 0 || id >= values().length ? IGNORE : values()[id];
     }
 
-    public static <T extends TileEntity> TileDataParameter<Integer> createParameter() {
-        return new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, T>() {
-            @Override
-            public Integer getValue(T tile) {
-                return ((IRedstoneConfigurable) tile).getRedstoneMode().ordinal();
-            }
-        }, new ITileDataConsumer<Integer, T>() {
-            @Override
-            public void setValue(T tile, Integer value) {
-                ((IRedstoneConfigurable) tile).setRedstoneMode(RedstoneMode.getById(value));
-            }
-        });
+    public static <T extends TileEntity & IRedstoneConfigurable> TileDataParameter<Integer, T> createParameter() {
+        return new TileDataParameter<>(DataSerializers.VARINT, IGNORE.ordinal(), t -> t.getRedstoneMode().ordinal(), (t, v) -> t.setRedstoneMode(RedstoneMode.getById(v)));
     }
 }

src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/ICraftingMonitor.java

@@ -15,7 +15,7 @@ public interface ICraftingMonitor {
 
     void onCancelled(EntityPlayerMP player, int id);
 
-    TileDataParameter<Integer> getRedstoneModeParameter();
+    TileDataParameter<Integer, ?> getRedstoneModeParameter();
 
     @Nullable
     BlockPos getNetworkPosition();

src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/TileCraftingMonitor.java

@@ -3,8 +3,6 @@ package com.raoulvdberge.refinedstorage.tile.craftingmonitor;
 import com.raoulvdberge.refinedstorage.api.network.INetwork;
 import com.raoulvdberge.refinedstorage.apiimpl.network.node.NetworkNodeCraftingMonitor;
 import com.raoulvdberge.refinedstorage.tile.TileNode;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
@@ -13,22 +11,14 @@ import net.minecraft.world.World;
 import javax.annotation.Nonnull;
 
 public class TileCraftingMonitor extends TileNode<NetworkNodeCraftingMonitor> {
-    public static final TileDataParameter<Boolean> VIEW_AUTOMATED = new TileDataParameter<>(DataSerializers.BOOLEAN, true, new ITileDataProducer<Boolean, TileCraftingMonitor>() {
-        @Override
-        public Boolean getValue(TileCraftingMonitor tile) {
-            return tile.getNode().canViewAutomated();
-        }
-    }, new ITileDataConsumer<Boolean, TileCraftingMonitor>() {
-        @Override
-        public void setValue(TileCraftingMonitor tile, Boolean value) {
-            tile.getNode().setViewAutomated(value);
-            tile.getNode().markDirty();
+    public static final TileDataParameter<Boolean, TileCraftingMonitor> VIEW_AUTOMATED = new TileDataParameter<>(DataSerializers.BOOLEAN, true, t -> t.getNode().canViewAutomated(), (t, v) -> {
+        t.getNode().setViewAutomated(v);
+        t.getNode().markDirty();
 
-            INetwork network = tile.getNode().getNetwork();
+        INetwork network = t.getNode().getNetwork();
 
-            if (network != null) {
-                network.sendCraftingMonitorUpdate();
-            }
+        if (network != null) {
+            network.sendCraftingMonitorUpdate();
         }
     });
 

src/main/java/com/raoulvdberge/refinedstorage/tile/craftingmonitor/WirelessCraftingMonitor.java

@@ -74,7 +74,7 @@ public class WirelessCraftingMonitor implements ICraftingMonitor {
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeParameter() {
+    public TileDataParameter<Integer, ?> getRedstoneModeParameter() {
         return null;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/tile/data/ITileDataConsumer.java

@@ -1,7 +0,0 @@
-package com.raoulvdberge.refinedstorage.tile.data;
-
-import net.minecraft.tileentity.TileEntity;
-
-public interface ITileDataConsumer<T, E extends TileEntity> {
-    void setValue(E tile, T value);
-}

src/main/java/com/raoulvdberge/refinedstorage/tile/data/ITileDataListener.java

@@ -1,5 +0,0 @@
-package com.raoulvdberge.refinedstorage.tile.data;
-
-public interface ITileDataListener<T> {
-    void onChanged(TileDataParameter<T> parameter);
-}

src/main/java/com/raoulvdberge/refinedstorage/tile/data/ITileDataProducer.java

@@ -1,7 +0,0 @@
-package com.raoulvdberge.refinedstorage.tile.data;
-
-import net.minecraft.tileentity.TileEntity;
-
-public interface ITileDataProducer<T, E extends TileEntity> {
-    T getValue(E tile);
-}

src/main/java/com/raoulvdberge/refinedstorage/tile/data/TileDataManager.java

@@ -17,26 +17,11 @@ public class TileDataManager {
     private static Map<Integer, TileDataParameter> REGISTRY = new HashMap<>();
 
     private List<TileDataParameter> parameters = new ArrayList<>();
-
     private List<TileDataParameter> watchedParameters = new ArrayList<>();
     private List<Object> watchedParametersCache = new ArrayList<>();
 
     private List<EntityPlayer> watchers = new ArrayList<>();
 
-    public static void registerParameter(TileDataParameter<?> parameter) {
-        parameter.setId(LAST_ID);
-
-        REGISTRY.put(LAST_ID++, parameter);
-    }
-
-    public static TileDataParameter<?> getParameter(int id) {
-        return REGISTRY.get(id);
-    }
-
-    public static <T> void setParameter(TileDataParameter<T> parameter, T value) {
-        RS.INSTANCE.network.sendToServer(new MessageTileDataParameterUpdate(parameter, value));
-    }
-
     private TileEntity tile;
 
     public TileDataManager(TileEntity tile) {
@@ -47,7 +32,7 @@ public class TileDataManager {
         return watchers;
     }
 
-    public void addParameter(TileDataParameter<?> parameter) {
+    public void addParameter(TileDataParameter parameter) {
         parameters.add(parameter);
     }
 
@@ -55,7 +40,7 @@ public class TileDataManager {
         return parameters;
     }
 
-    public void addWatchedParameter(TileDataParameter<?> parameter) {
+    public void addWatchedParameter(TileDataParameter parameter) {
         addParameter(parameter);
 
         watchedParameters.add(parameter);
@@ -66,7 +51,7 @@ public class TileDataManager {
         for (int i = 0; i < watchedParameters.size(); ++i) {
             TileDataParameter parameter = watchedParameters.get(i);
 
-            Object real = parameter.getValueProducer().getValue(tile);
+            Object real = parameter.getValueProducer().apply(tile);
             Object cached = watchedParametersCache.get(i);
 
             if (!real.equals(cached)) {
@@ -81,11 +66,25 @@ public class TileDataManager {
         parameters.forEach(p -> sendParameter(player, p));
     }
 
-    public void sendParameterToWatchers(TileDataParameter<?> parameter) {
+    public void sendParameterToWatchers(TileDataParameter parameter) {
         watchers.forEach(p -> sendParameter((EntityPlayerMP) p, parameter));
     }
 
-    public void sendParameter(EntityPlayerMP player, TileDataParameter<?> parameter) {
+    public void sendParameter(EntityPlayerMP player, TileDataParameter parameter) {
         RS.INSTANCE.network.sendTo(new MessageTileDataParameter(tile, parameter), player);
     }
+
+    public static void registerParameter(TileDataParameter parameter) {
+        parameter.setId(LAST_ID);
+
+        REGISTRY.put(LAST_ID++, parameter);
+    }
+
+    public static TileDataParameter getParameter(int id) {
+        return REGISTRY.get(id);
+    }
+
+    public static void setParameter(TileDataParameter parameter, Object value) {
+        RS.INSTANCE.network.sendToServer(new MessageTileDataParameterUpdate(parameter, value));
+    }
 }

src/main/java/com/raoulvdberge/refinedstorage/tile/data/TileDataParameter.java

@@ -3,23 +3,30 @@ package com.raoulvdberge.refinedstorage.tile.data;
 import net.minecraft.network.datasync.DataSerializer;
 import net.minecraft.tileentity.TileEntity;
 
-public class TileDataParameter<T> {
+import javax.annotation.Nullable;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public class TileDataParameter<T, E extends TileEntity> {
     private int id;
     private DataSerializer<T> serializer;
-    private ITileDataProducer<T, ? extends TileEntity> valueProducer;
-    private ITileDataConsumer<T, ? extends TileEntity> valueConsumer;
-    private ITileDataListener<T> listener;
+    private Function<E, T> valueProducer;
+    @Nullable
+    private BiConsumer<E, T> valueConsumer;
+    @Nullable
+    private Consumer<T> listener;
     private T value;
 
-    public TileDataParameter(DataSerializer<T> serializer, T defaultValue, ITileDataProducer<T, ? extends TileEntity> producer) {
+    public TileDataParameter(DataSerializer<T> serializer, T defaultValue, Function<E, T> producer) {
         this(serializer, defaultValue, producer, null);
     }
 
-    public TileDataParameter(DataSerializer<T> serializer, T defaultValue, ITileDataProducer<T, ? extends TileEntity> producer, ITileDataConsumer<T, ? extends TileEntity> consumer) {
+    public TileDataParameter(DataSerializer<T> serializer, T defaultValue, Function<E, T> producer, @Nullable BiConsumer<E, T> consumer) {
         this(serializer, defaultValue, producer, consumer, null);
     }
 
-    public TileDataParameter(DataSerializer<T> serializer, T defaultValue, ITileDataProducer<T, ? extends TileEntity> producer, ITileDataConsumer<T, ? extends TileEntity> consumer, ITileDataListener<T> listener) {
+    public TileDataParameter(DataSerializer<T> serializer, T defaultValue, Function<E, T> producer, @Nullable BiConsumer<E, T> consumer, @Nullable Consumer<T> listener) {
         this.value = defaultValue;
         this.serializer = serializer;
         this.valueProducer = producer;
@@ -39,11 +46,12 @@ public class TileDataParameter<T> {
         return serializer;
     }
 
-    public ITileDataProducer<T, ? extends TileEntity> getValueProducer() {
+    public Function<E, T> getValueProducer() {
         return valueProducer;
     }
 
-    public ITileDataConsumer<T, ? extends TileEntity> getValueConsumer() {
+    @Nullable
+    public BiConsumer<E, T> getValueConsumer() {
         return valueConsumer;
     }
 
@@ -51,7 +59,7 @@ public class TileDataParameter<T> {
         this.value = value;
 
         if (listener != null) {
-            listener.onChanged(this);
+            listener.accept(value);
         }
     }
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/IGrid.java

@@ -64,7 +64,7 @@ public interface IGrid {
 
     ItemHandlerBase getFilter();
 
-    TileDataParameter<Integer> getRedstoneModeConfig();
+    TileDataParameter<Integer, ?> getRedstoneModeConfig();
 
     InventoryCrafting getCraftingMatrix();
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/TileGrid.java

@@ -5,8 +5,6 @@ import com.raoulvdberge.refinedstorage.block.GridType;
 import com.raoulvdberge.refinedstorage.container.ContainerGrid;
 import com.raoulvdberge.refinedstorage.gui.grid.GuiGrid;
 import com.raoulvdberge.refinedstorage.tile.TileNode;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import net.minecraft.client.Minecraft;
 import net.minecraft.network.datasync.DataSerializers;
@@ -20,163 +18,83 @@ import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class TileGrid extends TileNode<NetworkNodeGrid> {
-    public static final TileDataParameter<Integer> VIEW_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileGrid>() {
-        @Override
-        public Integer getValue(TileGrid tile) {
-            return tile.getNode().getViewType();
+    public static final TileDataParameter<Integer, TileGrid> VIEW_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getViewType(), (t, v) -> {
+        if (NetworkNodeGrid.isValidViewType(v)) {
+            t.getNode().setViewType(v);
+            t.getNode().markDirty();
         }
-    }, new ITileDataConsumer<Integer, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidViewType(value)) {
-                tile.getNode().setViewType(value);
-                tile.getNode().markDirty();
-            }
+    }, p -> GuiGrid.markForSorting());
+    public static final TileDataParameter<Integer, TileGrid> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getSortingDirection(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSortingDirection(v)) {
+            t.getNode().setSortingDirection(v);
+            t.getNode().markDirty();
         }
-    }, parameter -> GuiGrid.markForSorting());
-
-    public static final TileDataParameter<Integer> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileGrid>() {
-        @Override
-        public Integer getValue(TileGrid tile) {
-            return tile.getNode().getSortingDirection();
+    }, p -> GuiGrid.markForSorting());
+    public static final TileDataParameter<Integer, TileGrid> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getSortingType(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSortingType(v)) {
+            t.getNode().setSortingType(v);
+            t.getNode().markDirty();
         }
-    }, new ITileDataConsumer<Integer, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSortingDirection(value)) {
-                tile.getNode().setSortingDirection(value);
-                tile.getNode().markDirty();
-            }
+    }, p -> GuiGrid.markForSorting());
+    public static final TileDataParameter<Integer, TileGrid> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getSearchBoxMode(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSearchBoxMode(v)) {
+            t.getNode().setSearchBoxMode(v);
+            t.getNode().markDirty();
         }
-    }, parameter -> GuiGrid.markForSorting());
-
-    public static final TileDataParameter<Integer> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileGrid>() {
-        @Override
-        public Integer getValue(TileGrid tile) {
-            return tile.getNode().getSortingType();
-        }
-    }, new ITileDataConsumer<Integer, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSortingType(value)) {
-                tile.getNode().setSortingType(value);
-                tile.getNode().markDirty();
-            }
-        }
-    }, parameter -> GuiGrid.markForSorting());
-
-    public static final TileDataParameter<Integer> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileGrid>() {
-        @Override
-        public Integer getValue(TileGrid tile) {
-            return tile.getNode().getSearchBoxMode();
-        }
-    }, new ITileDataConsumer<Integer, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSearchBoxMode(value)) {
-                tile.getNode().setSearchBoxMode(value);
-                tile.getNode().markDirty();
-            }
-        }
-    }, parameter -> {
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) {
-            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateSearchFieldFocus(parameter.getValue());
+            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateSearchFieldFocus(p);
         }
     });
-
-    public static final TileDataParameter<Integer> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileGrid>() {
-        @Override
-        public Integer getValue(TileGrid tile) {
-            return tile.getNode().getSize();
+    public static final TileDataParameter<Integer, TileGrid> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getSize(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSize(v)) {
+            t.getNode().setSize(v);
+            t.getNode().markDirty();
         }
-    }, new ITileDataConsumer<Integer, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSize(value)) {
-                tile.getNode().setSize(value);
-                tile.getNode().markDirty();
-            }
-        }
-    }, parameter -> {
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen != null) {
             Minecraft.getMinecraft().currentScreen.initGui();
         }
     });
-
-    public static final TileDataParameter<Integer> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TileGrid>() {
-        @Override
-        public Integer getValue(TileGrid tile) {
-            return tile.getNode().getTabSelected();
-        }
-    }, new ITileDataConsumer<Integer, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Integer value) {
-            tile.getNode().setTabSelected(value == tile.getNode().getTabSelected() ? -1 : value);
-            tile.getNode().markDirty();
-        }
-    }, parameter -> {
+    public static final TileDataParameter<Integer, TileGrid> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getNode().getTabSelected(), (t, v) -> {
+        t.getNode().setTabSelected(v == t.getNode().getTabSelected() ? -1 : v);
+        t.getNode().markDirty();
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) {
             ((GuiGrid) Minecraft.getMinecraft().currentScreen).markForSorting();
         }
     });
-
-    public static final TileDataParameter<Boolean> OREDICT_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileGrid>() {
-        @Override
-        public Boolean getValue(TileGrid tile) {
-            return tile.getNode().isOredictPattern();
-        }
-    }, new ITileDataConsumer<Boolean, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Boolean value) {
-            tile.getNode().setOredictPattern(value);
-            tile.getNode().markDirty();
-        }
-    }, parameter -> {
+    public static final TileDataParameter<Boolean, TileGrid> OREDICT_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isOredictPattern(), (t, v) -> {
+        t.getNode().setOredictPattern(v);
+        t.getNode().markDirty();
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) {
-            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateOredictPattern(parameter.getValue());
+            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateOredictPattern(p);
         }
     });
+    public static final TileDataParameter<Boolean, TileGrid> PROCESSING_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isProcessingPattern(), (t, v) -> {
+        t.getNode().setProcessingPattern(v);
+        t.getNode().markDirty();
 
-    public static final TileDataParameter<Boolean> PROCESSING_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileGrid>() {
-        @Override
-        public Boolean getValue(TileGrid tile) {
-            return tile.getNode().isProcessingPattern();
-        }
-    }, new ITileDataConsumer<Boolean, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Boolean value) {
-            tile.getNode().setProcessingPattern(value);
-            tile.getNode().markDirty();
+        t.getNode().onPatternMatrixClear();
 
-            tile.getNode().onPatternMatrixClear();
-
-            tile.world.getMinecraftServer().getPlayerList().getPlayers().stream()
-                .filter(player -> player.openContainer instanceof ContainerGrid && ((ContainerGrid) player.openContainer).getTile() != null && ((ContainerGrid) player.openContainer).getTile().getPos().equals(tile.getPos()))
-                .forEach(player -> {
-                    ((ContainerGrid) player.openContainer).initSlots();
-                    ((ContainerGrid) player.openContainer).sendAllSlots();
-                });
-        }
-    }, parameter -> {
+        t.world.getMinecraftServer().getPlayerList().getPlayers().stream()
+            .filter(player -> player.openContainer instanceof ContainerGrid && ((ContainerGrid) player.openContainer).getTile() != null && ((ContainerGrid) player.openContainer).getTile().getPos().equals(t.getPos()))
+            .forEach(player -> {
+                ((ContainerGrid) player.openContainer).initSlots();
+                ((ContainerGrid) player.openContainer).sendAllSlots();
+            });
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen != null) {
             Minecraft.getMinecraft().currentScreen.initGui();
         }
     });
-
-    public static final TileDataParameter<Boolean> BLOCKING_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, new ITileDataProducer<Boolean, TileGrid>() {
-        @Override
-        public Boolean getValue(TileGrid tile) {
-            return tile.getNode().isBlockingPattern();
-        }
-    }, new ITileDataConsumer<Boolean, TileGrid>() {
-        @Override
-        public void setValue(TileGrid tile, Boolean value) {
-            tile.getNode().setBlockingPattern(value);
-            tile.getNode().markDirty();
-        }
-    }, parameter -> {
+    public static final TileDataParameter<Boolean, TileGrid> BLOCKING_PATTERN = new TileDataParameter<>(DataSerializers.BOOLEAN, false, t -> t.getNode().isBlockingPattern(), (t, v) -> {
+        t.getNode().setBlockingPattern(v);
+        t.getNode().markDirty();
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) {
-            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateBlockingPattern(parameter.getValue());
+            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateBlockingPattern(p);
         }
     });
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/WirelessFluidGrid.java

@@ -169,7 +169,7 @@ public class WirelessFluidGrid implements IGrid {
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeConfig() {
+    public TileDataParameter<Integer, ?> getRedstoneModeConfig() {
         return null;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/WirelessGrid.java

@@ -203,7 +203,7 @@ public class WirelessGrid implements IGrid {
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeConfig() {
+    public TileDataParameter<Integer, ?> getRedstoneModeConfig() {
         return null;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/PortableGrid.java

@@ -305,7 +305,7 @@ public class PortableGrid implements IGrid, IPortableGrid {
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeConfig() {
+    public TileDataParameter<Integer, ?> getRedstoneModeConfig() {
         return null;
     }
 

src/main/java/com/raoulvdberge/refinedstorage/tile/grid/portable/TilePortableGrid.java

@@ -29,8 +29,6 @@ import com.raoulvdberge.refinedstorage.item.filter.FilterTab;
 import com.raoulvdberge.refinedstorage.tile.TileBase;
 import com.raoulvdberge.refinedstorage.tile.config.IRedstoneConfigurable;
 import com.raoulvdberge.refinedstorage.tile.config.RedstoneMode;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataConsumer;
-import com.raoulvdberge.refinedstorage.tile.data.ITileDataProducer;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataManager;
 import com.raoulvdberge.refinedstorage.tile.data.TileDataParameter;
 import com.raoulvdberge.refinedstorage.tile.grid.IGrid;
@@ -54,100 +52,49 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid, IRedstoneConfigurable {
-    public static final TileDataParameter<Integer> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TilePortableGrid>() {
-        @Override
-        public Integer getValue(TilePortableGrid tile) {
-            return tile.energyStorage.getEnergyStored();
+    public static final TileDataParameter<Integer, TilePortableGrid> REDSTONE_MODE = RedstoneMode.createParameter();
+    public static final TileDataParameter<Integer, TilePortableGrid> ENERGY_STORED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.energyStorage.getEnergyStored());
+    public static final TileDataParameter<Integer, TilePortableGrid> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getSortingDirection(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSortingDirection(v)) {
+            t.setSortingDirection(v);
+            t.markDirty();
         }
-    });
-
-    public static final TileDataParameter<Integer> SORTING_DIRECTION = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TilePortableGrid>() {
-        @Override
-        public Integer getValue(TilePortableGrid tile) {
-            return tile.getSortingDirection();
+    }, p -> GuiGrid.markForSorting());
+    public static final TileDataParameter<Integer, TilePortableGrid> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getSortingType(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSortingType(v)) {
+            t.setSortingType(v);
+            t.markDirty();
         }
-    }, new ITileDataConsumer<Integer, TilePortableGrid>() {
-        @Override
-        public void setValue(TilePortableGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSortingDirection(value)) {
-                tile.setSortingDirection(value);
-                tile.markDirty();
-            }
+    }, p -> GuiGrid.markForSorting());
+    public static final TileDataParameter<Integer, TilePortableGrid> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getSearchBoxMode(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSearchBoxMode(v)) {
+            t.setSearchBoxMode(v);
+            t.markDirty();
         }
-    }, parameter -> GuiGrid.markForSorting());
-
-    public static final TileDataParameter<Integer> SORTING_TYPE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TilePortableGrid>() {
-        @Override
-        public Integer getValue(TilePortableGrid tile) {
-            return tile.getSortingType();
-        }
-    }, new ITileDataConsumer<Integer, TilePortableGrid>() {
-        @Override
-        public void setValue(TilePortableGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSortingType(value)) {
-                tile.setSortingType(value);
-                tile.markDirty();
-            }
-        }
-    }, parameter -> GuiGrid.markForSorting());
-
-    public static final TileDataParameter<Integer> SEARCH_BOX_MODE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TilePortableGrid>() {
-        @Override
-        public Integer getValue(TilePortableGrid tile) {
-            return tile.getSearchBoxMode();
-        }
-    }, new ITileDataConsumer<Integer, TilePortableGrid>() {
-        @Override
-        public void setValue(TilePortableGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSearchBoxMode(value)) {
-                tile.setSearchBoxMode(value);
-                tile.markDirty();
-            }
-        }
-    }, parameter -> {
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) {
-            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateSearchFieldFocus(parameter.getValue());
+            ((GuiGrid) Minecraft.getMinecraft().currentScreen).updateSearchFieldFocus(p);
         }
     });
-
-    public static final TileDataParameter<Integer> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TilePortableGrid>() {
-        @Override
-        public Integer getValue(TilePortableGrid tile) {
-            return tile.getSize();
+    public static final TileDataParameter<Integer, TilePortableGrid> SIZE = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getSize(), (t, v) -> {
+        if (NetworkNodeGrid.isValidSize(v)) {
+            t.setSize(v);
+            t.markDirty();
         }
-    }, new ITileDataConsumer<Integer, TilePortableGrid>() {
-        @Override
-        public void setValue(TilePortableGrid tile, Integer value) {
-            if (NetworkNodeGrid.isValidSize(value)) {
-                tile.setSize(value);
-                tile.markDirty();
-            }
-        }
-    }, parameter -> {
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen != null) {
             Minecraft.getMinecraft().currentScreen.initGui();
         }
     });
-
-    public static final TileDataParameter<Integer> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, new ITileDataProducer<Integer, TilePortableGrid>() {
-        @Override
-        public Integer getValue(TilePortableGrid tile) {
-            return tile.getTabSelected();
-        }
-    }, new ITileDataConsumer<Integer, TilePortableGrid>() {
-        @Override
-        public void setValue(TilePortableGrid tile, Integer value) {
-            tile.setTabSelected(value == tile.getTabSelected() ? -1 : value);
-            tile.markDirty();
-        }
-    }, parameter -> {
+    public static final TileDataParameter<Integer, TilePortableGrid> TAB_SELECTED = new TileDataParameter<>(DataSerializers.VARINT, 0, t -> t.getTabSelected(), (t, v) -> {
+        t.setTabSelected(v == t.getTabSelected() ? -1 : v);
+        t.markDirty();
+    }, p -> {
         if (Minecraft.getMinecraft().currentScreen instanceof GuiGrid) {
             ((GuiGrid) Minecraft.getMinecraft().currentScreen).markForSorting();
         }
     });
 
-    public static final TileDataParameter<Integer> REDSTONE_MODE = RedstoneMode.createParameter();
-
     private static final String NBT_ENERGY = "Energy";
     private static final String NBT_DISK_STATE = "DiskState";
     private static final String NBT_CONNECTED = "Connected";
@@ -225,13 +172,13 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     private boolean connected;
 
     public TilePortableGrid() {
+        dataManager.addWatchedParameter(REDSTONE_MODE);
         dataManager.addWatchedParameter(ENERGY_STORED);
         dataManager.addWatchedParameter(SORTING_DIRECTION);
         dataManager.addWatchedParameter(SORTING_TYPE);
         dataManager.addWatchedParameter(SEARCH_BOX_MODE);
         dataManager.addWatchedParameter(SIZE);
         dataManager.addWatchedParameter(TAB_SELECTED);
-        dataManager.addWatchedParameter(REDSTONE_MODE);
     }
 
     public PortableGridDiskState getDiskState() {
@@ -420,7 +367,7 @@ public class TilePortableGrid extends TileBase implements IGrid, IPortableGrid,
     }
 
     @Override
-    public TileDataParameter<Integer> getRedstoneModeConfig() {
+    public TileDataParameter<Integer, TilePortableGrid> getRedstoneModeConfig() {
         return REDSTONE_MODE;
     }