playing 'round with jgrapht

src/Test.java

@@ -5,7 +5,15 @@ import items.Database;
 import items.Item;
 import items.Recipe;
 import items.Utils;
+import org.jgrapht.Graph;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.jgrapht.graph.EdgeReversedGraph;
+import org.jgrapht.nio.Attribute;
+import org.jgrapht.nio.DefaultAttribute;
+import org.jgrapht.nio.dot.DOTExporter;
 
+import java.io.File;
+import java.util.HashMap;
 import java.util.Map;
 
 public class Test {
@@ -25,16 +33,30 @@ public class Test {
         String json3 = om.writeValueAsString(Recipe.getInputs(rawOnly));
         System.out.println(json2);
         System.out.println(json3);
-        System.out.println(om.writeValueAsString(Utils.getRawOnly(Database.AdaptiveControlUnit.getRecipe().getTotalRequirements())));
+        Item ACU = Database.AdaptiveControlUnit;
-        System.out.println(om.writeValueAsString(Database.AdaptiveControlUnit.getRecipe().getTotalRequirements()));
+        System.out.println(om.writeValueAsString(Utils.getRawOnly(ACU.getRecipe().getTotalRequirements())));
+        System.out.println(om.writeValueAsString(ACU.getRecipe().getTotalRequirements()));
 
         System.out.println();
-        System.out.println(om.writeValueAsString(Database.AdaptiveControlUnit));
+        System.out.println(om.writeValueAsString(ACU));
-        System.out.println(Database.AdaptiveControlUnit.getProductionRate());
+        System.out.println(ACU.getProductionRate());
         System.out.println("total requirements for ACU");
-        System.out.println(om.writeValueAsString(Utils.shorten(Database.AdaptiveControlUnit.getRecipe().getTotalRequirements())));
+        System.out.println(om.writeValueAsString(Utils.shorten(ACU.getRecipe().getTotalRequirements())));
         //System.out.println(Database.AdaptiveControlUnit.getRecipe().getRequirementRates(Database.AdaptiveControlUnit));
         System.out.println("requirement rate for ACU");
-        System.out.println(om.writeValueAsString(Utils.shorten(Database.AdaptiveControlUnit.getRecipe().getRequirementRates(Database.AdaptiveControlUnit))));
+        System.out.println(om.writeValueAsString(Utils.shorten(ACU.getRecipe().getRequirementRates(ACU))));
+
+        Graph<Item, DefaultWeightedEdge> x = ACU.getRecipe().buildGraph(ACU);
+        DOTExporter<Item, DefaultWeightedEdge> de = new DOTExporter<>(Utils::dotID);
+        de.setEdgeAttributeProvider(defaultWeightedEdge -> {
+            Map<String, Attribute> m = new HashMap<>();
+            m.put("label", DefaultAttribute.createAttribute(x.getEdgeWeight(defaultWeightedEdge)));
+            return m;
+        });
+        de.exportGraph(x, new File("acu.dot"));
+        de.exportGraph(new EdgeReversedGraph<>(x), new File("acu2.dot"));
+
+        Utils.fixSums(ACU, x);
+        de.exportGraph(x, new File("acu3.dot"));
     }
 }

src/items/Item.java

@@ -10,6 +10,7 @@ public class Item {
     private String name;
     private Set<Recipe> recipes;
     private Recipe preference = null;
+    public int sum = 0;
 
     protected Item(String name, Set<Recipe> recipes) {
         this.name = name;
@@ -32,9 +33,9 @@ public class Item {
         add(recipe, 1);
     }
 
-    public void add(Recipe recipe, int amount) {
+    public void add(Recipe recipe, int output) {
         recipes.add(recipe);
-        recipe.checkOutput(this, amount);
+        recipe.checkOutput(this, output);
     }
 
     public String getName() {

src/items/Recipe.java

@@ -2,10 +2,13 @@ package items;
 
 import items.requirements.RateAccumulator;
 import items.requirements.TotalAccumulator;
+import org.jgrapht.Graph;
+import org.jgrapht.Graphs;
+import org.jgrapht.graph.DefaultDirectedWeightedGraph;
+import org.jgrapht.graph.DefaultWeightedEdge;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 public class Recipe {
     private Map<Item, Integer> inputs;
@@ -25,9 +28,9 @@ public class Recipe {
         this.isHandCraftable = isHandCraftable;
     }
 
-    public Recipe(int duration, Item input, int amount) {
+    public Recipe(int duration, Item item, int input) {
         this(duration);
-        addInput(input, amount);
+        addInput(item, input);
     }
 
     public Recipe(int duration, Map<Item, Integer> inputs, Map<Item, Integer> outputs) {
@@ -95,7 +98,7 @@ public class Recipe {
         return production / duration;
     }
 
-    public Map<Item, Float> getRequirementRates(Item item){
+    public Map<Item, Float> getRequirementRates(Item item) {
         float rate = getProductionRate(item);
         return new RateAccumulator(this, item).accumulate();
     }
@@ -103,4 +106,22 @@ public class Recipe {
     public Map<Item, Integer> getInputs() {
         return inputs;
     }
+
+    public Graph<Item, DefaultWeightedEdge> buildGraph(Item target) {
+        Graph<Item, DefaultWeightedEdge> graph = new DefaultDirectedWeightedGraph<>(DefaultWeightedEdge.class);
+        graph.addVertex(target);
+        target.sum +=1;
+        inputs.forEach((item, integer) -> {
+            graph.addVertex(item);
+            graph.addEdge(item, target);
+            graph.setEdgeWeight(item, target, integer);
+
+            Graph<Item, DefaultWeightedEdge> g = item.getRecipe().buildGraph(item);
+            Graphs.addGraph(graph, g);
+        });
+
+
+        return graph;
+    }
+
 }

src/items/Utils.java

@@ -1,5 +1,15 @@
 package items;
 
+import org.jgrapht.Graph;
+import org.jgrapht.event.ConnectedComponentTraversalEvent;
+import org.jgrapht.event.EdgeTraversalEvent;
+import org.jgrapht.event.TraversalListener;
+import org.jgrapht.event.VertexTraversalEvent;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.jgrapht.graph.EdgeReversedGraph;
+import org.jgrapht.traverse.DepthFirstIterator;
+import org.jgrapht.traverse.GraphIterator;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -18,4 +28,50 @@ public class Utils {
         totals.forEach((item, e) -> shortend.put(item.getName(), e));
         return shortend;
     }
+
+    public static String dotID(Item item){
+        String name = item.getName();// +"_"+item.sum+"__"+item.getProductionRate();
+        name = name.replace(" ","").replace(".","");
+        return name;
+    }
+    public static void fixSums(Item target, Graph<Item, DefaultWeightedEdge> graph) {
+        System.err.println(target);
+        EdgeReversedGraph<Item, DefaultWeightedEdge> inverse = new EdgeReversedGraph<>(graph);
+
+        GraphIterator<Item, DefaultWeightedEdge> iterator = new DepthFirstIterator<>(inverse, target);
+        iterator.addTraversalListener(new TraversalListener<Item, DefaultWeightedEdge>() {
+            @Override
+            public void connectedComponentFinished(ConnectedComponentTraversalEvent e) {
+                System.out.println("\tconnectedComponentFinished: " + e);
+            }
+
+            @Override
+            public void connectedComponentStarted(ConnectedComponentTraversalEvent e) {
+                System.out.println("\tconnectedComponentStarted: " + e);
+
+            }
+
+            @Override
+            public void edgeTraversed(EdgeTraversalEvent<DefaultWeightedEdge> e) {
+                System.out.println("\tedgeTraversed: " + e + "---> " + e.getEdge());
+
+            }
+
+            @Override
+            public void vertexTraversed(VertexTraversalEvent<Item> e) {
+                System.out.println("\tvertexTraversed: " + e + "---> " + e.getVertex().getName());
+
+            }
+
+            @Override
+            public void vertexFinished(VertexTraversalEvent<Item> e) {
+                System.out.println("\tvertexFinished: " + e);
+
+            }
+        });
+        while (iterator.hasNext()){
+            Item i = iterator.next();
+            System.out.println(i.getName());
+        }
+    }
 }