From 7c2a510545e8280ff073e289e5d600e4614b27cc Mon Sep 17 00:00:00 2001
From: shedaniel <daniel@shedaniel.me>
Date: Wed, 14 Apr 2021 20:08:47 +0800
Subject: Refactor MenuInfo into a provider system and add more docs

Signed-off-by: shedaniel <daniel@shedaniel.me>
---
 .../me/shedaniel/rei/RoughlyEnoughItemsCore.java   | 26 +++++++-------
 .../rei/impl/common/transfer/InputSlotCrafter.java | 26 +++++++-------
 .../impl/common/transfer/MenuInfoRegistryImpl.java | 41 +++++++++++++++-------
 .../autocrafting/DefaultCategoryHandler.java       |  2 +-
 4 files changed, 57 insertions(+), 38 deletions(-)

(limited to 'runtime/src/main/java')

diff --git a/runtime/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java b/runtime/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java
index 0ed0e6f78..6f7e36118 100644
--- a/runtime/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java
+++ b/runtime/src/main/java/me/shedaniel/rei/RoughlyEnoughItemsCore.java
@@ -142,18 +142,18 @@ import java.util.stream.Stream;
 public class RoughlyEnoughItemsCore {
     @ApiStatus.Internal
     public static final Logger LOGGER = LogManager.getFormatterLogger("REI");
-    private static final ExecutorService RELOAD_PLUGINS;
+    private static ExecutorService reloadPlugins;
     @ApiStatus.Experimental
     public static boolean isLeftMousePressed = false;
     
     static {
-        RELOAD_PLUGINS = Executors.newSingleThreadScheduledExecutor(r -> {
-            Thread thread = new Thread(r, "REI-ReloadPlugins");
-            thread.setDaemon(true);
-            return thread;
-        });
         attachCommonInternals();
         if (Platform.getEnvironment() == Env.CLIENT) {
+            reloadPlugins = Executors.newSingleThreadScheduledExecutor(r -> {
+                Thread thread = new Thread(r, "REI-ReloadPlugins");
+                thread.setDaemon(true);
+                return thread;
+            });
             attachClientInternals();
         }
     }
@@ -401,15 +401,19 @@ public class RoughlyEnoughItemsCore {
             lastReload.setValue(System.currentTimeMillis());
         }
         if (ConfigObject.getInstance().doesRegisterRecipesInAnotherThread()) {
-            CompletableFuture.runAsync(RoughlyEnoughItemsCore::_reloadPlugins, RELOAD_PLUGINS);
+            CompletableFuture.runAsync(RoughlyEnoughItemsCore::_reloadPlugins, reloadPlugins);
         } else {
             _reloadPlugins();
         }
     }
     
     private static void _reloadPlugins() {
-        for (PluginManager<? extends REIPlugin<?>> instance : PluginManager.getActiveInstances()) {
-            instance.startReload();
+        try {
+            for (PluginManager<? extends REIPlugin<?>> instance : PluginManager.getActiveInstances()) {
+                instance.startReload();
+            }
+        } catch (Throwable throwable) {
+            throwable.printStackTrace();
         }
     }
     
@@ -421,9 +425,7 @@ public class RoughlyEnoughItemsCore {
         if (Platform.getEnvironment() == Env.SERVER) {
             MutableLong lastReload = new MutableLong(-1);
             ReloadListeners.registerReloadListener(PackType.SERVER_DATA, (preparationBarrier, resourceManager, profilerFiller, profilerFiller2, executor, executor2) -> {
-                return preparationBarrier.wait(Unit.INSTANCE).thenRunAsync(() -> {
-                    CompletableFuture.runAsync(RoughlyEnoughItemsCore::_reloadPlugins, RELOAD_PLUGINS);
-                }, executor2);
+                return preparationBarrier.wait(Unit.INSTANCE).thenRunAsync(RoughlyEnoughItemsCore::_reloadPlugins, executor2);
             });
         }
     }
diff --git a/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/InputSlotCrafter.java b/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/InputSlotCrafter.java
index 17812fec9..f17ae6faa 100644
--- a/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/InputSlotCrafter.java
+++ b/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/InputSlotCrafter.java
@@ -31,7 +31,7 @@ import me.shedaniel.rei.api.common.transfer.RecipeFinder;
 import me.shedaniel.rei.api.common.transfer.info.MenuInfo;
 import me.shedaniel.rei.api.common.transfer.info.MenuInfoContext;
 import me.shedaniel.rei.api.common.transfer.info.MenuInfoRegistry;
-import me.shedaniel.rei.api.common.transfer.info.stack.StackAccessor;
+import me.shedaniel.rei.api.common.transfer.info.stack.SlotAccessor;
 import me.shedaniel.rei.api.common.util.CollectionUtils;
 import net.minecraft.core.NonNullList;
 import net.minecraft.nbt.CompoundTag;
@@ -51,8 +51,8 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
     protected T container;
     protected D display;
     protected MenuInfo<T, D> menuInfo;
-    private Iterable<StackAccessor> inputStacks;
-    private Iterable<StackAccessor> inventoryStacks;
+    private Iterable<SlotAccessor> inputStacks;
+    private Iterable<SlotAccessor> inventoryStacks;
     private ServerPlayer player;
     
     private InputSlotCrafter(CategoryIdentifier<D> category, T container, CompoundTag display, MenuInfo<T, D> menuInfo) {
@@ -71,8 +71,8 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
     
     private void fillInputSlots(ServerPlayer player, boolean hasShift) {
         this.player = player;
-        this.inventoryStacks = this.menuInfo.getInventoryStacks(this);
-        this.inputStacks = this.menuInfo.getInputStacks(this);
+        this.inventoryStacks = this.menuInfo.getInventorySlots(this);
+        this.inputStacks = this.menuInfo.getInputSlots(this);
         
         player.ignoreSlotUpdateHack = true;
         // Return the already placed items on the grid
@@ -81,7 +81,7 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
         RecipeFinder recipeFinder = new RecipeFinder();
         this.menuInfo.getRecipeFinderPopulator().populate(this, recipeFinder);
         NonNullList<Ingredient> ingredients = NonNullList.create();
-        for (List<ItemStack> itemStacks : this.menuInfo.getDisplayInputs(this)) {
+        for (List<ItemStack> itemStacks : this.menuInfo.getInputs(this)) {
             ingredients.add(CollectionUtils.toIngredient(itemStacks));
         }
         
@@ -98,8 +98,8 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
         this.menuInfo.markDirty(this);
     }
     
-    public void alignRecipeToGrid(Iterable<StackAccessor> inputStacks, Iterator<Integer> recipeItemIds, int craftsAmount) {
-        for (StackAccessor inputStack : inputStacks) {
+    public void alignRecipeToGrid(Iterable<SlotAccessor> inputStacks, Iterator<Integer> recipeItemIds, int craftsAmount) {
+        for (SlotAccessor inputStack : inputStacks) {
             if (!recipeItemIds.hasNext()) {
                 return;
             }
@@ -108,7 +108,7 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
         }
     }
     
-    public void acceptAlignedInput(Integer recipeItemId, StackAccessor inputStack, int craftsAmount) {
+    public void acceptAlignedInput(Integer recipeItemId, SlotAccessor inputStack, int craftsAmount) {
         ItemStack toBeTakenStack = RecipeFinder.getStackFromId(recipeItemId);
         if (!toBeTakenStack.isEmpty()) {
             for (int i = 0; i < craftsAmount; ++i) {
@@ -117,8 +117,8 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
         }
     }
     
-    protected void fillInputSlot(StackAccessor slot, ItemStack toBeTakenStack) {
-        StackAccessor takenSlot = this.takeInventoryStack(toBeTakenStack);
+    protected void fillInputSlot(SlotAccessor slot, ItemStack toBeTakenStack) {
+        SlotAccessor takenSlot = this.takeInventoryStack(toBeTakenStack);
         if (takenSlot != null) {
             ItemStack takenStack = takenSlot.getItemStack().copy();
             if (!takenStack.isEmpty()) {
@@ -161,8 +161,8 @@ public class InputSlotCrafter<T extends AbstractContainerMenu, C extends Contain
     }
     
     @Nullable
-    public StackAccessor takeInventoryStack(ItemStack itemStack) {
-        for (StackAccessor inventoryStack : inventoryStacks) {
+    public SlotAccessor takeInventoryStack(ItemStack itemStack) {
+        for (SlotAccessor inventoryStack : inventoryStacks) {
             ItemStack itemStack1 = inventoryStack.getItemStack();
             if (!itemStack1.isEmpty() && areItemsEqual(itemStack, itemStack1) && !itemStack1.isDamaged() && !itemStack1.isEnchanted() && !itemStack1.hasCustomHoverName()) {
                 return inventoryStack;
diff --git a/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/MenuInfoRegistryImpl.java b/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/MenuInfoRegistryImpl.java
index b6760a424..8b38b73bf 100644
--- a/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/MenuInfoRegistryImpl.java
+++ b/runtime/src/main/java/me/shedaniel/rei/impl/common/transfer/MenuInfoRegistryImpl.java
@@ -29,46 +29,63 @@ import me.shedaniel.rei.api.common.category.CategoryIdentifier;
 import me.shedaniel.rei.api.common.display.Display;
 import me.shedaniel.rei.api.common.plugins.REIServerPlugin;
 import me.shedaniel.rei.api.common.transfer.info.MenuInfo;
+import me.shedaniel.rei.api.common.transfer.info.MenuInfoProvider;
 import me.shedaniel.rei.api.common.transfer.info.MenuInfoRegistry;
 import net.minecraft.world.inventory.AbstractContainerMenu;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Predicate;
 
 public class MenuInfoRegistryImpl implements MenuInfoRegistry {
-    private final Map<CategoryIdentifier<?>, Map<Class<? extends AbstractContainerMenu>, MenuInfo<?, ?>>> map = Maps.newLinkedHashMap();
-    private final Map<Predicate<CategoryIdentifier<?>>, List<MenuInfo<?, ?>>> mapGeneric = Maps.newLinkedHashMap();
+    private final Map<CategoryIdentifier<?>, Map<Class<? extends AbstractContainerMenu>, List<MenuInfoProvider<?, ?>>>> map = Maps.newLinkedHashMap();
+    private final Map<Predicate<CategoryIdentifier<?>>, List<MenuInfoProvider<?, ?>>> mapGeneric = Maps.newLinkedHashMap();
     
     @Override
-    public <C extends AbstractContainerMenu, D extends Display> void register(CategoryIdentifier<D> category, Class<C> menuClass, MenuInfo<C, D> menuInfo) {
-        map.computeIfAbsent(category, id -> Maps.newLinkedHashMap()).put(menuClass, menuInfo);
+    public <C extends AbstractContainerMenu, D extends Display> void register(CategoryIdentifier<D> category, Class<C> menuClass, MenuInfoProvider<C, D> menuInfo) {
+        map.computeIfAbsent(category, id -> Maps.newLinkedHashMap())
+                .computeIfAbsent(menuClass, c -> Lists.newArrayList())
+                .add(menuInfo);
     }
     
     @Override
-    public <D extends Display> void registerGeneric(Predicate<CategoryIdentifier<?>> categoryPredicate, MenuInfo<?, D> menuInfo) {
+    public <D extends Display> void registerGeneric(Predicate<CategoryIdentifier<?>> categoryPredicate, MenuInfoProvider<?, D> menuInfo) {
         mapGeneric.computeIfAbsent(categoryPredicate, id -> Lists.newArrayList()).add(menuInfo);
     }
     
     @Override
     public <T extends AbstractContainerMenu, D extends Display> MenuInfo<T, D> get(CategoryIdentifier<D> category, Class<T> menuClass) {
-        Map<Class<? extends AbstractContainerMenu>, MenuInfo<?, ?>> infoMap = map.get(category);
+        Map<Class<? extends AbstractContainerMenu>, List<MenuInfoProvider<?, ?>>> infoMap = map.get(category);
         if (infoMap != null && !infoMap.isEmpty()) {
             if (infoMap.containsKey(menuClass)) {
-                return (MenuInfo<T, D>) infoMap.get(menuClass);
+                for (MenuInfoProvider<?, ?> provider : infoMap.get(menuClass)) {
+                    Optional<MenuInfo<T, D>> info = ((MenuInfoProvider<T, D>) provider).provide(category, menuClass);
+                    if (info.isPresent()) {
+                        return info.get();
+                    }
+                }
             }
-            for (Map.Entry<Class<? extends AbstractContainerMenu>, MenuInfo<?, ?>> entry : infoMap.entrySet()) {
+            for (Map.Entry<Class<? extends AbstractContainerMenu>, List<MenuInfoProvider<?, ?>>> entry : infoMap.entrySet()) {
                 if (entry.getKey().isAssignableFrom(menuClass)) {
-                    return (MenuInfo<T, D>) entry.getValue();
+                    for (MenuInfoProvider<?, ?> provider : entry.getValue()) {
+                        Optional<MenuInfo<T, D>> info = ((MenuInfoProvider<T, D>) provider).provide(category, menuClass);
+                        if (info.isPresent()) {
+                            return info.get();
+                        }
+                    }
                 }
             }
         }
         
-        for (Map.Entry<Predicate<CategoryIdentifier<?>>, List<MenuInfo<?, ?>>> entry : mapGeneric.entrySet()) {
+        for (Map.Entry<Predicate<CategoryIdentifier<?>>, List<MenuInfoProvider<?, ?>>> entry : mapGeneric.entrySet()) {
             if (entry.getKey().test(category) && !entry.getValue().isEmpty()) {
-                List<MenuInfo<?, ?>> infoList = entry.getValue();
+                List<MenuInfoProvider<?, ?>> infoList = entry.getValue();
                 if (!infoList.isEmpty()) {
-                    return (MenuInfo<T, D>) infoList.get(0);
+                    Optional<MenuInfo<T, D>> info = ((MenuInfoProvider<T, D>) infoList.get(0)).provide(category, menuClass);
+                    if (info.isPresent()) {
+                        return info.get();
+                    }
                 }
             }
         }
diff --git a/runtime/src/main/java/me/shedaniel/rei/plugin/autocrafting/DefaultCategoryHandler.java b/runtime/src/main/java/me/shedaniel/rei/plugin/autocrafting/DefaultCategoryHandler.java
index dba6fe449..a400c0155 100644
--- a/runtime/src/main/java/me/shedaniel/rei/plugin/autocrafting/DefaultCategoryHandler.java
+++ b/runtime/src/main/java/me/shedaniel/rei/plugin/autocrafting/DefaultCategoryHandler.java
@@ -74,7 +74,7 @@ public class DefaultCategoryHandler implements TransferHandler {
         } catch (MenuTransferException e) {
             return Result.createFailed(e.getError());
         }
-        List<List<ItemStack>> input = menuInfo.getDisplayInputs(menuInfoContext);
+        List<List<ItemStack>> input = menuInfo.getInputs(menuInfoContext);
         IntList intList = hasItems(menu, menuInfo, display, input);
         if (!intList.isEmpty()) {
             return Result.createFailed(new TranslatableComponent("error.rei.not.enough.materials"), intList);
-- 
cgit