refactoring enumerator

Mumfrey
1 parent 1ef9f4cf
Showing 14 changed files with 704 additions and 370 deletions
java/common/com/mumfrey/liteloader/api/ContainerRegistry.java
java/common/com/mumfrey/liteloader/api/EnumerationObserver.java
java/common/com/mumfrey/liteloader/api/EnumeratorPlugin.java
java/common/com/mumfrey/liteloader/api/ModClassValidator.java
java/common/com/mumfrey/liteloader/core/Containers.java
java/common/com/mumfrey/liteloader/core/LiteLoaderBootstrap.java
java/common/com/mumfrey/liteloader/core/LiteLoaderEnumerator.java
java/common/com/mumfrey/liteloader/core/LiteLoaderMods.java
java/common/com/mumfrey/liteloader/core/api/DefaultClassValidator.java
java/common/com/mumfrey/liteloader/core/api/DefaultEnumeratorPlugin.java
java/common/com/mumfrey/liteloader/interfaces/LoaderEnumerator.java
java/common/com/mumfrey/liteloader/interfaces/ModularEnumerator.java
java/common/com/mumfrey/liteloader/launch/LoaderEnvironment.java
java/common/com/mumfrey/liteloader/transformers/event/json/ModEvents.java
+package com.mumfrey.liteloader.api;
+
+import java.io.File;
+import java.util.Collection;
+
+import com.mumfrey.liteloader.core.ModInfo;
+import com.mumfrey.liteloader.interfaces.Loadable;
+import com.mumfrey.liteloader.interfaces.LoadableMod;
+import com.mumfrey.liteloader.interfaces.TweakContainer;
+
+/**
+ * Registry for enabled, disabled, injected and bad containers
+ * 
+ * @author Adam Mummery-Smith
+ */
+public interface ContainerRegistry
+{
+	public enum DisabledReason
+	{
+		UNKNOWN("Container %s is could not be loaded for UNKNOWN reason"),
+		USER_DISABLED("Container %s is disabled"),
+		MISSING_DEPENDENCY("Container %s is missing one or more dependencies"),
+		MISSING_API("Container %s is missing one or more required APIs");
+		
+		private final String message;
+		
+		private DisabledReason(String message)
+		{
+			this.message = message;
+		}
+
+		public String getMessage(LoadableMod<?> container)
+		{
+			return String.format(this.message, container);
+		}
+	}
+
+	/**
+	 * Register an enabled container, removes the container from the disabled containers list if present
+	 */
+	public abstract void registerEnabledContainer(LoadableMod<?> container);
+	
+	/**
+	 * Get all enabled containers
+	 */
+	public abstract Collection<? extends LoadableMod<?>> getEnabledContainers();
+	
+	/**
+	 * Get a specific enabled container by id
+	 */
+	public abstract LoadableMod<?> getEnabledContainer(String identifier);
+
+	/**
+	 * Register a disabled container
+	 */
+	public abstract void registerDisabledContainer(LoadableMod<?> container, DisabledReason reason);
+	
+	/**
+	 * Get all disabled containers
+	 */
+	public abstract Collection<? extends ModInfo<Loadable<?>>> getDisabledContainers();
+	
+	/**
+	 * Check whether a specific container is registered as disabled
+	 */
+	public abstract boolean isDisabledContainer(LoadableMod<?> container);
+	
+	/**
+	 * Register a bad container
+	 */
+	public abstract void registerBadContainer(Loadable<?> container, String reason);
+	
+	/**
+	 * Get all bad containers
+	 */
+	public abstract Collection<? extends ModInfo<Loadable<?>>> getBadContainers();
+	
+	/**
+	 * Register a candidate tweak container
+	 */
+	public abstract void registerTweakContainer(TweakContainer<File> container);
+	
+	/**
+	 * Get all registered tweak containers
+	 */
+	public abstract Collection<TweakContainer<File>> getTweakContainers();
+
+	/**
+	 * Register an injected tweak container
+	 */
+	public abstract void registerInjectedTweak(TweakContainer<File> container);
+	
+	/**
+	 * Get all injected tweak containers
+	 */
+	public abstract Collection<? extends ModInfo<Loadable<?>>> getInjectedTweaks();
+}
@@ -2,10 +2,10 @@ package com.mumfrey.liteloader.api;
 import java.io.File;
+import com.mumfrey.liteloader.api.ContainerRegistry.DisabledReason;
 import com.mumfrey.liteloader.core.ModInfo;
 import com.mumfrey.liteloader.interfaces.LoadableMod;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
-import com.mumfrey.liteloader.interfaces.LoaderEnumerator.DisabledReason;
 import com.mumfrey.liteloader.interfaces.TweakContainer;
 /**
+package com.mumfrey.liteloader.api;
+
+import java.util.List;
+
+import com.mumfrey.liteloader.interfaces.LoadableMod;
+import com.mumfrey.liteloader.launch.LoaderEnvironment;
+import com.mumfrey.liteloader.launch.LoaderProperties;
+
+/**
+ * LiteLoader Extensible API - Interface for objects which can interact with the enumeration process, not yet available to APIs
+ * 
+ * @author Adam Mummery-Smith
+ */
+public interface EnumeratorPlugin
+{
+	/**
+	 * Initialise this plugin
+	 */
+	public abstract void init(LoaderEnvironment environment, LoaderProperties properties);
+
+	/**
+	 * Get classes in the supplied container
+	 * 
+	 * @param container Container to inspect
+	 * @param classloader ClassLoader for this container
+	 * @param superClass Superclass the class must implement
+	 * @param supportedPrefixes Registered class prefixes
+	 * @return
+	 */
+	public abstract <T> List<Class<? extends T>> getClasses(LoadableMod<?> container, ClassLoader classloader, ModClassValidator validator);
+
+	public abstract boolean checkEnabled(ContainerRegistry containers, LoadableMod<?> container);
+	
+	public abstract boolean checkDependencies(ContainerRegistry containers, LoadableMod<?> base);
+
+	public abstract boolean checkAPIRequirements(ContainerRegistry containers, LoadableMod<?> container);
+}
+package com.mumfrey.liteloader.api;
+
+/**
+ * Interface for object which validates whether a supplied mod class can be loaded
+ *
+ * @author Adam Mummery-Smith
+ */
+public interface ModClassValidator
+{
+	public abstract boolean validateName(String className);
+	
+	public abstract boolean validateClass(ClassLoader classLoader, Class<?> candidateClass);
+}
+package com.mumfrey.liteloader.core;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.mumfrey.liteloader.api.ContainerRegistry;
+import com.mumfrey.liteloader.interfaces.Loadable;
+import com.mumfrey.liteloader.interfaces.LoadableMod;
+import com.mumfrey.liteloader.interfaces.TweakContainer;
+
+/**
+ * Implementation of ContainerRegistry for LiteLoaderEnumerator
+ * 
+ * @author Adam Mummery-Smith
+ */
+class Containers implements ContainerRegistry
+{
+	/**
+	 * Mod containers which are disabled 
+	 */
+	private final Map<String, ModInfo<Loadable<?>>> disabledContainers = new HashMap<String, ModInfo<Loadable<?>>>();
+
+	/**
+	 * Mapping of identifiers to mod containers 
+	 */
+	private final Map<String, LoadableMod<?>> enabledContainers = new HashMap<String, LoadableMod<?>>();
+
+	/**
+	 * Map of containers which cannot be loaded to reasons
+	 */
+	private final Set<ModInfo<Loadable<?>>> badContainers = new HashSet<ModInfo<Loadable<?>>>();
+	
+	/**
+	 * Tweaks to inject 
+	 */
+	private final List<TweakContainer<File>> tweakContainers = new ArrayList<TweakContainer<File>>();
+	
+	/**
+	 * Other tweak-containing jars which we have injected 
+	 */
+	private final List<ModInfo<Loadable<?>>> injectedTweaks = new ArrayList<ModInfo<Loadable<?>>>();
+	
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#getDisabledContainers()
+	 */
+	@Override
+	public Collection<? extends ModInfo<Loadable<?>>> getDisabledContainers()
+	{
+		return this.disabledContainers.values();
+	}
+	
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#getEnabledContainers()
+	 */
+	@Override
+	public Collection<? extends LoadableMod<?>> getEnabledContainers()
+	{
+		return this.enabledContainers.values();
+	}
+	
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#getBadContainers()
+	 */
+	@Override
+	public Collection<? extends ModInfo<Loadable<?>>> getBadContainers()
+	{
+		return this.badContainers;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#getTweakContainers()
+	 */
+	@Override
+	public List<TweakContainer<File>> getTweakContainers()
+	{
+		return this.tweakContainers;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#getInjectedTweaks()
+	 */
+	@Override
+	public List<? extends ModInfo<Loadable<?>>> getInjectedTweaks()
+	{
+		return this.injectedTweaks;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#isDisabledContainer(com.mumfrey.liteloader.interfaces.LoadableMod)
+	 */
+	@Override
+	public boolean isDisabledContainer(LoadableMod<?> container)
+	{
+		return this.disabledContainers.containsValue(container);
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#getEnabledContainer(java.lang.String)
+	 */
+	@Override
+	public LoadableMod<?> getEnabledContainer(String identifier)
+	{
+		LoadableMod<?> container = this.enabledContainers.get(identifier);
+		return container != null ? container : LoadableMod.NONE;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#registerBadContainer(com.mumfrey.liteloader.interfaces.Loadable, java.lang.String)
+	 */
+	@Override
+	public void registerBadContainer(Loadable<?> container, String reason)
+	{
+		this.badContainers.add(new BadContainerInfo(container, reason));
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#registerEnabledContainer(com.mumfrey.liteloader.interfaces.LoadableMod)
+	 */
+	@Override
+	public void registerEnabledContainer(LoadableMod<?> container)
+	{
+		this.disabledContainers.remove(container.getIdentifier());
+		this.enabledContainers.put(container.getIdentifier(), container);
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#registerDisabledContainer(com.mumfrey.liteloader.interfaces.LoadableMod, com.mumfrey.liteloader.api.ContainerRegistry.DisabledReason)
+	 */
+	@Override
+	public void registerDisabledContainer(LoadableMod<?> container, DisabledReason reason)
+	{
+		this.enabledContainers.remove(container.getIdentifier());
+		this.disabledContainers.put(container.getIdentifier(), new NonMod(container, false));
+	}
+	
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#registerTweakContainer(com.mumfrey.liteloader.interfaces.TweakContainer)
+	 */
+	@Override
+	public void registerTweakContainer(TweakContainer<File> container)
+	{
+		this.tweakContainers.add(container);
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.ContainerRegistry#registerInjectedTweak(com.mumfrey.liteloader.interfaces.TweakContainer)
+	 */
+	@Override
+	public void registerInjectedTweak(TweakContainer<File> container)
+	{
+		this.injectedTweaks.add(new NonMod(container, true));
+	}
+}
@@ -27,6 +27,8 @@ import com.mumfrey.liteloader.api.manager.APIRegistry;
 import com.mumfrey.liteloader.common.LoadingProgress;
 import com.mumfrey.liteloader.core.api.LiteLoaderCoreAPI;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
+import com.mumfrey.liteloader.launch.ClassTransformerManager;
+import com.mumfrey.liteloader.launch.LiteLoaderTweaker;
 import com.mumfrey.liteloader.launch.LoaderBootstrap;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
@@ -259,9 +261,25 @@ class LiteLoaderBootstrap implements LoaderBootstrap, LoaderEnvironment, LoaderP
 	}
 	@Override
-	public ITweaker getTweaker()
+	public boolean addCascadedTweaker(String tweakClass, int priority)
 	{
-		return this.tweaker;
+		if (this.tweaker instanceof LiteLoaderTweaker)
+		{
+			return ((LiteLoaderTweaker)this.tweaker).addCascadedTweaker(tweakClass, priority);
+		}
+		
+		return false;
+	}
+	
+	@Override
+	public ClassTransformerManager getTransformerManager()
+	{
+		if (this.tweaker instanceof LiteLoaderTweaker)
+		{
+			return ((LiteLoaderTweaker)this.tweaker).getTransformerManager();
+		}
+		
+		return null;
 	}
 	/* (non-Javadoc)
@@ -9,7 +9,6 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -19,17 +18,22 @@ import net.minecraft.launchwrapper.LaunchClassLoader;
 import com.google.common.base.Throwables;
 import com.mumfrey.liteloader.LiteMod;
+import com.mumfrey.liteloader.api.ContainerRegistry;
+import com.mumfrey.liteloader.api.ContainerRegistry.DisabledReason;
 import com.mumfrey.liteloader.api.EnumerationObserver;
 import com.mumfrey.liteloader.api.EnumeratorModule;
+import com.mumfrey.liteloader.api.EnumeratorPlugin;
 import com.mumfrey.liteloader.api.LiteAPI;
-import com.mumfrey.liteloader.api.manager.APIProvider;
+import com.mumfrey.liteloader.api.ModClassValidator;
+import com.mumfrey.liteloader.core.api.DefaultClassValidator;
+import com.mumfrey.liteloader.core.api.DefaultEnumeratorPlugin;
 import com.mumfrey.liteloader.core.event.HandlerList;
-import com.mumfrey.liteloader.core.exceptions.OutdatedLoaderException;
 import com.mumfrey.liteloader.interfaces.FastIterableDeque;
 import com.mumfrey.liteloader.interfaces.Loadable;
 import com.mumfrey.liteloader.interfaces.LoadableMod;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
 import com.mumfrey.liteloader.interfaces.TweakContainer;
+import com.mumfrey.liteloader.launch.ClassTransformerManager;
 import com.mumfrey.liteloader.launch.LiteLoaderTweaker;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
@@ -73,55 +77,32 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	private final LoaderEnvironment environment;
 	private final LoaderProperties properties;
-	
-	private final LiteLoaderTweaker tweaker;
 	/**
 	 * Reference to the launch classloader
 	 */
 	private final LaunchClassLoader classLoader;
-
-	/**
-	 * Classes to load, mapped by class name 
-	 */
-	private final Set<ModInfo<LoadableMod<?>>> modsToLoad = new LinkedHashSet<ModInfo<LoadableMod<?>>>();
 	/**
-	 * Mod containers which are disabled 
-	 */
-	private final Map<String, ModInfo<Loadable<?>>> disabledContainers = new HashMap<String, ModInfo<Loadable<?>>>();
-
-	/**
-	 * Mapping of identifiers to mod containers 
-	 */
-	private final Map<String, LoadableMod<?>> enabledContainers = new HashMap<String, LoadableMod<?>>();
-
-	/**
-	 * Map of containers which cannot be loaded to reasons
+	 * 
 	 */
-	private final Set<ModInfo<Loadable<?>>> badContainers = new HashSet<ModInfo<Loadable<?>>>();
+	private final List<EnumeratorModule> modules = new ArrayList<EnumeratorModule>();
-	/**
-	 * Containers which have already been checked for potential mod candidates 
-	 */
-	private final Set<LoadableMod<?>> enumeratedContainers = new HashSet<LoadableMod<?>>();
+	private final List<EnumeratorPlugin> plugins = new ArrayList<EnumeratorPlugin>();
-	/**
-	 * Tweaks to inject 
-	 */
-	private final List<TweakContainer<File>> tweakContainers = new ArrayList<TweakContainer<File>>();
+	private final ContainerRegistry containers = new Containers();
 	/**
-	 * Other tweak-containing jars which we have injected 
+	 * Containers which have already been checked for potential mod candidates 
 	 */
-	private final List<ModInfo<Loadable<?>>> injectedTweaks = new ArrayList<ModInfo<Loadable<?>>>();
+	private final Set<LoadableMod<?>> enumeratedContainers = new HashSet<LoadableMod<?>>();
 	/**
-	 * 
+	 * Classes to load, mapped by class name 
 	 */
-	private final List<EnumeratorModule> modules = new ArrayList<EnumeratorModule>();
+	private final Set<ModInfo<LoadableMod<?>>> modsToLoad = new LinkedHashSet<ModInfo<LoadableMod<?>>>();
-	private final String[] supportedPrefixes;
+	private final ModClassValidator validator;
 	private final FastIterableDeque<EnumerationObserver> observers = new HandlerList<EnumerationObserver>(EnumerationObserver.class);
@@ -136,9 +117,11 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	{
 		this.environment       = environment;
 		this.properties        = properties;
-		this.tweaker           = (LiteLoaderTweaker)environment.getTweaker();
 		this.classLoader       = classLoader;
-		this.supportedPrefixes = this.getSupportedPrefixes(environment);
+		this.validator         = this.getValidator(environment);
+
+		this.initModules(environment);
+		this.registerPlugin(new DefaultEnumeratorPlugin());
 		// Initialise observers
 		this.observers.addAll(environment.getAPIAdapter().getPreInitObservers(EnumerationObserver.class));
@@ -150,12 +133,30 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	/**
 	 * @param environment
 	 */
-	private String[] getSupportedPrefixes(LoaderEnvironment environment)
+	private ModClassValidator getValidator(LoaderEnvironment environment)
 	{
 		List<String> prefixes = new ArrayList<String>();
 		for (LiteAPI api : environment.getAPIProvider().getAPIs())
 		{
+			String prefix = api.getModClassPrefix();
+			if (prefix != null)
+			{
+				LiteLoaderLogger.info("Adding supported mod class prefix '%s'", prefix);
+				prefixes.add(prefix);
+			}
+		}
+		
+		return new DefaultClassValidator<LiteMod>(LiteMod.class, prefixes);
+	}
+	
+	/**
+	 * @param environment
+	 */
+	private void initModules(LoaderEnvironment environment)
+	{
+		for (LiteAPI api : environment.getAPIProvider().getAPIs())
+		{
 			List<EnumeratorModule> apiModules = api.getEnumeratorModules();
 			if (apiModules != null)
@@ -165,18 +166,9 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 					this.registerModule(module);
 				}			
 			}
-			
-			String prefix = api.getModClassPrefix();
-			if (prefix != null)
-			{
-				LiteLoaderLogger.info("Adding supported mod class prefix '%s'", prefix);
-				prefixes.add(prefix);
-			}
 		}
-		
-		return prefixes.toArray(new String[prefixes.size()]);
 	}
-	
+
 	private void checkState(EnumeratorState state, String action)
 	{
 		if (this.state != state)
@@ -243,6 +235,19 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		}
 	}
+	@Override
+	public void registerPlugin(EnumeratorPlugin plugin)
+	{
+		this.checkState(EnumeratorState.INIT, "registerPlugin");
+		
+		if (plugin != null && !this.plugins.contains(plugin))
+		{
+			LiteLoaderLogger.info("Registering enumerator plugin %s: [%s]", plugin.getClass().getSimpleName(), plugin);
+			this.plugins.add(plugin);
+			plugin.init(this.environment, this.properties);
+		}
+	}
+	
 	/**
 	 * Get the list of all enumerated mod classes to load
 	 */
@@ -250,7 +255,6 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	public Collection<? extends ModInfo<LoadableMod<?>>> getModsToLoad()
 	{
 		this.checkState(EnumeratorState.FINALISED, "getModsToLoad");
-		
 		return Collections.unmodifiableSet(this.modsToLoad);
 	}
@@ -261,27 +265,24 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	public Collection<? extends ModInfo<Loadable<?>>> getDisabledContainers()
 	{
 		this.checkState(EnumeratorState.FINALISED, "getDisabledContainers");
-		
-		return this.disabledContainers.values();
+		return this.containers.getDisabledContainers();
 	}
 	@Override
 	public Collection<? extends ModInfo<Loadable<?>>> getBadContainers()
 	{
 		this.checkState(EnumeratorState.FINALISED, "getBadContainers");
-		
-		return this.badContainers;
+		return this.containers.getBadContainers();
 	}
 	/**
 	 * Get the list of injected tweak containers
 	 */
 	@Override
-	public List<? extends ModInfo<Loadable<?>>> getInjectedTweaks()
+	public Collection<? extends ModInfo<Loadable<?>>> getInjectedTweaks()
 	{
 		this.checkState(EnumeratorState.FINALISED, "getInjectedTweaks");
-		
-		return this.injectedTweaks;
+		return this.containers.getInjectedTweaks();
 	}
 	/**
@@ -304,7 +305,6 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	public String getModMetaData(Class<? extends LiteMod> modClass, String metaDataKey, String defaultValue)
 	{
 		this.checkState(EnumeratorState.FINALISED, "getModMetaData");
-		
 		return this.getContainerForMod(modClass).getMetaValue(metaDataKey, defaultValue);
 	}
@@ -315,17 +315,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	public LoadableMod<?> getContainer(String identifier)
 	{
 		this.checkState(EnumeratorState.FINALISED, "getContainer");
-		
-		return this.getContainerById(identifier);
-	}
-
-	/**
-	 * @param identifier
-	 */
-	private LoadableMod<?> getContainerById(String identifier)
-	{
-		LoadableMod<?> container = this.enabledContainers.get(identifier);
-		return container != null ? container : LoadableMod.NONE;
+		return this.containers.getEnabledContainer(identifier);
 	}
 	/**
@@ -335,7 +325,6 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	public LoadableMod<?> getContainer(Class<? extends LiteMod> modClass)
 	{
 		this.checkState(EnumeratorState.FINALISED, "getContainer");
-		
 		return this.getContainerForMod(modClass);
 	}
@@ -403,7 +392,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	{
 		this.gotoState(EnumeratorState.INJECT);
-		for (TweakContainer<File> tweakContainer : this.tweakContainers)
+		for (TweakContainer<File> tweakContainer : this.containers.getTweakContainers())
 		{
 			this.addTweaksFrom(tweakContainer);
 		}
@@ -418,36 +407,13 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		try
 		{
 			this.gotoState(EnumeratorState.INJECT);
-			
-			for (EnumeratorModule module : this.modules)
-			{
-				try
-				{
-					module.injectIntoClassLoader(this, this.classLoader);
-				}
-				catch (Throwable th)
-				{
-					LiteLoaderLogger.warning(th, "Enumerator Module %s encountered an error whilst injecting", module.getClass().getName());
-				}
-			}
+			this.injectIntoClassLoader();
 			this.gotoState(EnumeratorState.REGISTER);
-			
-			for (EnumeratorModule module : this.modules)
-			{
-				try
-				{
-					module.registerMods(this, this.classLoader);
-				}
-				catch (Throwable th)
-				{
-					LiteLoaderLogger.warning(th, "Enumerator Module %s encountered an error whilst registering mods", module.getClass().getName());
-				}
-			}
-
-			LiteLoaderLogger.info("Mod class discovery completed");
+			this.registerMods();
 			this.gotoState(EnumeratorState.FINALISED);
+			LiteLoaderLogger.info("Mod class discovery completed");
 		}
 		catch (IllegalStateException ex) // wut?
 		{
@@ -459,6 +425,42 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		}
 	}
+	/**
+	 * 
+	 */
+	private void injectIntoClassLoader()
+	{
+		for (EnumeratorModule module : this.modules)
+		{
+			try
+			{
+				module.injectIntoClassLoader(this, this.classLoader);
+			}
+			catch (Throwable th)
+			{
+				LiteLoaderLogger.warning(th, "Enumerator Module %s encountered an error whilst injecting", module.getClass().getName());
+			}
+		}
+	}
+
+	/**
+	 * 
+	 */
+	private void registerMods()
+	{
+		for (EnumeratorModule module : this.modules)
+		{
+			try
+			{
+				module.registerMods(this, this.classLoader);
+			}
+			catch (Throwable th)
+			{
+				LiteLoaderLogger.warning(th, "Enumerator Module %s encountered an error whilst registering mods", module.getClass().getName());
+			}
+		}
+	}
+
 	/* (non-Javadoc)
 	 * @see com.mumfrey.liteloader.interfaces.ModularEnumerator#registerModContainer(com.mumfrey.liteloader.interfaces.LoadableMod)
 	 */
@@ -469,7 +471,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		if (container != null)
 		{
-			if (!container.isEnabled(this.environment))
+			if (!this.checkEnabled(container))
 			{
 				this.registerDisabledContainer(container, DisabledReason.USER_DISABLED);
 				return false;
@@ -492,14 +494,12 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		return true;
 	}
-	
+
 	@Override
 	public void registerBadContainer(Loadable<?> container, String reason)
 	{
 		this.checkState(EnumeratorState.DISCOVER, "registerBadContainer");
-		
-		BadContainerInfo badMod = new BadContainerInfo(container, reason);
-		this.badContainers.add(badMod);
+		this.containers.registerBadContainer(container, reason);
 	}
 	/**
@@ -508,10 +508,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	protected void registerEnabledContainer(LoadableMod<?> container)
 	{
 		this.checkState(EnumeratorState.DISCOVER, "registerEnabledContainer");
-		
-		this.disabledContainers.remove(container.getIdentifier());
-		this.enabledContainers.put(container.getIdentifier(), container);
-		
+		this.containers.registerEnabledContainer(container);
 		this.observers.all().onRegisterEnabledContainer(this, container);
 	}
@@ -523,10 +520,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		this.checkState(EnumeratorState.DISCOVER, "registerDisabledContainer");
 		LiteLoaderLogger.info(Verbosity.REDUCED, reason.getMessage(container));
-		
-		this.enabledContainers.remove(container.getIdentifier());
-		this.disabledContainers.put(container.getIdentifier(), new NonMod(container, false));
-
+		this.containers.registerDisabledContainer(container, reason);
 		this.observers.all().onRegisterDisabledContainer(this, container, reason);
 	}
@@ -544,7 +538,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 			return false;
 		}
-		this.tweakContainers.add(container);
+		this.containers.registerTweakContainer(container);
 		this.observers.all().onRegisterTweakContainer(this, container);
 		return true;
 	}
@@ -577,14 +571,14 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 			String tweakClass = container.getTweakClassName();
 			int tweakPriority = container.getTweakPriority();
 			LiteLoaderLogger.info(Verbosity.REDUCED, "Mod file '%s' provides tweakClass '%s', adding to Launch queue with priority %d", container.getName(), tweakClass, tweakPriority);
-			if (this.tweaker.addCascadedTweaker(tweakClass, tweakPriority))
+			if (this.environment.addCascadedTweaker(tweakClass, tweakPriority))
 			{
 				LiteLoaderLogger.info(Verbosity.REDUCED, "tweakClass '%s' was successfully added", tweakClass);
 				container.injectIntoClassPath(this.classLoader, true);
 				if (container.isExternalJar())
 				{
-					this.injectedTweaks.add(new NonMod(container, true));
+					this.containers.registerInjectedTweak(container);
 				}
 				String[] classPathEntries = container.getClassPathEntries();
@@ -618,7 +612,8 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 			for (String classTransformerClass : classTransformerClasses)
 			{
 				LiteLoaderLogger.info(Verbosity.REDUCED, "Mod file '%s' provides classTransformer '%s', adding to class loader", container.getName(), classTransformerClass);
-				if (this.tweaker.getTransformerManager().injectTransformer(classTransformerClass))
+				ClassTransformerManager transformerManager = this.environment.getTransformerManager();
+				if (transformerManager != null && transformerManager.injectTransformer(classTransformerClass))
 				{
 					LiteLoaderLogger.info(Verbosity.REDUCED, "classTransformer '%s' was successfully added", classTransformerClass);
 					container.injectIntoClassPath(this.classLoader, true);
@@ -638,7 +633,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	{
 		this.checkState(EnumeratorState.REGISTER, "registerModsFrom");
-		if (this.disabledContainers.containsValue(container))
+		if (this.containers.isDisabledContainer(container))
 		{
 			throw new IllegalArgumentException("Attempted to register mods from a disabled container '" + container.getName() + "'");
 		}
@@ -651,7 +646,15 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		this.enumeratedContainers.add(container);
-		LinkedList<Class<? extends LiteMod>> modClasses = LiteLoaderEnumerator.<LiteMod>getSubclassesFor(container, this.classLoader, LiteMod.class, this.supportedPrefixes);
+		List<Class<? extends LiteMod>> modClasses = new ArrayList<Class<? extends LiteMod>>();
+		
+		for (EnumeratorPlugin plugin : this.plugins)
+		{
+			List<Class<? extends LiteMod>> classes = plugin.getClasses(container, this.classLoader, this.validator);
+			LiteLoaderLogger.debug("Plugin %s returned %d classes for %s", plugin.getClass(), classes.size(), container.getDisplayName());
+			modClasses.addAll(classes);
+		}
+		
 		for (Class<? extends LiteMod> modClass : modClasses)
 		{
 			Mod mod = new Mod(container, modClass);
@@ -661,9 +664,7 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		if (modClasses.size() > 0)
 		{
 			LiteLoaderLogger.info("Found %d potential matches", modClasses.size());
-
-			this.disabledContainers.remove(container.getIdentifier());
-			this.enabledContainers.put(container.getIdentifier(), container);
+			this.containers.registerEnabledContainer(container);
 		}
 	}
@@ -684,169 +685,37 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		this.observers.all().onModAdded(this, mod);
 	}
-
-	/**
-	 * Enumerate classes on the classpath which are subclasses of the specified
-	 * class
-	 * 
-	 * @param superClass
-	 */
-	private static <T> LinkedList<Class<? extends T>> getSubclassesFor(LoadableMod<?> container, ClassLoader classloader, Class<T> superClass, String[] supportedPrefixes)
+	
+	private boolean checkEnabled(LoadableMod<?> container)
 	{
-		LinkedList<Class<? extends T>> classes = new LinkedList<Class<? extends T>>();
-		
-		if (container != null)
+		for (EnumeratorPlugin plugin : this.plugins)
 		{
-			try
-			{
-				for (String fullClassName : container.getContainedClassNames())
-				{
-					boolean isDefaultPackage = fullClassName.lastIndexOf('.') == -1;
-					String className = isDefaultPackage ? fullClassName : fullClassName.substring(fullClassName.lastIndexOf('.') + 1);
-					if (supportedPrefixes == null || supportedPrefixes.length == 0 || LiteLoaderEnumerator.startsWithAny(className, supportedPrefixes))
-					{
-						LiteLoaderEnumerator.<T>checkAndAddClass(classloader, superClass, classes, fullClassName);
-					}
-				}
-			}
-			catch (OutdatedLoaderException ex)
-			{
-				classes.clear();
-				LiteLoaderLogger.info(Verbosity.REDUCED, "Error searching in '%s', missing API component '%s', your loader is probably out of date", container, ex.getMessage());
-			}
-			catch (Throwable th)
-			{
-				LiteLoaderLogger.warning(th, "Enumeration error");
-			}
+			if (!plugin.checkEnabled(this.containers, container)) return false;
 		}
-		return classes;
+		return true;
 	}
-	/**
-	 * @param classloader
-	 * @param superClass
-	 * @param classes
-	 * @param className
-	 * @throws OutdatedLoaderException 
-	 */
-	private static <T> void checkAndAddClass(ClassLoader classloader, Class<T> superClass, LinkedList<Class<? extends T>> classes, String className) throws OutdatedLoaderException
+	@Override
+	public boolean checkAPIRequirements(LoadableMod<?> container)
 	{
-		if (className.indexOf('$') > -1)
-			return;
-		
-		try
+		for (EnumeratorPlugin plugin : this.plugins)
 		{
-			Class<?> subClass = classloader.loadClass(className);
-			
-			if (subClass != null && !superClass.equals(subClass) && superClass.isAssignableFrom(subClass) && !subClass.isInterface() && !classes.contains(subClass))
-			{
-				@SuppressWarnings("unchecked")
-				Class<? extends T> matchingClass = (Class<? extends T>)subClass;
-				classes.add(matchingClass);
-			}
+			if (!plugin.checkAPIRequirements(this.containers, container)) return false;
 		}
-		catch (Throwable th)
-		{
-			if (th.getCause() != null)
-			{
-				String missingClassName = th.getCause().getMessage();
-				if (th.getCause() instanceof NoClassDefFoundError && missingClassName != null)
-				{
-					if (missingClassName.startsWith("com/mumfrey/liteloader/"))
-					{
-						throw new OutdatedLoaderException(missingClassName.substring(missingClassName.lastIndexOf('/') + 1));
-					}
-					
-//					String mahClassName = LiteLoaderEnumerator.getMissingAPIHandlerClass(classloader, className);
-//					if (mahClassName != null)
-//					{
-//						LiteLoaderEnumerator.checkAndAddClass(classloader, superClass, classes, mahClassName);
-//						return;
-//					}
-				}
-			}
-			
-			LiteLoaderLogger.warning(th, "checkAndAddClass error while checking '%s'", className);
-		}
-	}
-
-//	private static String getMissingAPIHandlerClass(ClassLoader classloader, String className)
-//	{
-//		String mahTypeDescriptor = Type.getDescriptor(MissingAPIHandlerClass.class);
-//		
-//		if (classloader instanceof LaunchClassLoader)
-//		{
-//			try
-//			{
-//				byte[] basicClass = ((LaunchClassLoader)classloader).getClassBytes(className);
-//				ClassNode classNode = LiteLoaderEnumerator.readClass(basicClass);
-//				
-//				if (classNode.invisibleAnnotations != null)
-//				{
-//					for (AnnotationNode annotation : classNode.invisibleAnnotations)
-//					{
-//						if (mahTypeDescriptor.equals(annotation.desc))
-//						{
-//							return LiteLoaderEnumerator.<String>getAnnotationValue(annotation, "value");
-//						}
-//					}
-//				}
-//			}
-//			catch (IOException ex)
-//			{
-//				ex.printStackTrace();
-//			}
-//		}
-//		
-//		return null;
-//	}
-//
-//	/**
-//	 * @param basicClass
-//	 * @return
-//	 */
-//	private static ClassNode readClass(byte[] basicClass)
-//	{
-//		ClassReader classReader = new ClassReader(basicClass);
-//		ClassNode classNode = new ClassNode();
-//		classReader.accept(classNode, ClassReader.EXPAND_FRAMES);
-//		return classNode;
-//	}
-//
-//	/**
-//	 * @param annotation
-//	 * @param key
-//	 * @return
-//	 */
-//	@SuppressWarnings("unchecked")
-//	private static <T> T getAnnotationValue(AnnotationNode annotation, String key)
-//	{
-//		boolean getNextValue = false;
-//		for (Object value : annotation.values)
-//		{
-//			if (getNextValue) return (T)value;
-//			if (value.equals(key)) getNextValue = true;
-//		}
-//		return null;
-//	}
-	
+		
+		return true;
+	}
+
 	@Override
-	public boolean checkAPIRequirements(LoadableMod<?> container)
+	public boolean checkDependencies(LoadableMod<?> container)
 	{
-		boolean result = true;
-		APIProvider apiProvider = this.environment.getAPIProvider();
-		
-		for (String identifier : container.getRequiredAPIs())
+		for (EnumeratorPlugin plugin : this.plugins)
 		{
-			if (!apiProvider.isAPIAvailable(identifier))
-			{
-				container.registerMissingAPI(identifier);
-				result = false;
-			}
+			if (!plugin.checkDependencies(this.containers, container)) return false;
 		}
-		return result;
+		return true;
 	}
 	@SuppressWarnings("unchecked")
@@ -860,59 +729,6 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 		return true;
 	}
-	@Override
-	public boolean checkDependencies(LoadableMod<?> base)
-	{
-		if (base == null || !base.hasDependencies()) return true;
-		
-		HashSet<String> circularDependencySet = new HashSet<String>();
-		circularDependencySet.add(base.getIdentifier());
-		
-		boolean result = this.checkDependencies(base, base, circularDependencySet);
-		LiteLoaderLogger.info(Verbosity.REDUCED, "Dependency check for %s %s", base.getIdentifier(), result ? "passed" : "failed");
-		
-		return result;
-	}
-
-	private boolean checkDependencies(LoadableMod<?> base, LoadableMod<?> container, Set<String> circularDependencySet)
-	{
-		if (container.getDependencies().size() == 0)
-			return true;
-		
-		boolean result = true;
-		
-		for (String dependency : container.getDependencies())
-		{
-			if (!circularDependencySet.contains(dependency))
-			{
-				circularDependencySet.add(dependency);
-				
-				LoadableMod<?> dependencyContainer = this.getContainerById(dependency);
-				if (dependencyContainer != LoadableMod.NONE)
-				{
-					if (this.environment.getEnabledModsList().isEnabled(this.environment.getProfile(), dependency))
-					{
-						result &= this.checkDependencies(base, dependencyContainer, circularDependencySet);
-					}
-					else
-					{
-//						LiteLoaderLogger.warning("Dependency %s required by %s is currently disabled", dependency, base.getIdentifier());
-						base.registerMissingDependency(dependency);
-						result = false;
-					}
-				}
-				else
-				{
-//					LiteLoaderLogger.info("Dependency %s for %s is was not located, no container ", dependency, base.getIdentifier());
-					base.registerMissingDependency(dependency);
-					result = false;
-				}
-			}
-		}
-		
-		return result;
-	}
-
 	public static String getModClassName(LiteMod mod)
 	{
 		return LiteLoaderEnumerator.getModClassName(mod.getClass());
@@ -922,12 +738,4 @@ public class LiteLoaderEnumerator implements LoaderEnumerator
 	{
 		return mod.getSimpleName().substring(7);
 	}
-
-	private static boolean startsWithAny(String string, String[] candidates)
-	{
-		for (String candidate : candidates)
-			if (string.startsWith(candidate)) return true;
-		
-		return false;
-	}
 }
 \ No newline at end of file
 package com.mumfrey.liteloader.core;
 import java.io.File;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Deque;
 import java.util.HashMap;
@@ -19,7 +20,6 @@ import com.mumfrey.liteloader.interfaces.LoadableMod;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
 import com.mumfrey.liteloader.interfaces.TweakContainer;
 import com.mumfrey.liteloader.launch.ClassTransformerManager;
-import com.mumfrey.liteloader.launch.LiteLoaderTweaker;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
 import com.mumfrey.liteloader.modconfig.ConfigManager;
@@ -57,11 +57,6 @@ public class LiteLoaderMods
 	protected final LoaderEnumerator enumerator;
 	/**
-	 * Tweaker
-	 */
-	private final LiteLoaderTweaker tweaker;
-
-	/**
 	 * Configuration manager 
 	 */
 	private final ConfigManager configManager;
@@ -113,7 +108,6 @@ public class LiteLoaderMods
 		this.loader           = loader;
 		this.environment      = environment;
 		this.enumerator       = environment.getEnumerator();
-		this.tweaker          = (LiteLoaderTweaker)environment.getTweaker();
 		this.properties       = properties;
 		this.configManager    = configManager;
 	}
@@ -179,7 +173,7 @@ public class LiteLoaderMods
 	/**
 	 * Get the list of injected tweak containers
 	 */
-	public List<? extends ModInfo<Loadable<?>>> getInjectedTweaks()
+	public Collection<? extends ModInfo<Loadable<?>>> getInjectedTweaks()
 	{
 		return this.enumerator.getInjectedTweaks();
 	}
@@ -672,7 +666,7 @@ public class LiteLoaderMods
 	 */
 	private void validateModTransformers()
 	{
-		ClassTransformerManager transformerManager = this.tweaker.getTransformerManager();
+		ClassTransformerManager transformerManager = this.environment.getTransformerManager();
 		Set<String> injectedTransformers = transformerManager.getInjectedTransformers();
 		for (Mod mod : this.loadedMods)
@@ -728,7 +722,7 @@ public class LiteLoaderMods
 	{
 		if (!mod.hasClassTransformers()) return false;
-		Set<String> injectedTransformers = this.tweaker.getTransformerManager().getInjectedTransformers();
+		Set<String> injectedTransformers = this.environment.getTransformerManager().getInjectedTransformers();
 		List<String> modTransformers = ((TweakContainer<?>)mod.getContainer()).getClassTransformerClassNames();
 		for (String modTransformer : modTransformers)
+package com.mumfrey.liteloader.core.api;
+
+import java.util.List;
+
+import com.mumfrey.liteloader.api.ModClassValidator;
+
+public class DefaultClassValidator<T> implements ModClassValidator
+{
+	private final Class<T> superClass;
+	
+	private final List<String> supportedPrefixes;
+	
+	public DefaultClassValidator(Class<T> superClass, List<String> supportedPrefixes)
+	{
+		this.supportedPrefixes = supportedPrefixes;
+		this.superClass = superClass;
+	}
+
+	@Override
+	public boolean validateName(String className)
+	{
+		return this.supportedPrefixes == null || this.supportedPrefixes.size() == 0 || DefaultClassValidator.startsWithAny(className, this.supportedPrefixes);
+	}
+	
+	@Override
+	public boolean validateClass(ClassLoader classLoader, Class<?> candidateClass)
+	{
+		return (candidateClass != null && !this.superClass.equals(candidateClass) && this.superClass.isAssignableFrom(candidateClass) && !candidateClass.isInterface());
+	}
+
+	private static boolean startsWithAny(String string, List<String> candidates)
+	{
+		for (String candidate : candidates)
+			if (string.startsWith(candidate)) return true;
+		
+		return false;
+	}
+}
+package com.mumfrey.liteloader.core.api;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.mumfrey.liteloader.api.ContainerRegistry;
+import com.mumfrey.liteloader.api.EnumeratorPlugin;
+import com.mumfrey.liteloader.api.ModClassValidator;
+import com.mumfrey.liteloader.api.manager.APIProvider;
+import com.mumfrey.liteloader.core.exceptions.OutdatedLoaderException;
+import com.mumfrey.liteloader.interfaces.LoadableMod;
+import com.mumfrey.liteloader.launch.LoaderEnvironment;
+import com.mumfrey.liteloader.launch.LoaderProperties;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger.Verbosity;
+
+public class DefaultEnumeratorPlugin implements EnumeratorPlugin
+{
+	private LoaderEnvironment environment;
+
+	@Override
+	public void init(LoaderEnvironment environment, LoaderProperties properties)
+	{
+		this.environment = environment;
+	}
+	
+	@Override
+	public boolean checkEnabled(ContainerRegistry containers, LoadableMod<?> container)
+	{
+		return container.isEnabled(this.environment);
+	}
+
+	@Override
+	public boolean checkAPIRequirements(ContainerRegistry containers, LoadableMod<?> container)
+	{
+		boolean result = true;
+		APIProvider apiProvider = this.environment.getAPIProvider();
+		
+		for (String identifier : container.getRequiredAPIs())
+		{
+			if (!apiProvider.isAPIAvailable(identifier))
+			{
+				container.registerMissingAPI(identifier);
+				result = false;
+			}
+		}
+		
+		return result;
+	}
+	
+	@Override
+	public boolean checkDependencies(ContainerRegistry containers, LoadableMod<?> base)
+	{
+		if (base == null || !base.hasDependencies()) return true;
+		
+		HashSet<String> circularDependencySet = new HashSet<String>();
+		circularDependencySet.add(base.getIdentifier());
+		
+		boolean result = this.checkDependencies(containers, base, base, circularDependencySet);
+		LiteLoaderLogger.info(Verbosity.REDUCED, "Dependency check for %s %s", base.getIdentifier(), result ? "passed" : "failed");
+		
+		return result;
+	}
+
+	private boolean checkDependencies(ContainerRegistry containers, LoadableMod<?> base, LoadableMod<?> container, Set<String> circularDependencySet)
+	{
+		if (container.getDependencies().size() == 0)
+			return true;
+		
+		boolean result = true;
+		
+		for (String dependency : container.getDependencies())
+		{
+			if (!circularDependencySet.contains(dependency))
+			{
+				circularDependencySet.add(dependency);
+				
+				LoadableMod<?> dependencyContainer = containers.getEnabledContainer(dependency);
+				if (dependencyContainer != LoadableMod.NONE)
+				{
+					String identifier = dependency;
+					if (this.environment.getEnabledModsList().isEnabled(this.environment.getProfile(), identifier))
+					{
+						result &= this.checkDependencies(containers, base, dependencyContainer, circularDependencySet);
+					}
+					else
+					{
+//						LiteLoaderLogger.warning("Dependency %s required by %s is currently disabled", dependency, base.getIdentifier());
+						base.registerMissingDependency(dependency);
+						result = false;
+					}
+				}
+				else
+				{
+//					LiteLoaderLogger.info("Dependency %s for %s is was not located, no container ", dependency, base.getIdentifier());
+					base.registerMissingDependency(dependency);
+					result = false;
+				}
+			}
+		}
+		
+		return result;
+	}
+
+	/**
+	 * Enumerate classes on the classpath which are subclasses of the specified
+	 * class
+	 * 
+	 * @param superClass
+	 */
+	@Override
+	public <T> List<Class<? extends T>> getClasses(LoadableMod<?> container, ClassLoader classloader, ModClassValidator validator)
+	{
+		List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>();
+		
+		if (container != null)
+		{
+			try
+			{
+				for (String fullClassName : container.getContainedClassNames())
+				{
+					boolean isDefaultPackage = fullClassName.lastIndexOf('.') == -1;
+					String className = isDefaultPackage ? fullClassName : fullClassName.substring(fullClassName.lastIndexOf('.') + 1);
+					if (validator.validateName(className))
+					{
+						Class<? extends T> clazz = DefaultEnumeratorPlugin.<T>checkClass(classloader, validator, fullClassName);
+						if (clazz != null && !classes.contains(clazz))
+						{
+							classes.add(clazz);
+						}
+					}
+				}
+			}
+			catch (OutdatedLoaderException ex)
+			{
+				classes.clear();
+				LiteLoaderLogger.info(Verbosity.REDUCED, "Error searching in '%s', missing API component '%s', your loader is probably out of date", container, ex.getMessage());
+			}
+			catch (Throwable th)
+			{
+				LiteLoaderLogger.warning(th, "Enumeration error");
+			}
+		}
+		
+		return classes;
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <T> Class<? extends T> checkClass(ClassLoader classLoader, ModClassValidator validator, String className) throws OutdatedLoaderException
+	{
+		if (className.indexOf('$') > -1)
+			return null;
+		
+		try
+		{
+			Class<?> candidateClass = classLoader.loadClass(className);
+
+			if (validator.validateClass(classLoader, candidateClass))
+			{
+				return (Class<? extends T>)candidateClass;
+			}
+		}
+		catch (Throwable th)
+		{
+			th.printStackTrace();
+			
+			if (th.getCause() != null)
+			{
+				String missingClassName = th.getCause().getMessage();
+				if (th.getCause() instanceof NoClassDefFoundError && missingClassName != null)
+				{
+					if (missingClassName.startsWith("com/mumfrey/liteloader/"))
+					{
+						throw new OutdatedLoaderException(missingClassName.substring(missingClassName.lastIndexOf('/') + 1));
+					}
+				}
+			}
+			
+			LiteLoaderLogger.warning(th, "checkAndAddClass error while checking '%s'", className);
+		}
+		
+		return null;
+	}
+}
 package com.mumfrey.liteloader.interfaces;
 import java.util.Collection;
-import java.util.List;
 import java.util.Map;
 import com.mumfrey.liteloader.LiteMod;
@@ -14,26 +13,6 @@ import com.mumfrey.liteloader.core.ModInfo;
  */
 public interface LoaderEnumerator extends ModularEnumerator
 {
-	public enum DisabledReason
-	{
-		UNKNOWN("Container %s is could not be loaded for UNKNOWN reason"),
-		USER_DISABLED("Container %s is disabled"),
-		MISSING_DEPENDENCY("Container %s is missing one or more dependencies"),
-		MISSING_API("Container %s is missing one or more required APIs");
-		
-		private final String message;
-		
-		private DisabledReason(String message)
-		{
-			this.message = message;
-		}
-
-		public String getMessage(LoadableMod<?> container)
-		{
-			return String.format(this.message, container);
-		}
-	}
-	
 	/**
 	 * Perform pre-init tasks (container discovery)
 	 */
@@ -109,7 +88,7 @@ public interface LoaderEnumerator extends ModularEnumerator
 	/**
 	 * Get all tweakers which were injected
 	 */
-	public abstract List<? extends ModInfo<Loadable<?>>> getInjectedTweaks();
+	public abstract Collection<? extends ModInfo<Loadable<?>>> getInjectedTweaks();
 	/**
 	 * Get the shared modlist data
@@ -3,6 +3,7 @@ package com.mumfrey.liteloader.interfaces;
 import java.io.File;
 import com.mumfrey.liteloader.api.EnumeratorModule;
+import com.mumfrey.liteloader.api.EnumeratorPlugin;
 import com.mumfrey.liteloader.core.ModInfo;
 /**
@@ -20,6 +21,13 @@ public interface ModularEnumerator
 	public abstract void registerModule(EnumeratorModule module);
 	/**
+	 * Register a plugin into the enumerator
+	 * 
+	 * @param plugin
+	 */
+	public abstract void registerPlugin(EnumeratorPlugin plugin);
+	
+	/**
 	 * @param container
 	 */
 	public abstract boolean registerModContainer(LoadableMod<?> container);
@@ -2,8 +2,6 @@ package com.mumfrey.liteloader.launch;
 import java.io.File;
-import net.minecraft.launchwrapper.ITweaker;
-
 import com.mumfrey.liteloader.api.manager.APIAdapter;
 import com.mumfrey.liteloader.api.manager.APIProvider;
 import com.mumfrey.liteloader.core.EnabledModsList;
@@ -75,8 +73,7 @@ public interface LoaderEnvironment extends GameEnvironment
 	 */
 	public abstract File inflectVersionedConfigPath(LiteLoaderVersion version);
-	/**
-	 * Get the tweaker 
-	 */
-	public abstract ITweaker getTweaker();
+	public abstract boolean addCascadedTweaker(String tweakClass, int priority);
+
+	public abstract ClassTransformerManager getTransformerManager();
 }
@@ -8,13 +8,13 @@ import java.util.Map;
 import net.minecraft.launchwrapper.Launch;
 import com.google.common.base.Charsets;
+import com.mumfrey.liteloader.api.ContainerRegistry.DisabledReason;
 import com.mumfrey.liteloader.api.EnumerationObserver;
 import com.mumfrey.liteloader.core.ModInfo;
 import com.mumfrey.liteloader.core.api.LoadableModFile;
 import com.mumfrey.liteloader.interfaces.LoadableMod;
 import com.mumfrey.liteloader.interfaces.LoaderEnumerator;
 import com.mumfrey.liteloader.interfaces.TweakContainer;
-import com.mumfrey.liteloader.interfaces.LoaderEnumerator.DisabledReason;
 import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
 public class ModEvents implements EnumerationObserver