Remove network node equals/hashCode requirement.

src/main/java/com/refinedmods/refinedstorage/api/IRSAPI.java

@@ -10,7 +10,6 @@ import com.refinedmods.refinedstorage.api.autocrafting.task.ICraftingTaskRegistr
 import com.refinedmods.refinedstorage.api.network.INetworkManager;
 import com.refinedmods.refinedstorage.api.network.grid.ICraftingGridBehavior;
 import com.refinedmods.refinedstorage.api.network.grid.IGridManager;
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNodeManager;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNodeRegistry;
 import com.refinedmods.refinedstorage.api.storage.StorageType;
@@ -218,17 +217,4 @@ public interface IRSAPI {
      * @return a hashcode for the given stack
      */
     int getFluidStackHashCode(FluidStack stack);
-
-    /**
-     * @param node the node
-     * @return the hashcode
-     */
-    int getNetworkNodeHashCode(INetworkNode node);
-
-    /**
-     * @param left  the first network node
-     * @param right the second network node
-     * @return true if the two network nodes are equal, false otherwise
-     */
-    boolean isNetworkNodeEqual(INetworkNode left, Object right);
 }

src/main/java/com/refinedmods/refinedstorage/api/network/INetworkNodeGraph.java

@@ -1,6 +1,5 @@
 package com.refinedmods.refinedstorage.api.network;
 
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.util.Action;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
@@ -30,9 +29,9 @@ public interface INetworkNodeGraph {
     void runActionWhenPossible(Consumer<INetwork> handler);
 
     /**
-     * @return a collection of all connected nodes
+     * @return a collection of all connected entries
      */
-    Collection<INetworkNode> all();
+    Collection<INetworkNodeGraphEntry> all();
 
     /**
      * @param listener the listener

src/main/java/com/refinedmods/refinedstorage/api/network/INetworkNodeGraphEntry.java

@@ -0,0 +1,11 @@
+package com.refinedmods.refinedstorage.api.network;
+
+import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
+
+/**
+ * An entry in the network graph.
+ * Implementors MUST implement equals and hashCode.
+ */
+public interface INetworkNodeGraphEntry {
+    INetworkNode getNode();
+}

src/main/java/com/refinedmods/refinedstorage/apiimpl/API.java

@@ -12,7 +12,6 @@ import com.refinedmods.refinedstorage.api.autocrafting.task.ICraftingTaskRegistr
 import com.refinedmods.refinedstorage.api.network.INetworkManager;
 import com.refinedmods.refinedstorage.api.network.grid.ICraftingGridBehavior;
 import com.refinedmods.refinedstorage.api.network.grid.IGridManager;
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNodeManager;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNodeRegistry;
 import com.refinedmods.refinedstorage.api.storage.StorageType;
@@ -312,31 +311,4 @@ public class API implements IRSAPI {
 
         return result;
     }
-
-    @Override
-    public int getNetworkNodeHashCode(INetworkNode node) {
-        int result = node.getPos().hashCode();
-        result = 31 * result + node.getWorld().func_234923_W_().hashCode();
-
-        return result;
-    }
-
-    @Override
-    public boolean isNetworkNodeEqual(INetworkNode left, Object right) {
-        if (!(right instanceof INetworkNode)) {
-            return false;
-        }
-
-        if (left == right) {
-            return true;
-        }
-
-        INetworkNode rightNode = (INetworkNode) right;
-
-        if (left.getWorld().func_234923_W_() != rightNode.getWorld().func_234923_W_()) {
-            return false;
-        }
-
-        return left.getPos().equals(rightNode.getPos());
-    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/autocrafting/CraftingManager.java

@@ -6,7 +6,7 @@ import com.refinedmods.refinedstorage.api.autocrafting.ICraftingPatternContainer
 import com.refinedmods.refinedstorage.api.autocrafting.craftingmonitor.ICraftingMonitorListener;
 import com.refinedmods.refinedstorage.api.autocrafting.task.*;
 import com.refinedmods.refinedstorage.api.network.INetwork;
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.util.IComparer;
 import com.refinedmods.refinedstorage.apiimpl.API;
 import com.refinedmods.refinedstorage.apiimpl.autocrafting.task.v6.calculator.CalculationResult;
@@ -393,9 +393,9 @@ public class CraftingManager implements ICraftingManager {
     private List<ICraftingPatternContainer> getContainers() {
         List<ICraftingPatternContainer> containers = new ArrayList<>();
 
-        for (INetworkNode node : network.getNodeGraph().all()) {
+        for (INetworkNodeGraphEntry entry : network.getNodeGraph().all()) {
-            if (node instanceof ICraftingPatternContainer && node.isActive()) {
+            if (entry.getNode() instanceof ICraftingPatternContainer && entry.getNode().isActive()) {
-                containers.add((ICraftingPatternContainer) node);
+                containers.add((ICraftingPatternContainer) entry.getNode());
             }
         }
 

src/main/java/com/refinedmods/refinedstorage/apiimpl/autocrafting/InvalidCraftingPattern.java

@@ -50,41 +50,41 @@ public class InvalidCraftingPattern implements ICraftingPattern {
 
     @Override
     public List<NonNullList<ItemStack>> getInputs() {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public NonNullList<ItemStack> getOutputs() {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public ItemStack getOutput(NonNullList<ItemStack> took) {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public NonNullList<ItemStack> getByproducts() {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public NonNullList<ItemStack> getByproducts(NonNullList<ItemStack> took) {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public List<NonNullList<FluidStack>> getFluidInputs() {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public NonNullList<FluidStack> getFluidOutputs() {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 
     @Override
     public ResourceLocation getCraftingTaskFactoryId() {
-        throw new IllegalStateException(EXCEPTION_MESSAGE);
+        throw new UnsupportedOperationException(EXCEPTION_MESSAGE);
     }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/Network.java

@@ -5,11 +5,11 @@ import com.refinedmods.refinedstorage.api.autocrafting.ICraftingManager;
 import com.refinedmods.refinedstorage.api.autocrafting.task.ICraftingTask;
 import com.refinedmods.refinedstorage.api.network.INetwork;
 import com.refinedmods.refinedstorage.api.network.INetworkNodeGraph;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.network.NetworkType;
 import com.refinedmods.refinedstorage.api.network.grid.handler.IFluidGridHandler;
 import com.refinedmods.refinedstorage.api.network.grid.handler.IItemGridHandler;
 import com.refinedmods.refinedstorage.api.network.item.INetworkItemManager;
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.network.security.ISecurityManager;
 import com.refinedmods.refinedstorage.api.storage.AccessType;
 import com.refinedmods.refinedstorage.api.storage.IStorage;
@@ -564,9 +564,9 @@ public class Network implements INetwork, IRedstoneConfigurable {
 
         int usage = RS.SERVER_CONFIG.getController().getBaseUsage();
 
-        for (INetworkNode node : nodeGraph.all()) {
+        for (INetworkNodeGraphEntry entry : nodeGraph.all()) {
-            if (node.isActive()) {
+            if (entry.getNode().isActive()) {
-                usage += node.getEnergyUsage();
+                usage += entry.getNode().getEnergyUsage();
             }
         }
 

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/NetworkNodeGraph.java

@@ -1,10 +1,7 @@
 package com.refinedmods.refinedstorage.apiimpl.network;
 
 import com.google.common.collect.Sets;
-import com.refinedmods.refinedstorage.api.network.INetwork;
+import com.refinedmods.refinedstorage.api.network.*;
-import com.refinedmods.refinedstorage.api.network.INetworkNodeGraph;
-import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphListener;
-import com.refinedmods.refinedstorage.api.network.INetworkNodeVisitor;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.util.Action;
 import com.refinedmods.refinedstorage.util.NetworkUtils;
@@ -20,7 +17,7 @@ import java.util.function.Consumer;
 
 public class NetworkNodeGraph implements INetworkNodeGraph {
     private final INetwork network;
-    private Set<INetworkNode> nodes = Sets.newConcurrentHashSet();
+    private Set<INetworkNodeGraphEntry> entries = Sets.newConcurrentHashSet();
     private final List<INetworkNodeGraphListener> listeners = new LinkedList<>();
 
     private final Set<Consumer<INetwork>> actions = new HashSet<>();
@@ -47,21 +44,21 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
             currentVisitor.visit(operator);
         }
 
-        this.nodes = operator.foundNodes;
+        this.entries = operator.foundNodes;
 
         if (action == Action.PERFORM) {
-            for (INetworkNode node : operator.newNodes) {
+            for (INetworkNodeGraphEntry entry : operator.newEntries) {
-                node.onConnected(network);
+                entry.getNode().onConnected(network);
             }
 
-            for (INetworkNode node : operator.previousNodes) {
+            for (INetworkNodeGraphEntry entry : operator.previousEntries) {
-                node.onDisconnected(network);
+                entry.getNode().onDisconnected(network);
             }
 
             actions.forEach(h -> h.accept(network));
             actions.clear();
 
-            if (!operator.newNodes.isEmpty() || !operator.previousNodes.isEmpty()) {
+            if (!operator.newEntries.isEmpty() || !operator.previousEntries.isEmpty()) {
                 listeners.forEach(INetworkNodeGraphListener::onChanged);
             }
         }
@@ -79,8 +76,8 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
     }
 
     @Override
-    public Collection<INetworkNode> all() {
+    public Collection<INetworkNodeGraphEntry> all() {
-        return nodes;
+        return entries;
     }
 
     @Override
@@ -90,8 +87,8 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
 
     @Override
     public void disconnectAll() {
-        nodes.forEach(n -> n.onDisconnected(network));
+        entries.forEach(entry -> entry.getNode().onDisconnected(network));
-        nodes.clear();
+        entries.clear();
 
         listeners.forEach(INetworkNodeGraphListener::onChanged);
     }
@@ -101,10 +98,10 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
     }
 
     private class Operator implements INetworkNodeVisitor.Operator {
-        private final Set<INetworkNode> foundNodes = Sets.newConcurrentHashSet(); // All scanned nodes
+        private final Set<INetworkNodeGraphEntry> foundNodes = Sets.newConcurrentHashSet(); // All scanned entries
 
-        private final Set<INetworkNode> newNodes = Sets.newConcurrentHashSet(); // All scanned new nodes, that didn't appear in the list before
+        private final Set<INetworkNodeGraphEntry> newEntries = Sets.newConcurrentHashSet(); // All scanned new entries, that didn't appear in the list before
-        private final Set<INetworkNode> previousNodes = Sets.newConcurrentHashSet(nodes); // All unscanned nodes (nodes that were in the previous list, but not in the new list)
+        private final Set<INetworkNodeGraphEntry> previousEntries = Sets.newConcurrentHashSet(entries); // All unscanned entries (entries that were in the previous list, but not in the new list)
 
         private final Queue<Visitor> toCheck = new ArrayDeque<>();
 
@@ -119,8 +116,9 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
             TileEntity tile = world.getTileEntity(pos);
 
             INetworkNode otherNode = NetworkUtils.getNodeFromTile(tile);
-
             if (otherNode != null) {
+                NetworkNodeGraphEntry otherNodeItem = new NetworkNodeGraphEntry(otherNode);
+
                 if (otherNode.getNetwork() != null && !otherNode.getNetwork().equals(network)) {
                     if (action == Action.PERFORM) {
                         dropConflictingBlock(world, pos);
@@ -129,15 +127,15 @@ public class NetworkNodeGraph implements INetworkNodeGraph {
                     return;
                 }
 
-                if (foundNodes.add(otherNode)) {
+                if (foundNodes.add(otherNodeItem)) {
-                    if (!nodes.contains(otherNode)) {
+                    if (!entries.contains(otherNodeItem)) {
                         // We can't let the node connect immediately
                         // We can only let the node connect AFTER the nodes list has changed in the graph
                         // This is so that storage nodes can refresh the item/fluid cache, and the item/fluid cache will notice it then (otherwise not)
-                        newNodes.add(otherNode);
+                        newEntries.add(otherNodeItem);
                     }
 
-                    previousNodes.remove(otherNode);
+                    previousEntries.remove(otherNodeItem);
 
                     toCheck.add(new Visitor(otherNode, world, pos, side, tile));
                 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/NetworkNodeGraphEntry.java

@@ -0,0 +1,42 @@
+package com.refinedmods.refinedstorage.apiimpl.network;
+
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
+import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
+
+public class NetworkNodeGraphEntry implements INetworkNodeGraphEntry {
+    private final INetworkNode node;
+
+    public NetworkNodeGraphEntry(INetworkNode node) {
+        this.node = node;
+    }
+
+    @Override
+    public INetworkNode getNode() {
+        return node;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (!(other instanceof NetworkNodeGraphEntry)) {
+            return false;
+        }
+        if (this == other) {
+            return true;
+        }
+
+        NetworkNodeGraphEntry otherItem = (NetworkNodeGraphEntry) other;
+
+        if (node.getWorld().func_234923_W_() != otherItem.node.getWorld().func_234923_W_()) {
+            return false;
+        }
+
+        return node.getPos().equals(otherItem.node.getPos());
+    }
+
+    @Override
+    public int hashCode() {
+        int result = node.getPos().hashCode();
+        result = 31 * result + node.getWorld().func_234923_W_().hashCode();
+        return result;
+    }
+}

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/item/NetworkItemManager.java

@@ -1,6 +1,7 @@
 package com.refinedmods.refinedstorage.apiimpl.network.item;
 
 import com.refinedmods.refinedstorage.api.network.INetwork;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.network.IWirelessTransmitter;
 import com.refinedmods.refinedstorage.api.network.item.INetworkItem;
 import com.refinedmods.refinedstorage.api.network.item.INetworkItemManager;
@@ -26,7 +27,9 @@ public class NetworkItemManager implements INetworkItemManager {
     public void open(PlayerEntity player, ItemStack stack, int slotId) {
         boolean inRange = false;
 
-        for (INetworkNode node : network.getNodeGraph().all()) {
+        for (INetworkNodeGraphEntry entry : network.getNodeGraph().all()) {
+            INetworkNode node = entry.getNode();
+
             if (node instanceof IWirelessTransmitter &&
                 network.canRun() &&
                 node.isActive() &&

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/NetworkNode.java

@@ -279,14 +279,4 @@ public abstract class NetworkNode implements INetworkNode, INetworkNodeVisitor {
     public UUID getOwner() {
         return owner;
     }
-
-    @Override
-    public boolean equals(Object o) {
-        return API.instance().isNetworkNodeEqual(this, o);
-    }
-
-    @Override
-    public int hashCode() {
-        return API.instance().getNetworkNodeHashCode(this);
-    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/RootNetworkNode.java

@@ -3,7 +3,6 @@ package com.refinedmods.refinedstorage.apiimpl.network.node;
 import com.refinedmods.refinedstorage.api.network.INetwork;
 import com.refinedmods.refinedstorage.api.network.INetworkNodeVisitor;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
-import com.refinedmods.refinedstorage.apiimpl.API;
 import net.minecraft.block.BlockState;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
@@ -109,14 +108,4 @@ public class RootNetworkNode implements INetworkNode, INetworkNodeVisitor {
             operator.apply(world, pos.offset(facing), facing.getOpposite());
         }
     }
-
-    @Override
-    public boolean equals(Object o) {
-        return API.instance().isNetworkNodeEqual(this, o);
-    }
-
-    @Override
-    public int hashCode() {
-        return API.instance().getNetworkNodeHashCode(this);
-    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/security/SecurityManager.java

@@ -1,7 +1,7 @@
 package com.refinedmods.refinedstorage.apiimpl.network.security;
 
 import com.refinedmods.refinedstorage.api.network.INetwork;
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.network.security.ISecurityCard;
 import com.refinedmods.refinedstorage.api.network.security.ISecurityCardContainer;
 import com.refinedmods.refinedstorage.api.network.security.ISecurityManager;
@@ -48,9 +48,9 @@ public class SecurityManager implements ISecurityManager {
         this.cards.clear();
         this.globalCard = null;
 
-        for (INetworkNode node : network.getNodeGraph().all()) {
+        for (INetworkNodeGraphEntry entry : network.getNodeGraph().all()) {
-            if (node instanceof ISecurityCardContainer && node.isActive()) {
+            if (entry.getNode() instanceof ISecurityCardContainer && entry.getNode().isActive()) {
-                ISecurityCardContainer container = (ISecurityCardContainer) node;
+                ISecurityCardContainer container = (ISecurityCardContainer) entry.getNode();
 
                 for (ISecurityCard card : container.getCards()) {
                     if (card.getOwner() == null) {

src/main/java/com/refinedmods/refinedstorage/apiimpl/storage/cache/FluidStorageCache.java

@@ -1,6 +1,7 @@
 package com.refinedmods.refinedstorage.apiimpl.storage.cache;
 
 import com.refinedmods.refinedstorage.api.network.INetwork;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.storage.AccessType;
 import com.refinedmods.refinedstorage.api.storage.IStorage;
 import com.refinedmods.refinedstorage.api.storage.IStorageProvider;
@@ -44,7 +45,10 @@ public class FluidStorageCache implements IStorageCache<FluidStack> {
 
         storages.clear();
 
-        network.getNodeGraph().all().stream()
+        network.getNodeGraph()
+            .all()
+            .stream()
+            .map(INetworkNodeGraphEntry::getNode)
             .filter(node -> node.isActive() && node instanceof IStorageProvider)
             .forEach(node -> ((IStorageProvider) node).addFluidStorages(storages));
 

src/main/java/com/refinedmods/refinedstorage/apiimpl/storage/cache/ItemStorageCache.java

@@ -1,6 +1,7 @@
 package com.refinedmods.refinedstorage.apiimpl.storage.cache;
 
 import com.refinedmods.refinedstorage.api.network.INetwork;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.storage.AccessType;
 import com.refinedmods.refinedstorage.api.storage.IStorage;
 import com.refinedmods.refinedstorage.api.storage.IStorageProvider;
@@ -44,7 +45,10 @@ public class ItemStorageCache implements IStorageCache<ItemStack> {
 
         storages.clear();
 
-        network.getNodeGraph().all().stream()
+        network.getNodeGraph()
+            .all()
+            .stream()
+            .map(INetworkNodeGraphEntry::getNode)
             .filter(node -> node.isActive() && node instanceof IStorageProvider)
             .forEach(node -> ((IStorageProvider) node).addItemStorages(storages));
 

src/main/java/com/refinedmods/refinedstorage/tile/ControllerTile.java

@@ -3,8 +3,8 @@ package com.refinedmods.refinedstorage.tile;
 import com.refinedmods.refinedstorage.RSTiles;
 import com.refinedmods.refinedstorage.api.network.INetwork;
 import com.refinedmods.refinedstorage.api.network.INetworkManager;
+import com.refinedmods.refinedstorage.api.network.INetworkNodeGraphEntry;
 import com.refinedmods.refinedstorage.api.network.NetworkType;
-import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.network.node.INetworkNodeProxy;
 import com.refinedmods.refinedstorage.apiimpl.API;
 import com.refinedmods.refinedstorage.apiimpl.network.Network;
@@ -165,15 +165,15 @@ public class ControllerTile extends BaseTile implements INetworkNodeProxy<RootNe
     private static List<ClientNode> collectClientNodes(ControllerTile tile) {
         List<ClientNode> nodes = new ArrayList<>();
 
-        for (INetworkNode node : tile.getNetwork().getNodeGraph().all()) {
+        for (INetworkNodeGraphEntry entry : tile.getNetwork().getNodeGraph().all()) {
-            if (node.isActive()) {
+            if (entry.getNode().isActive()) {
-                ItemStack stack = node.getItemStack();
+                ItemStack stack = entry.getNode().getItemStack();
 
                 if (stack.isEmpty()) {
                     continue;
                 }
 
-                ClientNode clientNode = new ClientNode(stack, 1, node.getEnergyUsage());
+                ClientNode clientNode = new ClientNode(stack, 1, entry.getNode().getEnergyUsage());
 
                 if (nodes.contains(clientNode)) {
                     ClientNode other = nodes.get(nodes.indexOf(clientNode));

src/main/java/com/refinedmods/refinedstorage/util/NetworkUtils.java

@@ -19,6 +19,9 @@ import javax.annotation.Nullable;
 import java.util.function.Consumer;
 
 public class NetworkUtils {
+    private NetworkUtils() {
+    }
+
     @Nullable
     public static INetworkNode getNodeFromTile(@Nullable TileEntity tile) {
         if (tile != null) {