WIP Module

7 files changed, 862 insertions, 0 deletions

diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryImpl.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryImpl.java
new file mode 100644
index 000000000..be1ed5225
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryImpl.java
@@ -0,0 +1,276 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type;
+
+import com.google.common.collect.Lists;
+import it.unimi.dsi.fastutil.longs.LongArrayList;
+import it.unimi.dsi.fastutil.longs.LongList;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import me.shedaniel.rei.api.client.REIRuntime;
+import me.shedaniel.rei.api.client.overlay.ScreenOverlay;
+import me.shedaniel.rei.api.client.plugins.REIClientPlugin;
+import me.shedaniel.rei.api.client.registry.entry.EntryRegistry;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import me.shedaniel.rei.api.common.entry.comparison.ComparisonContext;
+import me.shedaniel.rei.api.common.entry.type.EntryDefinition;
+import me.shedaniel.rei.api.common.entry.type.VanillaEntryTypes;
+import me.shedaniel.rei.api.common.registry.ReloadStage;
+import me.shedaniel.rei.api.common.util.CollectionUtils;
+import me.shedaniel.rei.api.common.util.EntryStacks;
+import me.shedaniel.rei.impl.Internals;
+import me.shedaniel.rei.impl.common.InternalLogger;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.item.CreativeModeTab;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+@ApiStatus.Internal
+@Environment(EnvType.CLIENT)
+public class EntryRegistryImpl implements EntryRegistry {
+    private final List<EntryRegistryListener> listeners = Lists.newCopyOnWriteArrayList();
+    private EntryRegistryList registryList;
+    private LongSet entriesHash;
+    private boolean reloading;
+    
+    public EntryRegistryImpl() {
+        registryList = new NormalEntryRegistryList();
+        entriesHash = new LongOpenHashSet();
+        listeners.addAll(Internals.resolveServices(EntryRegistryListener.class));
+    }
+    
+    @Override
+    public void acceptPlugin(REIClientPlugin plugin) {
+        plugin.registerEntries(this);
+    }
+    
+    @Override
+    public ReloadStage getStage() {
+        return ReloadStage.START;
+    }
+    
+    @Override
+    public void startReload() {
+        registryList = new ReloadingEntryRegistryList();
+        entriesHash = new LongOpenHashSet();
+        reloading = true;
+    }
+    
+    @Override
+    public void endReload() {
+        reloading = false;
+        if (!(registryList instanceof ReloadingEntryRegistryList)) {
+            throw new IllegalStateException("Expected ReloadingEntryRegistryList, got " + registryList.getClass().getName());
+        }
+        registryList = new NormalEntryRegistryList(registryList.stream().filter(((Predicate<EntryStack<?>>) EntryStack::isEmpty).negate()));
+        refilter();
+        REIRuntime.getInstance().getOverlay().ifPresent(ScreenOverlay::queueReloadOverlay);
+        InternalLogger.getInstance().debug("Reloaded entry registry with %d entries and %d filtered entries", size(), getPreFilteredList().size());
+    }
+    
+    @Override
+    public boolean isReloading() {
+        return reloading;
+    }
+    
+    @Override
+    public int size() {
+        return registryList.size();
+    }
+    
+    @Override
+    public Stream<EntryStack<?>> getEntryStacks() {
+        return registryList.stream();
+    }
+    
+    @Override
+    public void refilter() {
+        List<EntryStack<?>> stacks = registryList.collect();
+        
+        for (EntryRegistryListener listener : listeners) {
+            listener.onReFilter(stacks);
+        }
+    }
+    
+    private static final Comparator<ItemStack> STACK_COMPARATOR = (a, b) -> ItemStack.matches(a, b) ? 0 : 1;
+    
+    @Override
+    public List<ItemStack> appendStacksForItem(Item item) {
+        NonNullList<ItemStack> list = NonNullList.create();
+        LongSet set = new LongOpenHashSet();
+        EntryDefinition<ItemStack> itemDefinition = VanillaEntryTypes.ITEM.getDefinition();
+        for (CreativeModeTab tab : CreativeModeTab.TABS) {
+            if (tab != CreativeModeTab.TAB_HOTBAR && tab != CreativeModeTab.TAB_INVENTORY) {
+                NonNullList<ItemStack> tabList = NonNullList.create();
+                item.fillItemCategory(tab, tabList);
+                for (ItemStack stack : tabList) {
+                    if (set.add(itemDefinition.hash(null, stack, ComparisonContext.EXACT))) {
+                        list.add(stack);
+                    }
+                }
+            }
+        }
+        if (list.isEmpty()) {
+            return Collections.singletonList(item.getDefaultInstance());
+        }
+        if (list.size() > 1) {
+            list.sort(STACK_COMPARATOR);
+        }
+        return list;
+    }
+    
+    @Override
+    public boolean alreadyContain(EntryStack<?> stack) {
+        return entriesHash.contains(EntryStacks.hashExact(stack));
+    }
+    
+    @Override
+    public void addEntryAfter(@Nullable EntryStack<?> afterEntry, EntryStack<?> stack) {
+        long hashExact = EntryStacks.hashExact(stack);
+        if (this.entriesHash.add(hashExact)) {
+            if (afterEntry != null) {
+                int index = registryList.lastIndexOf(afterEntry);
+                registryList.add(index, stack, hashExact);
+            } else registryList.add(stack, hashExact);
+            
+            for (EntryRegistryListener listener : listeners) {
+                listener.addEntryAfter(afterEntry, stack, hashExact);
+            }
+        }
+    }
+    
+    @Override
+    public void addEntriesAfter(@Nullable EntryStack<?> afterEntry, Collection<? extends EntryStack<?>> stacks) {
+        List<EntryStack<?>> filtered;
+        LongList hashes = registryList.needsHash() ? new LongArrayList(stacks.size()) : null;
+        
+        if (registryList.needsHash()) {
+            filtered = new ArrayList<>(stacks.size());
+            for (EntryStack<?> stack : stacks) {
+                long hashExact = EntryStacks.hashExact(stack);
+                if (entriesHash.add(hashExact)) {
+                    filtered.add(stack);
+                    hashes.add(hashExact);
+                }
+            }
+        } else {
+            filtered = CollectionUtils.filterToList((List<EntryStack<?>>) stacks, entry -> entriesHash.add(EntryStacks.hashExact(entry)));
+        }
+        
+        if (afterEntry != null) {
+            int index = registryList.lastIndexOf(afterEntry);
+            registryList.addAll(index, filtered, hashes);
+        } else registryList.addAll(filtered, hashes);
+        
+        for (EntryRegistryListener listener : listeners) {
+            listener.addEntriesAfter(afterEntry, filtered, hashes);
+        }
+    }
+    
+    @Override
+    public boolean removeEntry(EntryStack<?> stack) {
+        long hashExact = EntryStacks.hashExact(stack);
+        registryList.remove(stack, hashExact);
+        boolean removed = entriesHash.remove(hashExact);
+        
+        if (removed) {
+            for (EntryRegistryListener listener : listeners) {
+                listener.removeEntry(stack, hashExact);
+            }
+        }
+        
+        return removed;
+    }
+    
+    @Override
+    public boolean removeEntryIf(Predicate<? extends EntryStack<?>> predicate) {
+        List<EntryStack<?>> removedStacks = new ArrayList<>();
+        LongList hashes = registryList.needsHash() ? new LongArrayList() : null;
+        
+        boolean removed = registryList.removeIf(stack -> {
+            if (((Predicate<EntryStack<?>>) predicate).test(stack)) {
+                long hashExact = EntryStacks.hashExact(stack);
+                entriesHash.remove(hashExact);
+                removedStacks.add(stack);
+                if (hashes != null) hashes.add(hashExact);
+                return true;
+            }
+            
+            return false;
+        });
+        
+        if (removed) {
+            for (EntryRegistryListener listener : listeners) {
+                listener.removeEntries(removedStacks, hashes);
+            }
+        }
+        
+        return removed;
+    }
+    
+    @Override
+    public boolean removeEntryExactHashIf(LongPredicate predicate) {
+        LongPredicate entryStackPredicate = hash -> {
+            if (predicate.test(hash)) {
+                entriesHash.remove(hash);
+                return true;
+            }
+            
+            return false;
+        };
+        
+        for (EntryRegistryListener listener : listeners) {
+            listener.removeEntriesIf(stack -> predicate.test(EntryStacks.hashExact(stack)));
+        }
+        
+        return registryList.removeExactIf(entryStackPredicate);
+    }
+    
+    @Override
+    public boolean removeEntryFuzzyHashIf(LongPredicate predicate) {
+        Predicate<EntryStack<?>> entryStackPredicate = stack -> {
+            if (predicate.test(EntryStacks.hashFuzzy(stack))) {
+                entriesHash.remove(EntryStacks.hashExact(stack));
+                return true;
+            }
+            
+            return false;
+        };
+        
+        for (EntryRegistryListener listener : listeners) {
+            listener.removeEntriesIf(entryStackPredicate);
+        }
+        
+        return registryList.removeIf(entryStackPredicate);
+    }
+}
diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryList.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryList.java
new file mode 100644
index 000000000..401bf61a9
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryList.java
@@ -0,0 +1,62 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type;
+
+import it.unimi.dsi.fastutil.longs.LongList;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.List;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+@ApiStatus.Internal
+public interface EntryRegistryList {
+    int size();
+    
+    Stream<EntryStack<?>> stream();
+    
+    List<EntryStack<?>> collect();
+    
+    int indexOf(EntryStack<?> stack);
+    
+    int lastIndexOf(EntryStack<?> stack);
+    
+    void add(EntryStack<?> stack, long hashExact);
+    
+    void add(int index, EntryStack<?> stack, long hashExact);
+    
+    void addAll(List<EntryStack<?>> stacks, LongList hashes);
+    
+    void addAll(int index, List<EntryStack<?>> stacks, LongList hashes);
+    
+    void remove(EntryStack<?> stack, long hashExact);
+    
+    boolean removeIf(Predicate<? extends EntryStack<?>> predicate);
+    
+    boolean removeExactIf(LongPredicate predicate);
+    
+    boolean needsHash();
+}
diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryListener.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryListener.java
new file mode 100644
index 000000000..b1c59e0e7
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryRegistryListener.java
@@ -0,0 +1,47 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type;
+
+import it.unimi.dsi.fastutil.longs.LongList;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+@ApiStatus.Internal
+public interface EntryRegistryListener {
+    default void addEntryAfter(@Nullable EntryStack<?> afterEntry, EntryStack<?> stack, long stackHashExact) {}
+    
+    default void addEntriesAfter(@Nullable EntryStack<?> afterEntry, List<EntryStack<?>> stacks, @Nullable LongList hashes) {}
+    
+    default void removeEntry(EntryStack<?> stack, long hashExact) {}
+    
+    default void removeEntries(List<EntryStack<?>> stacks, @Nullable LongList hashes) {}
+    
+    default void removeEntriesIf(Predicate<EntryStack<?>> predicate) {}
+    
+    default void onReFilter(List<EntryStack<?>> stacks) {}
+}
diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryTypeRegistryImpl.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryTypeRegistryImpl.java
new file mode 100644
index 000000000..ad5a6261d
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/EntryTypeRegistryImpl.java
@@ -0,0 +1,102 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Table;
+import me.shedaniel.rei.api.common.entry.type.EntryDefinition;
+import me.shedaniel.rei.api.common.entry.type.EntryType;
+import me.shedaniel.rei.api.common.entry.type.EntryTypeBridge;
+import me.shedaniel.rei.api.common.entry.type.EntryTypeRegistry;
+import me.shedaniel.rei.api.common.plugins.REIPlugin;
+import me.shedaniel.rei.api.common.registry.ReloadStage;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+@ApiStatus.Internal
+public class EntryTypeRegistryImpl implements EntryTypeRegistry {
+    private final BiMap<ResourceLocation, EntryDefinition<?>> entryTypes = HashBiMap.create();
+    private final Table<ResourceLocation, ResourceLocation, List<EntryTypeBridge<?, ?>>> typeBridges = HashBasedTable.create();
+    
+    @Override
+    public ReloadStage getStage() {
+        return ReloadStage.START;
+    }
+    
+    @Override
+    public void acceptPlugin(REIPlugin<?> plugin) {
+        plugin.registerEntryTypes(this);
+    }
+    
+    @Override
+    public <T> void register(ResourceLocation id, EntryDefinition<T> definition) {
+        this.entryTypes.put(id, definition);
+    }
+    
+    @Override
+    public <A, B> void registerBridge(EntryType<A> original, EntryType<B> destination, EntryTypeBridge<A, B> bridge) {
+        List<EntryTypeBridge<?, ?>> list = this.typeBridges.get(original.getId(), destination.getId());
+        if (list == null) {
+            this.typeBridges.put(original.getId(), destination.getId(), list = new ArrayList<>());
+        }
+        list.add(bridge);
+    }
+    
+    @Override
+    public EntryDefinition<?> get(ResourceLocation id) {
+        return this.entryTypes.get(id);
+    }
+    
+    @Override
+    public Set<ResourceLocation> keySet() {
+        return this.entryTypes.keySet();
+    }
+    
+    @Override
+    public Set<EntryDefinition<?>> values() {
+        return this.entryTypes.values();
+    }
+    
+    @Override
+    public <A, B> Iterable<EntryTypeBridge<A, B>> getBridgesFor(EntryType<A> original, EntryType<B> destination) {
+        List<? extends EntryTypeBridge<?, ?>> list = this.typeBridges.get(original.getId(), destination.getId());
+        if (list == null) {
+            return Collections.emptyList();
+        }
+        return (Iterable<EntryTypeBridge<A, B>>) list;
+    }
+    
+    @Override
+    public void startReload() {
+        entryTypes.clear();
+        typeBridges.clear();
+    }
+}
diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/NormalEntryRegistryList.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/NormalEntryRegistryList.java
new file mode 100644
index 000000000..73f378c0f
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/NormalEntryRegistryList.java
@@ -0,0 +1,117 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type;
+
+import it.unimi.dsi.fastutil.longs.LongList;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import me.shedaniel.rei.api.common.util.EntryStacks;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@ApiStatus.Internal
+public class NormalEntryRegistryList implements EntryRegistryList {
+    private List<EntryStack<?>> list = new ArrayList<>();
+    
+    public NormalEntryRegistryList() {
+    }
+    
+    public NormalEntryRegistryList(Stream<EntryStack<?>> list) {
+        list.collect(Collectors.toCollection(() -> this.list));
+    }
+    
+    @Override
+    public int size() {
+        return list.size();
+    }
+    
+    @Override
+    public Stream<EntryStack<?>> stream() {
+        return list.stream();
+    }
+    
+    @Override
+    public List<EntryStack<?>> collect() {
+        return list;
+    }
+    
+    @Override
+    public int indexOf(EntryStack<?> stack) {
+        return list.indexOf(stack);
+    }
+    
+    @Override
+    public int lastIndexOf(EntryStack<?> stack) {
+        return list.lastIndexOf(stack);
+    }
+    
+    @Override
+    public void add(EntryStack<?> stack, long hashExact) {
+        list.add(stack);
+    }
+    
+    @Override
+    public void add(int index, EntryStack<?> stack, long hashExact) {
+        list.add(index, stack);
+    }
+    
+    @Override
+    public void addAll(List<EntryStack<?>> stacks, LongList hashes) {
+        list.addAll(stacks);
+    }
+    
+    @Override
+    public void addAll(int index, List<EntryStack<?>> stacks, LongList hashes) {
+        list.addAll(index, stacks);
+    }
+    
+    @Override
+    public void remove(EntryStack<?> stack, long hashExact) {
+        list.remove(stack);
+    }
+    
+    @Override
+    public boolean removeIf(Predicate<? extends EntryStack<?>> predicate) {
+        return list.removeIf((Predicate<? super EntryStack<?>>) predicate);
+    }
+    
+    @Override
+    public boolean removeExactIf(LongPredicate predicate) {
+        return list.removeIf(stack -> predicate.test(EntryStacks.hashExact(stack)));
+    }
+    
+    @Override
+    public boolean needsHash() {
+        return false;
+    }
+    
+    public List<EntryStack<?>> getList() {
+        return list;
+    }
+}
diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/ReloadingEntryRegistryList.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/ReloadingEntryRegistryList.java
new file mode 100644
index 000000000..53f21406b
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/ReloadingEntryRegistryList.java
@@ -0,0 +1,109 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type;
+
+import it.unimi.dsi.fastutil.longs.LongList;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import me.shedaniel.rei.api.common.util.CollectionUtils;
+import me.shedaniel.rei.impl.common.util.HashedEntryStackWrapper;
+import net.minecraft.core.Registry;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.LongPredicate;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+@ApiStatus.Internal
+public class ReloadingEntryRegistryList implements EntryRegistryList {
+    private List<HashedEntryStackWrapper> list = new ArrayList<>(Registry.ITEM.keySet().size() + 100);
+    
+    @Override
+    public int size() {
+        return list.size();
+    }
+    
+    @Override
+    public Stream<EntryStack<?>> stream() {
+        return list.stream().map(HashedEntryStackWrapper::unwrap);
+    }
+    
+    @Override
+    public List<EntryStack<?>> collect() {
+        return CollectionUtils.map(list, HashedEntryStackWrapper::unwrap);
+    }
+    
+    @Override
+    public int indexOf(EntryStack<?> stack) {
+        return list.indexOf(new HashedEntryStackWrapper(stack));
+    }
+    
+    @Override
+    public int lastIndexOf(EntryStack<?> stack) {
+        return list.lastIndexOf(new HashedEntryStackWrapper(stack));
+    }
+    
+    @Override
+    public void add(EntryStack<?> stack, long hashExact) {
+        list.add(new HashedEntryStackWrapper(stack, hashExact));
+    }
+    
+    @Override
+    public void add(int index, EntryStack<?> stack, long hashExact) {
+        list.add(index, new HashedEntryStackWrapper(stack, hashExact));
+    }
+    
+    @Override
+    public void addAll(List<EntryStack<?>> stacks, LongList hashes) {
+        List<HashedEntryStackWrapper> wrappers = CollectionUtils.mapIndexed(stacks, (i, stack) -> new HashedEntryStackWrapper(stack, hashes.getLong(i)));
+        list.addAll(wrappers);
+    }
+    
+    @Override
+    public void addAll(int index, List<EntryStack<?>> stacks, LongList hashes) {
+        List<HashedEntryStackWrapper> wrappers = CollectionUtils.mapIndexed(stacks, (i, stack) -> new HashedEntryStackWrapper(stack, hashes.getLong(i)));
+        list.addAll(index, wrappers);
+    }
+    
+    @Override
+    public void remove(EntryStack<?> stack, long hashExact) {
+        list.remove(new HashedEntryStackWrapper(stack, hashExact));
+    }
+    
+    @Override
+    public boolean removeIf(Predicate<? extends EntryStack<?>> predicate) {
+        return list.removeIf(wrapper -> ((Predicate<EntryStack<?>>) predicate).test(wrapper.unwrap()));
+    }
+    
+    @Override
+    public boolean removeExactIf(LongPredicate predicate) {
+        return list.removeIf(wrapper -> predicate.test(wrapper.hashExact()));
+    }
+    
+    @Override
+    public boolean needsHash() {
+        return true;
+    }
+}
diff --git a/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/collapsed/CollapsibleEntryRegistryImpl.java b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/collapsed/CollapsibleEntryRegistryImpl.java
new file mode 100644
index 000000000..f5222f864
--- /dev/null
+++ b/runtime-engine/entries/src/main/java/me/shedaniel/rei/impl/client/entry/type/collapsed/CollapsibleEntryRegistryImpl.java
@@ -0,0 +1,149 @@
+/*
+ * This file is licensed under the MIT License, part of Roughly Enough Items.
+ * Copyright (c) 2018, 2019, 2020, 2021, 2022 shedaniel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package me.shedaniel.rei.impl.client.entry.type.collapsed;
+
+import com.google.common.collect.ForwardingList;
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import me.shedaniel.rei.api.client.plugins.REIClientPlugin;
+import me.shedaniel.rei.api.client.registry.entry.CollapsibleEntry;
+import me.shedaniel.rei.api.client.registry.entry.CollapsibleEntryRegistry;
+import me.shedaniel.rei.api.common.entry.EntryStack;
+import me.shedaniel.rei.api.common.util.EntryStacks;
+import me.shedaniel.rei.impl.common.InternalLogger;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.ApiStatus;
+