1 files changed, 74 insertions, 0 deletions
diff --git a/src/main/java/gregtech/api/interfaces/IRecipeMap.java b/src/main/java/gregtech/api/interfaces/IRecipeMap.java
new file mode 100644
index 0000000000..ce48b29927
--- /dev/null
+++ b/src/main/java/gregtech/api/interfaces/IRecipeMap.java
@@ -0,0 +1,74 @@
+package gregtech.api.interfaces;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+
+import javax.annotation.Nonnull;
+
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_RecipeBuilder;
+import gregtech.api.util.GT_Utility;
+
+/**
+ * Represents the target of a recipe adding action, usually, but not necessarily, is a recipe map itself.
+ */
+public interface IRecipeMap {
+
+    /**
+     * Add a downstream recipe map that will get to handle the original builder.
+     * <p>
+     * Downstream recipe maps got passed the recipe builder after parent recipe map is done with its business. Notice
+     * at this time the original recipe builder might be modified by the parent recipe map in some form, but it will
+     * remain as valid.
+     * <p>
+     * A downstream will only be invoked if parent recipe map added something.
+     *
+     * @param downstream the downstream recipe map to add
+     */
+    void addDownstream(IRecipeMap downstream);
+
+    /**
+     * Actually add the recipe represented by the builder. CAN modify the builder's internal states!!!
+     */
+    @Nonnull
+    Collection<GT_Recipe> doAdd(GT_RecipeBuilder builder);
+
+    /**
+     * Return a variant of this recipe map that will perform a deep copy on input recipe builder before doing anything
+     * to it.
+     * <p>
+     * The returned recipe map will not have any downstreams, but can accept new downstreams.
+     */
+    default IRecipeMap deepCopyInput() {
+        return newRecipeMap(b -> doAdd(b.copy()));
+    }
+
+    static IRecipeMap newRecipeMap(Function<? super GT_RecipeBuilder, Collection<GT_Recipe>> func) {
+        return new IRecipeMap() {
+
+            private final Collection<IRecipeMap> downstreams = new ArrayList<>();
+
+            @Override
+            public void addDownstream(IRecipeMap downstream) {
+                downstreams.add(downstream);
+            }
+
+            @Nonnull
+            @Override
+            public Collection<GT_Recipe> doAdd(GT_RecipeBuilder builder) {
+                List<Collection<GT_Recipe>> ret = new ArrayList<>();
+                Collection<GT_Recipe> out = func.apply(builder);
+                ret.add(out);
+                builder.clearInvalid();
+                if (!out.isEmpty()) {
+                    for (IRecipeMap downstream : downstreams) {
+                        ret.add(downstream.doAdd(builder));
+                    }
+                }
+                return GT_Utility.concat(ret);
+            }
+        };
+    }
+}