From 7fafa7d9bbb2483313d86f946653f3ad64b2db18 Mon Sep 17 00:00:00 2001 From: shedaniel Date: Sat, 9 Apr 2022 02:41:21 +0800 Subject: Support for JEI 9.5, Close #821, Fix #807 --- .../rei/api/client/view/ViewSearchBuilder.java | 75 +++++++++++++ .../main/java/me/shedaniel/rei/impl/Internals.java | 6 ++ .../shedaniel/rei/impl/common/InternalLogger.java | 117 +++++++++++++++++++++ 3 files changed, 198 insertions(+) create mode 100644 api/src/main/java/me/shedaniel/rei/impl/common/InternalLogger.java (limited to 'api/src/main/java') diff --git a/api/src/main/java/me/shedaniel/rei/api/client/view/ViewSearchBuilder.java b/api/src/main/java/me/shedaniel/rei/api/client/view/ViewSearchBuilder.java index 2b3091e12..dbca0d265 100644 --- a/api/src/main/java/me/shedaniel/rei/api/client/view/ViewSearchBuilder.java +++ b/api/src/main/java/me/shedaniel/rei/api/client/view/ViewSearchBuilder.java @@ -27,6 +27,7 @@ import me.shedaniel.rei.api.client.ClientHelper; import me.shedaniel.rei.api.client.registry.category.CategoryRegistry; import me.shedaniel.rei.api.client.registry.display.DisplayCategory; import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.display.Display; import me.shedaniel.rei.api.common.entry.EntryStack; import me.shedaniel.rei.api.common.util.CollectionUtils; import me.shedaniel.rei.impl.ClientInternals; @@ -38,26 +39,89 @@ import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.stream.Stream; public interface ViewSearchBuilder { + /** + * Creates a new {@link ViewSearchBuilder} for looking up displays. + */ static ViewSearchBuilder builder() { return ClientInternals.createViewSearchBuilder(); } + /** + * Adds all displays from the given {@link DisplayCategory} to the search. + * + * @param category the category to add + * @return the {@link ViewSearchBuilder} for chaining + */ ViewSearchBuilder addCategory(CategoryIdentifier category); + /** + * Adds all displays from the given {@link DisplayCategory}s to the search. + * + * @param categories the categories to add + * @return the {@link ViewSearchBuilder} for chaining + */ ViewSearchBuilder addCategories(Collection> categories); + /** + * Adds all displays from all the {@link CategoryRegistry}s to the search. + * + * @return the {@link ViewSearchBuilder} for chaining + */ default ViewSearchBuilder addAllCategories() { return addCategories(CollectionUtils.map(CategoryRegistry.getInstance(), CategoryRegistry.CategoryConfiguration::getCategoryIdentifier)); } + /** + * Returns the set of {@link CategoryIdentifier}s that will be used to add all the {@link Display}s to the search. + * + * @return the set of {@link CategoryIdentifier}s + */ Set> getCategories(); + /** + * Filters the search to only include {@link Display}s that are in the given {@link CategoryIdentifier}. + * + * @param category the category to filter by + * @return the {@link ViewSearchBuilder} for chaining + */ + ViewSearchBuilder filterCategory(CategoryIdentifier category); + + /** + * Filters the search to only include {@link Display}s that are in the given {@link CategoryIdentifier}s. + * + * @param categories the categories to filter by + * @return the {@link ViewSearchBuilder} for chaining + */ + ViewSearchBuilder filterCategories(Collection> categories); + + /** + * Returns the set of {@link CategoryIdentifier}s that will be used to filter the search. + * + * @return the set of {@link CategoryIdentifier}s + */ + Set> getFilteringCategories(); + + /** + * Filters the search to only include {@link Display}s that are recipes for the given {@link EntryStack}. + * + * @param stack the stack to filter by + * @param the type of the stack + * @return the {@link ViewSearchBuilder} for chaining + */ ViewSearchBuilder addRecipesFor(EntryStack stack); List> getRecipesFor(); + /** + * Filters the search to only include {@link Display}s that are usages for the given {@link EntryStack}. + * + * @param stack the stack to filter by + * @param the type of the stack + * @return the {@link ViewSearchBuilder} for chaining + */ ViewSearchBuilder addUsagesFor(EntryStack stack); List> getUsagesFor(); @@ -70,6 +134,17 @@ public interface ViewSearchBuilder { @ApiStatus.Internal Map, List> buildMapInternal(); + @ApiStatus.Experimental + Stream streamDisplays(); + + boolean isMergingDisplays(); + + ViewSearchBuilder mergingDisplays(boolean mergingDisplays); + + boolean isProcessingVisibilityHandlers(); + + ViewSearchBuilder processingVisibilityHandlers(boolean processingVisibilityHandlers); + default boolean open() { return ClientHelper.getInstance().openView(this); } diff --git a/api/src/main/java/me/shedaniel/rei/impl/Internals.java b/api/src/main/java/me/shedaniel/rei/impl/Internals.java index 7fa35af8b..1e64c2c57 100644 --- a/api/src/main/java/me/shedaniel/rei/impl/Internals.java +++ b/api/src/main/java/me/shedaniel/rei/impl/Internals.java @@ -34,6 +34,7 @@ import me.shedaniel.rei.api.common.plugins.PluginManager; import me.shedaniel.rei.api.common.plugins.REIPlugin; import me.shedaniel.rei.api.common.plugins.REIServerPlugin; import me.shedaniel.rei.api.common.transfer.info.MenuInfoRegistry; +import me.shedaniel.rei.impl.common.InternalLogger; import net.minecraft.nbt.Tag; import net.minecraft.resources.ResourceLocation; import net.minecraft.util.Unit; @@ -53,6 +54,7 @@ public final class Internals { private static Supplier nbtHasherProvider = Internals::throwNotSetup; private static Function> categoryIdentifier = (object) -> throwNotSetup(); private static Supplier stubMenuInfoRegistry = Internals::throwNotSetup; + private static Supplier logger = Internals::throwNotSetup; private static T throwNotSetup() { throw new AssertionError("REI Internals have not been initialized!"); @@ -111,6 +113,10 @@ public final class Internals { return (CategoryIdentifier) categoryIdentifier.apply(location); } + public static InternalLogger getInternalLogger() { + return logger.get(); + } + public interface EntryStackProvider { EntryStack empty(); diff --git a/api/src/main/java/me/shedaniel/rei/impl/common/InternalLogger.java b/api/src/main/java/me/shedaniel/rei/impl/common/InternalLogger.java new file mode 100644 index 000000000..40f81129c --- /dev/null +++ b/api/src/main/java/me/shedaniel/rei/impl/common/InternalLogger.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.common; + +import me.shedaniel.rei.impl.Internals; +import org.apache.logging.log4j.Level; +import org.jetbrains.annotations.ApiStatus; + +@ApiStatus.Internal +public interface InternalLogger { + static InternalLogger getInstance() { + return Internals.getInternalLogger(); + } + + void throwException(Throwable throwable); + + void log(Level level, String message); + + void log(Level level, String message, Throwable throwable); + + default void log(Level level, String message, Object... args) { + log(level, String.format(message, args)); + } + + default void fatal(String message) { + log(Level.FATAL, message); + } + + default void fatal(String message, Throwable throwable) { + log(Level.FATAL, message, throwable); + } + + default void fatal(String message, Object... args) { + log(Level.FATAL, String.format(message, args)); + } + + default void error(String message) { + log(Level.ERROR, message); + } + + default void error(String message, Throwable throwable) { + log(Level.ERROR, message, throwable); + } + + default void error(String message, Object... args) { + log(Level.ERROR, String.format(message, args)); + } + + default void warn(String message) { + log(Level.WARN, message); + } + + default void warn(String message, Throwable throwable) { + log(Level.WARN, message, throwable); + } + + default void warn(String message, Object... args) { + log(Level.WARN, String.format(message, args)); + } + + default void info(String message) { + log(Level.INFO, message); + } + + default void info(String message, Throwable throwable) { + log(Level.INFO, message, throwable); + } + + default void info(String message, Object... args) { + log(Level.INFO, String.format(message, args)); + } + + default void debug(String message) { + log(Level.DEBUG, message); + } + + default void debug(String message, Throwable throwable) { + log(Level.DEBUG, message, throwable); + } + + default void debug(String message, Object... args) { + log(Level.DEBUG, String.format(message, args)); + } + + default void trace(String message) { + log(Level.TRACE, message); + } + + default void trace(String message, Throwable throwable) { + log(Level.TRACE, message, throwable); + } + + default void trace(String message, Object... args) { + log(Level.TRACE, String.format(message, args)); + } +} -- cgit