public static <T> List<T> getInstancesOfAnnotation(ASMDataTable asmDataTable, Class annotationClass, Class<T> instanceClass) { String annotationClassName = annotationClass.getCanonicalName(); Set<ASMDataTable.ASMData> asmDatas = asmDataTable.getAll(annotationClassName); List<T> instances = new ArrayList<>(); for (ASMDataTable.ASMData asmData : asmDatas) { try { Class<?> asmClass = Class.forName(asmData.getClassName()); Class<? extends T> asmInstanceClass = asmClass.asSubclass(instanceClass); T instance = asmInstanceClass.newInstance(); instances.add(instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | LinkageError e) { HarshenCastle.LOGGER.error("Failed to load: {}", asmData.getClassName(), e); } } return instances; }
public static List<CustomStuffPlugin> getPluginInstances(ASMDataTable asmDataTable) { String annotationName = CS4Plugin.class.getCanonicalName(); Set<ASMDataTable.ASMData> asmDatas = asmDataTable.getAll(annotationName); List<CustomStuffPlugin> instances = Lists.newArrayList(); for (ASMDataTable.ASMData asmData : asmDatas) { try { Class<?> asmClass = Class.forName(asmData.getClassName()); if (CustomStuffPlugin.class.isAssignableFrom(asmClass)) { Class<? extends CustomStuffPlugin> instanceClass = asmClass.asSubclass(CustomStuffPlugin.class); CustomStuffPlugin instance = instanceClass.newInstance(); instances.add(instance); } } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) { e.printStackTrace(); } } return instances; }
public static void loadData(ASMDataTable data) { FMLLog.fine("Loading @Config anotation data"); for (ASMData target : data.getAll(Config.class.getName())) { String modid = (String)target.getAnnotationInfo().get("modid"); Multimap<Config.Type, ASMData> map = asm_data.get(modid); if (map == null) { map = ArrayListMultimap.create(); asm_data.put(modid, map); } EnumHolder tholder = (EnumHolder)target.getAnnotationInfo().get("type"); Config.Type type = tholder == null ? Config.Type.INSTANCE : Config.Type.valueOf(tholder.getValue()); map.put(type, target); } }
/** * @param data The ASMData harvested by FML. * @return The class referred by this ASMData */ public static Class<?> getClass(ASMDataTable.ASMData data) { if (cache == null) cache = Maps.newHashMap(); Class<?> c = null; try { String name = data.getClassName(); if (cache.containsKey(name)) c = cache.get(name); else { c = Class.forName(name); cache.put(name, c); } } catch (ClassNotFoundException e) { e.printStackTrace(); } return c; }
/** * @param data The ASMData harvested by FML. * @return The class referred by this ASMData */ public static Class<?> getClassSafe(ASMDataTable.ASMData data) throws ClassNotFoundException { if (cache == null) cache = Maps.newHashMap(); Class<?> c = null; String name = data.getClassName(); if (cache.containsKey(name)) c = cache.get(name); else { c = Class.forName(name); cache.put(name, c); } return c; }
public static void scrapeData(ASMDataTable dataTable) { ImmutableList.Builder<IConfigureNEI> plugins = ImmutableList.builder(); for (ASMDataTable.ASMData data : dataTable.getAll(NEIPlugin.class.getName())) { try { Class<?> pluginClass = Class.forName(data.getClassName()); if (IConfigureNEI.class.isAssignableFrom(pluginClass)) { IConfigureNEI pluginInstance = (IConfigureNEI) pluginClass.newInstance(); plugins.add(pluginInstance); } else { LogHelper.error("Found class with annotation @NEIPlugin but class does not implement IConfigureNEI.. Class: " + data.getClassName()); } } catch (Exception e) { LogHelper.fatalError("Fatal exception occurred whilst loading a plugin! Class: %s", e, data.getClassName()); } } NEIInitialization.plugins = plugins.build(); }
private static void registerEvents(@Nonnull ASMDataTable dataTable) { String className = EventRegister.class.getCanonicalName(); Set<ASMDataTable.ASMData> dataSet = new HashSet<>(dataTable.getAll(className)); for (ASMDataTable.ASMData data : dataSet) { try { Class clazz = Class.forName(data.getClassName()); if (EventRegister.IOptionalEvent.class.isAssignableFrom(clazz)) { EventRegister.IOptionalEvent eventActive = (EventRegister.IOptionalEvent) clazz.newInstance(); if (eventActive.isActive()) { MinecraftForge.EVENT_BUS.register(clazz.newInstance()); } } else { MinecraftForge.EVENT_BUS.register(clazz.newInstance()); } } catch (Exception ignored) { } } }
/** * Loads classes with a specific annotation from an asm data table. * * Borrowed from JEI's source code, which is licensed under the MIT license. * * @param <T> The type of class to load. * @param asm The asm data table to load classes from. * @param anno The annotation marking classes of interest. * @param type The class type to load, as to get around Type erasure. * @return A list of the loaded classes, instantiated. */ private static <T> List<T> getInstances(ASMDataTable asm, Class anno, Class<T> type) { List<T> instances = new ArrayList<>(); for (ASMDataTable.ASMData asmData : asm.getAll(anno.getCanonicalName())) { try { T instance = Class.forName(asmData.getClassName()).asSubclass(type).newInstance(); instances.add(instance); } catch (ClassNotFoundException | NoClassDefFoundError | IllegalAccessException | InstantiationException e) { AgriCore.getLogger("agricraft-plugins").debug( "%nFailed to load AgriPlugin%n\tOf class: {0}!%n\tFor annotation: {1}!%n\tAs Instanceof: {2}!", asmData.getClassName(), anno.getCanonicalName(), type.getCanonicalName() ); } } return instances; }
public ModAPITransformer addModAPITransformer(ASMDataTable dataTable) { mainClassLoader.registerTransformer("net.minecraftforge.fml.common.asm.transformers.ModAPITransformer"); List<IClassTransformer> transformers = mainClassLoader.getTransformers(); ModAPITransformer modAPI = (ModAPITransformer) transformers.get(transformers.size()-1); modAPI.initTable(dataTable); return modAPI; }
public void sendToTable(ASMDataTable table, ModCandidate candidate) { for (ModAnnotation ma : annotations) { table.addASMData(candidate, ma.asmType.getClassName(), this.asmType.getClassName(), ma.member, ma.values); } for (String intf : interfaces) { table.addASMData(candidate, intf, this.asmType.getInternalName(), null, null); } }
public static void inject(ModContainer mod, ASMDataTable data, Side side) { FMLLog.fine("Attempting to inject @EventBusSubscriber classes into the eventbus for %s", mod.getModId()); Set<ASMDataTable.ASMData> targets = data.getAnnotationsFor(mod).get(Mod.EventBusSubscriber.class.getName()); ClassLoader mcl = Loader.instance().getModClassLoader(); for (ASMDataTable.ASMData targ : targets) { try { //noinspection unchecked List<ModAnnotation.EnumHolder> sidesEnum = (List<ModAnnotation.EnumHolder>)targ.getAnnotationInfo().get("value"); EnumSet<Side> sides = DEFAULT; if (sidesEnum != null) { sides = EnumSet.noneOf(Side.class); for (ModAnnotation.EnumHolder h: sidesEnum) { sides.add(Side.valueOf(h.getValue())); } } if (sides == DEFAULT || sides.contains(side)) { FMLLog.fine("Found @EventBusSubscriber class %s", targ.getClassName()); Class<?> subscriptionTarget = Class.forName(targ.getClassName(), true, mcl); MinecraftForge.EVENT_BUS.register(subscriptionTarget); FMLLog.fine("Injected @EventBusSubscriber class %s", targ.getClassName()); } } catch (Exception e) { FMLLog.log(Level.ERROR, e, "An error occurred trying to load an EventBusSubscriber %s for modid %s", targ.getClassName(), mod.getModId()); throw new LoaderException(e); } } }
/** * Used to setup a testharness with a single dummy mod instance for use with various testing hooks * @param dummycontainer A dummy container that will be returned as "active" for all queries */ public void setupTestHarness(ModContainer dummycontainer) { modController = new LoadController(this); mods = Lists.newArrayList(dummycontainer); modController.transition(LoaderState.LOADING, false); modController.transition(LoaderState.CONSTRUCTING, false); ObjectHolderRegistry.INSTANCE.findObjectHolders(new ASMDataTable()); modController.forceActiveContainer(dummycontainer); }
@SuppressWarnings("unchecked") public FMLConstructionEvent(Object... eventData) { this.modClassLoader = (ModClassLoader)eventData[0]; this.asmData = (ASMDataTable) eventData[1]; this.reverseDependencies = (ListMultimap<String, String>) eventData[2]; }
public void initTable(ASMDataTable dataTable) { optionals = ArrayListMultimap.create(); Set<ASMData> interfaceLists = dataTable.getAll("net.minecraftforge.fml.common.Optional$InterfaceList"); addData(unpackInterfaces(interfaceLists)); Set<ASMData> interfaces = dataTable.getAll("net.minecraftforge.fml.common.Optional$Interface"); addData(interfaces); Set<ASMData> methods = dataTable.getAll("net.minecraftforge.fml.common.Optional$Method"); addData(methods); }
public static Field getField(ASMDataTable.ASMData data) { try { return getClass(data).getField(data.getObjectName()); } catch (NoSuchFieldException e) { return null; } }
public final void addCache(String modid, ASMDataTable.ASMData data) { if (modid == null) modid = ASMDataUtil.getModId(data); Class<?> clz = ASMDataUtil.getClass(data); Class<? extends T> type = TypeUtils.getGenericTypeTo(this); T annotation = ASMDataUtil.getAnnotation(data, type); Optional<Field> f = Optional.fromNullable(ASMDataUtil.getField(data)); Optional<Object> o = ASMDataUtil.getObject(data); cache.add(new ASMCache(clz, modid, annotation, o, f)); }
public static <T> List<T> getInstances (ASMDataTable asmDataTable, Class<? extends Annotation> annotationClass, Class<T> instanceClass) { final String annotationClassName = annotationClass.getCanonicalName(); final Set<ASMDataTable.ASMData> asmDatas = asmDataTable.getAll(annotationClassName); final List<T> instances = new ArrayList<>(); for (final ASMDataTable.ASMData asmData : asmDatas) try { instances.add(Class.forName(asmData.getClassName()).asSubclass(instanceClass).newInstance()); } catch (final Exception e) { MMDLib.LOG.error("Failed to load: {}", asmData.getClassName(), e); } return instances; }
public static void registerCommands(@Nonnull ASMDataTable asmDataTable) { String annotationClassName = Command.class.getCanonicalName(); Set<ASMData> asmDatas = new HashSet<ASMData>(asmDataTable.getAll(annotationClassName)); for (ASMDataTable.ASMData asmData : asmDatas) { try { Class<?> asmClass = Class.forName(asmData.getClassName()); Class<? extends AbstractCommand> asmInstanceClass = asmClass.asSubclass(AbstractCommand.class); AbstractCommand instance = asmInstanceClass.newInstance(); CommandManager.INSTANCE.registerCommand(instance); } catch (Exception e) { e.printStackTrace(); } } }
/** * Attempts to find mod integrations. */ private void findIntegrations(ASMDataTable asmDataTable){ ACLogger.info("Starting the Integration Handler."); fetchModIntegrations(asmDataTable); if(!temp.isEmpty()) ACLogger.info("Preliminary integration search complete: found %d possible mod integration(s)!", temp.size()); }
private <T> List<T> fetchPlugins(ASMDataTable asmDataTable, Class annotationClass, Class<T> instanceClass){ String annotationClassName = annotationClass.getCanonicalName(); Set<ASMDataTable.ASMData> asmDatas = asmDataTable.getAll(annotationClassName); List<T> instances = new ArrayList<>(); for (ASMDataTable.ASMData asmData : asmDatas) try { Class<?> asmClass = Class.forName(asmData.getClassName()); Class<? extends T> asmInstanceClass = asmClass.asSubclass(instanceClass); T instance = asmInstanceClass.newInstance(); instances.add(instance); } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) { ACLogger.severe("Failed to load: {}", asmData.getClassName(), e); } return instances; }
public void fillAllHolders(ASMDataTable data) { final Map<Field, Class<?>> classTargetToSource = Maps.newHashMap(); final Map<Field, Class<?>> fieldTargetToSource = Maps.newHashMap(); for (ASMData target : data.getAll(TypeVariableHolder.class.getName())) findTargets(target, classTargetToSource, fieldTargetToSource); fillFields(classTargetToSource, fieldTargetToSource); }
private static <A> void fillTargetFields(final ApiProviderRegistry<A> registry, ASMDataTable table, Class<? extends Annotation> fieldMarker, Class<A> interfaceMarker) { final ClassInfoCache clsCache = new ClassInfoCache(); final Set<ASMData> targets = table.getAll(fieldMarker.getName()); for (ASMData data : targets) fillTargetField(clsCache, registry, data, interfaceMarker); }
public <A> ApiProviderRegistry<A> createApi(Class<? extends Annotation> fieldMarker, Class<A> interfaceMarker, ASMDataTable table, ApiProviderSetup<A> registrySetup) { Preconditions.checkState(apis.add(fieldMarker), "Duplicate API registration on %s", fieldMarker); final ApiProviderRegistry<A> registry = new ApiProviderRegistry<>(interfaceMarker); registrySetup.setup(registry); registry.freeze(); fillTargetFields(registry, table, fieldMarker, interfaceMarker); return registry; }
public static void loadPlugins(ASMDataTable asmData) { for(IHarshenPlugin plugin : HarshenUtils.getInstancesOfAnnotation(asmData, HarshenPlugin.class, IHarshenPlugin.class)) if(plugin.getModID() != HarshenCastle.MODID) ALL_PLUGINS.add(plugin); else ALL_PLUGINS.add(0, plugin); }
private void initPlugins(ASMDataTable asmDataTable) { plugins = PluginHelper.getPluginInstances(asmDataTable); plugins.forEach(plugin -> plugin.registerContent(contentRegistry)); }
public static void inject(ModContainer mod, ASMDataTable data, Side side, ILanguageAdapter languageAdapter) { FMLLog.fine("Attempting to inject @SidedProxy classes into %s", mod.getModId()); Set<ASMData> targets = data.getAnnotationsFor(mod).get(SidedProxy.class.getName()); ClassLoader mcl = Loader.instance().getModClassLoader(); for (ASMData targ : targets) { try { Class<?> proxyTarget = Class.forName(targ.getClassName(), true, mcl); Field target = proxyTarget.getDeclaredField(targ.getObjectName()); if (target == null) { // Impossible? FMLLog.severe("Attempted to load a proxy type into %s.%s but the field was not found", targ.getClassName(), targ.getObjectName()); throw new LoaderException(String.format("Attempted to load a proxy type into %s.%s but the field was not found", targ.getClassName(), targ.getObjectName())); } target.setAccessible(true); SidedProxy annotation = target.getAnnotation(SidedProxy.class); if (!Strings.isNullOrEmpty(annotation.modId()) && !annotation.modId().equals(mod.getModId())) { FMLLog.fine("Skipping proxy injection for %s.%s since it is not for mod %s", targ.getClassName(), targ.getObjectName(), mod.getModId()); continue; } String targetType = side.isClient() ? annotation.clientSide() : annotation.serverSide(); if(targetType.equals("")) { targetType = targ.getClassName() + (side.isClient() ? "$ClientProxy" : "$ServerProxy"); } Object proxy=Class.forName(targetType, true, mcl).newInstance(); if (languageAdapter.supportsStatics() && (target.getModifiers() & Modifier.STATIC) == 0 ) { FMLLog.severe("Attempted to load a proxy type %s into %s.%s, but the field is not static", targetType, targ.getClassName(), targ.getObjectName()); throw new LoaderException(String.format("Attempted to load a proxy type %s into %s.%s, but the field is not static", targetType, targ.getClassName(), targ.getObjectName())); } if (!target.getType().isAssignableFrom(proxy.getClass())) { FMLLog.severe("Attempted to load a proxy type %s into %s.%s, but the types don't match", targetType, targ.getClassName(), targ.getObjectName()); throw new LoaderException(String.format("Attempted to load a proxy type %s into %s.%s, but the types don't match", targetType, targ.getClassName(), targ.getObjectName())); } languageAdapter.setProxy(target, proxyTarget, proxy); } catch (Exception e) { FMLLog.log(Level.ERROR, e, "An error occurred trying to load a proxy into %s.%s", targ.getAnnotationInfo(), targ.getClassName(), targ.getObjectName()); throw new LoaderException(e); } } // Allow language specific proxy injection. languageAdapter.setInternalProxies(mod, side, mcl); }
public ASMDataTable getASMHarvestedData() { return asmData; }
public FMLPreInitializationEvent(Object... data) { super(data); this.asmData = (ASMDataTable)data[0]; this.configurationDir = (File)data[1]; }
public ASMDataTable getASMData() { return asmDataTable; }
/** * @param data The ASMData harvested by FML. * @return The mod's id of the ASMData referring to. */ public static String getModId(ASMDataTable.ASMData data) { return data.getCandidate().getContainedMods().get(0).getModId(); }
public static void init (ASMDataTable asmDataTable) { loaded = true; for (final Entry<Feature, DUFeature> feature : AnnotationUtils.getAnnotations(asmDataTable, DUFeature.class, Feature.class).entrySet()) { final DUFeature annotation = feature.getValue(); if (annotation == null) { Constants.LOG.warn("Annotation for " + feature.getKey().getClass().getCanonicalName() + " was null!"); continue; } registerFeature(feature.getKey(), annotation.name(), annotation.description()); } features.sort( (o1, o2) -> o2.configName.compareTo(o1.configName)); }
public AnnotationUtil(ASMDataTable asmData) { this.asmData = asmData; }
public void registerAnnotations(@Nonnull ASMDataTable data) { registerEvents(data); }
/** * Initializes the ConfigurationHandler. This should be called after you create your * configuration handler. * * @param table The ASMDataTable. You can get this from your fml construction events. */ public void init (ASMDataTable table) { if (CLASS_CACHE.isEmpty()) { for (final Tuple<Class<?>, Config> data : AnnotationUtils.getAnnotatedClasses(table, Config.class)) { if (data.getSecond() != null) { CLASS_CACHE.put(data.getSecond().name(), data.getFirst()); } } } this.properties = AnnotationUtils.getAnnotatedFields(CLASS_CACHE.get(this.name), Configurable.class).toArray(new Field[] {}); }
/** * Gets all classes annotated with the annotation class. * * @param table The ASMDataTable. This is generated from forge and can be accessed from the * initialization events. * @param annotation The annotation to search for. * @return A list of all classes with the passed annotation. */ public static <A extends Annotation> List<Tuple<Class<?>, A>> getAnnotatedClasses (ASMDataTable table, Class<A> annotation) { final List<Tuple<Class<?>, A>> classes = new ArrayList<>(); for (final ASMData data : getData(table, annotation)) { try { final Class clazz = Class.forName(data.getClassName()); if (clazz != null) { classes.add(new Tuple<Class<?>, A>(clazz, (A) clazz.getAnnotation(annotation))); } } catch (final ClassNotFoundException e) { Constants.LOG.warn(e, "Could not load class {} ", data.getClassName()); } } return classes; }
/** * Finds all classes annotated with the annotation class. These classes are then * instantiated, added to a list, and given to you. * * @param table The ASMDataTable created by Forge. You can get this from most of the main * mod loading stage events. * @param annotation The class of the annotation you're using to search for. * @param instance The class of the thing you're trying to construct. This should be a * shared interface, or parent class. * @return A list of all classes annotated with the annotation, as instances. */ public static <T, A extends Annotation> Map<T, A> getAnnotations (ASMDataTable table, Class<A> annotation, Class<T> instance) { final Map<T, A> map = new HashMap<>(); for (final ASMDataTable.ASMData asmData : getData(table, annotation)) { try { final Class<?> asmClass = Class.forName(asmData.getClassName()); final Class<? extends T> asmInstanceClass = asmClass.asSubclass(instance); map.put(asmInstanceClass.newInstance(), asmInstanceClass.getAnnotation(annotation)); } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) { Constants.LOG.warn(e, "Could not load class {}", asmData.getClassName()); } } return map; }
public void preInit(ASMDataTable asm) { //Create the API ProgressionAPI.registry = new APIHandler(); ProgressionAPI.player = new PlayerHandler(); ProgressionAPI.filters = new FilterSelectorHelper(); ProgressionAPI.fields = new FieldRegistry(); //Register Handlers MinecraftForge.EVENT_BUS.register(CommandManager.INSTANCE); MinecraftForge.EVENT_BUS.register(new PlayerTracker()); MinecraftForge.EVENT_BUS.register(new ProgressionEvents()); //Register the items Progression.item = (ItemProgression) new ItemProgression().setUnlocalizedName("item").setRegistryName("item"); GameRegistry.register(Progression.item); GameRegistry.addRecipe(new ShapedOreRecipe(getStackFromMeta(book), "FS", "PP", 'P', Items.PAPER, 'S', Items.STRING, 'F', FLINT)); if (Options.tileClaimerRecipe) { GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(Progression.item, 1, ItemProgression.ItemMeta.claim.ordinal()), new Object[] { "F", "P", 'F', Items.FLINT, 'P', "plankWood" })); } RuleHandler.registerRules(asm); CommandManager.registerCommands(asm); PacketHandler.registerPackets(asm); //Register DamageSources ProgressionAPI.registry.registerDamageSource(DamageSource.anvil); ProgressionAPI.registry.registerDamageSource(DamageSource.cactus); ProgressionAPI.registry.registerDamageSource(DamageSource.drown); ProgressionAPI.registry.registerDamageSource(DamageSource.fall); ProgressionAPI.registry.registerDamageSource(DamageSource.fallingBlock); ProgressionAPI.registry.registerDamageSource(DamageSource.generic); ProgressionAPI.registry.registerDamageSource(DamageSource.inFire); ProgressionAPI.registry.registerDamageSource(DamageSource.inWall); ProgressionAPI.registry.registerDamageSource(DamageSource.lava); ProgressionAPI.registry.registerDamageSource(DamageSource.lightningBolt); ProgressionAPI.registry.registerDamageSource(DamageSource.magic); ProgressionAPI.registry.registerDamageSource(DamageSource.onFire); ProgressionAPI.registry.registerDamageSource(DamageSource.outOfWorld); ProgressionAPI.registry.registerDamageSource(DamageSource.starve); ProgressionAPI.registry.registerDamageSource(DamageSource.wither); ProgressionAPI.registry.registerDamageSource(DamageSource.flyIntoWall); ProgressionAPI.registry.registerDamageSource(DamageSource.dragonBreath); NetworkRegistry.INSTANCE.registerGuiHandler(Progression.instance, Progression.proxy); }
public static void registerRules(@Nonnull ASMDataTable asmDataTable) { Class annotationClass = ProgressionRule.class; String annotationClassName = annotationClass.getCanonicalName(); Set<ASMData> asmDatas = new HashSet<ASMData>(asmDataTable.getAll(annotationClassName)); topLoop: for (ASMDataTable.ASMData asmData : asmDatas) { try { Class<?> asmClass = Class.forName(asmData.getClassName()); Class<? extends IRule> asmInstanceClass = asmClass.asSubclass(IRule.class); IRule instance = asmInstanceClass.newInstance(); Map<String, Object> data = asmData.getAnnotationInfo(); String modData = (String) data.get("mod"); if (modData != null) { String[] mods = modData.replace(" ", "").split(","); for (String mod: mods) { if (mod != null && !Loader.isModLoaded(mod)) continue topLoop; } } String name = (String) data.get("name"); int color = 0xFFCCCCCC; if (data.get("color") != null) { color = (Integer) data.get("color"); } String icon = (String) data.get("icon"); String meta = (String) data.get("meta"); boolean isCancelable = false; if (data.get("cancelable") != null) { isCancelable = (Boolean) data.get("cancelable"); } ItemStack stack = StackHelper.getStackFromString(icon); if (stack == null) stack = new ItemStack(Progression.item); if (meta != null) { for (ItemMeta item: ItemMeta.values()) { if (item.name().equalsIgnoreCase(meta)) { stack.setItemDamage(item.ordinal()); break; } } } if (instance instanceof IReward) { APIHandler.registerRewardType(instance, name, color).setIcon(stack); } else if (instance instanceof ITrigger) { ITriggerProvider provider = APIHandler.registerTriggerType(instance, name, color).setIcon(stack); if (isCancelable) { provider.setCancelable(); } } else if (instance instanceof ICondition) { APIHandler.registerConditionType(instance, name).setIcon(stack); } else if (instance instanceof IFilter) { APIHandler.registerFilterType(instance, name, color); } } catch (Exception e) { e.printStackTrace(); } } }
private void fetchModIntegrations(ASMDataTable asmDataTable){ List<IACPlugin> plugins = fetchPlugins(asmDataTable, ACPlugin.class, IACPlugin.class); if(!plugins.isEmpty()) for(IACPlugin plugin : plugins) temp.add(plugin); }
public void installHolderAccess(ASMDataTable table) { ApiFactory.instance.createApi(ApiHolder.class, IApiInterface.class, table, registry); }