diff --git a/fml/src/main/java/cpw/mods/fml/common/Loader.java b/fml/src/main/java/cpw/mods/fml/common/Loader.java index f59c84117f..375ba0833d 100644 --- a/fml/src/main/java/cpw/mods/fml/common/Loader.java +++ b/fml/src/main/java/cpw/mods/fml/common/Loader.java @@ -62,6 +62,7 @@ import cpw.mods.fml.common.functions.ArtifactVersionNameFunction; import cpw.mods.fml.common.functions.ModIdFunction; import cpw.mods.fml.common.registry.GameData; import cpw.mods.fml.common.registry.GameRegistry.Type; +import cpw.mods.fml.common.registry.ObjectHolderRegistry; import cpw.mods.fml.common.toposort.ModSorter; import cpw.mods.fml.common.toposort.ModSortingException; import cpw.mods.fml.common.toposort.ModSortingException.SortingExceptionData; @@ -502,12 +503,14 @@ public class Loader public void preinitializeMods() { + ObjectHolderRegistry.INSTANCE.findObjectHolders(discoverer.getASMTable()); if (!modController.isInState(LoaderState.PREINITIALIZATION)) { FMLLog.warning("There were errors previously. Not beginning mod initialization phase"); return; } modController.distributeStateMessage(LoaderState.PREINITIALIZATION, discoverer.getASMTable(), canonicalConfigDir); + ObjectHolderRegistry.INSTANCE.applyObjectHolders(); modController.transition(LoaderState.INITIALIZATION, false); } diff --git a/fml/src/main/java/cpw/mods/fml/common/registry/GameData.java b/fml/src/main/java/cpw/mods/fml/common/registry/GameData.java index 79d92d78de..d253fd042a 100644 --- a/fml/src/main/java/cpw/mods/fml/common/registry/GameData.java +++ b/fml/src/main/java/cpw/mods/fml/common/registry/GameData.java @@ -530,6 +530,8 @@ public class GameData { getMain().iBlockRegistry.dump(); getMain().iItemRegistry.dump(); Loader.instance().fireRemapEvent(remaps); + // The id map changed, ensure we apply object holders + ObjectHolderRegistry.INSTANCE.applyObjectHolders(); return ImmutableList.of(); } @@ -664,6 +666,8 @@ public class GameData { getMain().set(frozen); } + // the id mapping has reverted, ensure we sync up the object holders + ObjectHolderRegistry.INSTANCE.applyObjectHolders(); } protected static boolean isFrozen(FMLControlledNamespacedRegistry registry) diff --git a/fml/src/main/java/cpw/mods/fml/common/registry/GameRegistry.java b/fml/src/main/java/cpw/mods/fml/common/registry/GameRegistry.java index da0352db83..dfd90f6252 100644 --- a/fml/src/main/java/cpw/mods/fml/common/registry/GameRegistry.java +++ b/fml/src/main/java/cpw/mods/fml/common/registry/GameRegistry.java @@ -12,6 +12,10 @@ package cpw.mods.fml.common.registry; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; import java.lang.reflect.Constructor; import java.util.ArrayList; import java.util.Collections; @@ -424,4 +428,24 @@ public class GameRegistry return GameData.getUniqueName(item); } + + + /** + * This will cause runtime injection of public static final fields to occur at various points + * where mod blocks and items could be subject to change. This allows for dynamic + * substitution to occur. + * + */ + @Retention(RetentionPolicy.RUNTIME) + @Target({ElementType.TYPE, ElementType.FIELD}) + public @interface ObjectHolder { + /** + * If used on a class, this represents a modid only. + * If used on a field, it represents a name, which can be abbreviated or complete. + * Abbreviated names derive their modid from an enclosing ObjectHolder at the class level. + * + * @return either a modid or a name based on the rules above + */ + String value(); + } } diff --git a/fml/src/main/java/cpw/mods/fml/common/registry/ObjectHolderRef.java b/fml/src/main/java/cpw/mods/fml/common/registry/ObjectHolderRef.java new file mode 100644 index 0000000000..65e2082c71 --- /dev/null +++ b/fml/src/main/java/cpw/mods/fml/common/registry/ObjectHolderRef.java @@ -0,0 +1,101 @@ +package cpw.mods.fml.common.registry; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import org.apache.logging.log4j.Level; +import com.google.common.base.Throwables; +import cpw.mods.fml.common.FMLLog; +import cpw.mods.fml.common.registry.GameRegistry.ObjectHolder; +import net.minecraft.block.Block; +import net.minecraft.item.Item; + + +/** + * Internal class used in tracking {@link ObjectHolder} references + * + * @author cpw + * + */ +class ObjectHolderRef { + private Field field; + private String injectedObject; + private boolean isBlock; + private boolean isItem; + + + ObjectHolderRef(Field field, String injectedObject, boolean extractFromExistingValues) + { + this.field = field; + this.isBlock = Block.class.isAssignableFrom(field.getType()); + this.isItem = Item.class.isAssignableFrom(field.getType()); + if (extractFromExistingValues) + { + try + { + Object existing = field.get(null); + this.injectedObject = isBlock ? GameData.getBlockRegistry().getNameForObject(existing) : + isItem ? GameData.getItemRegistry().getNameForObject(existing) : null; + } catch (Exception e) + { + throw Throwables.propagate(e); + } + } + else + { + this.injectedObject = injectedObject; + } + + if (this.injectedObject == null || !isValid()) + { + throw new IllegalStateException("The ObjectHolder annotation cannot apply to a field that is not an Item or Block"); + } + makeWritable(field); + } + + private static Field modifiersField; + private static Object reflectionFactory; + private static Method newFieldAccessor; + private static Method fieldAccessorSet; + private static void makeWritable(Field f) + { + try + { + if (modifiersField == null) + { + Method getReflectionFactory = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("getReflectionFactory"); + reflectionFactory = getReflectionFactory.invoke(null); + newFieldAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newFieldAccessor", Field.class, boolean.class); + fieldAccessorSet = Class.forName("sun.reflect.FieldAccessor").getDeclaredMethod("set", Object.class, Object.class); + modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + } + modifiersField.setInt(f, f.getModifiers() & ~Modifier.FINAL); + } catch (Exception e) + { + throw Throwables.propagate(e); + } + } + + public boolean isValid() + { + return isBlock || isItem; + } + public void apply() + { + Object thing; + if (isBlock) + thing = GameData.getBlockRegistry().getObject(injectedObject); + else + thing = GameData.getItemRegistry().getObject(injectedObject); + try + { + Object fieldAccessor = newFieldAccessor.invoke(reflectionFactory, field, false); + fieldAccessorSet.invoke(fieldAccessor, null, thing); + } + catch (Exception e) + { + FMLLog.log(Level.WARN, e, "Unable to set %s with value %s (%s)", this.field, thing, this.injectedObject); + } + } +} diff --git a/fml/src/main/java/cpw/mods/fml/common/registry/ObjectHolderRegistry.java b/fml/src/main/java/cpw/mods/fml/common/registry/ObjectHolderRegistry.java new file mode 100644 index 0000000000..d4dbb0c7f6 --- /dev/null +++ b/fml/src/main/java/cpw/mods/fml/common/registry/ObjectHolderRegistry.java @@ -0,0 +1,123 @@ +package cpw.mods.fml.common.registry; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.List; +import java.util.Map; +import java.util.Set; +import com.google.common.base.Throwables; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import cpw.mods.fml.common.FMLLog; +import cpw.mods.fml.common.discovery.ASMDataTable; +import cpw.mods.fml.common.discovery.ASMDataTable.ASMData; +import cpw.mods.fml.common.registry.GameRegistry.ObjectHolder; + +/** + * Internal registry for tracking {@link ObjectHolder} references + * @author cpw + * + */ +public enum ObjectHolderRegistry { + INSTANCE; + private List objectHolders = Lists.newArrayList(); + + public void findObjectHolders(ASMDataTable table) + { + FMLLog.info("Processing ObjectHolder annotations"); + Set allObjectHolders = table.getAll(GameRegistry.ObjectHolder.class.getName()); + Map classModIds = Maps.newHashMap(); + Map> classCache = Maps.newHashMap(); + for (ASMData data : allObjectHolders) + { + String className = data.getClassName(); + String annotationTarget = data.getObjectName(); + String value = (String) data.getAnnotationInfo().get("value"); + boolean isClass = className.equals(annotationTarget); + scanTarget(classModIds, classCache, className, annotationTarget, value, isClass, false); + } + scanTarget(classModIds, classCache, "net.minecraft.init.Blocks", null, "minecraft", true, true); + scanTarget(classModIds, classCache, "net.minecraft.init.Items", null, "minecraft", true, true); + FMLLog.info("Found %d ObjectHolder annotations", objectHolders.size()); + } + + private void scanTarget(Map classModIds, Map> classCache, String className, String annotationTarget, String value, boolean isClass, boolean extractFromValue) + { + Class clazz; + if (classCache.containsKey(className)) + { + clazz = classCache.get(className); + } + else + { + try + { + clazz = Class.forName(className, true, getClass().getClassLoader()); + classCache.put(className, clazz); + } + catch (Exception ex) + { + // unpossible? + throw Throwables.propagate(ex); + } + } + if (isClass) + { + scanClassForFields(classModIds, className, value, clazz, extractFromValue); + } + else + { + if (value.indexOf(':') == -1) + { + String prefix = classModIds.get(className); + if (prefix == null) + { + FMLLog.warning("Found an unqualified ObjectHolder annotation (%s) without a modid context at %s.%s, ignoring", value, className, annotationTarget); + throw new IllegalStateException("Unqualified reference to ObjectHolder"); + } + value = prefix + ":" + value; + } + try + { + Field f = clazz.getField(annotationTarget); + addHolderReference(new ObjectHolderRef(f, value, extractFromValue)); + } + catch (Exception ex) + { + // unpossible? + throw Throwables.propagate(ex); + } + } + } + + private void scanClassForFields(Map classModIds, String className, String value, Class clazz, boolean extractFromExistingValues) + { + classModIds.put(className, value); + for (Field f : clazz.getFields()) + { + int mods = f.getModifiers(); + boolean isMatch = Modifier.isPublic(mods) && Modifier.isStatic(mods) && Modifier.isFinal(mods); + if (!isMatch || f.isAnnotationPresent(ObjectHolder.class)) + { + continue; + } + addHolderReference(new ObjectHolderRef(f, value + ":"+ f.getName(), extractFromExistingValues)); + } + } + + private void addHolderReference(ObjectHolderRef ref) + { + objectHolders.add(ref); + } + + public void applyObjectHolders() + { + FMLLog.info("Applying holder lookups"); + for (ObjectHolderRef ohr : objectHolders) + { + ohr.apply(); + } + FMLLog.info("Holder lookups applied"); + } + +}