Optimize load time (#60)

* Change iteration order to speedup LuVTierEnhancer

cache locality, tiered memory speed and whatnot. I thought this to be the common knowledge of computer science people?

* Various optimizations

1. cached reflections look up result
2. ore dict no create, and don't look into it more than necessary

Former-commit-id: 475a733e37ca1b749400294d0f0326a6c55eb783

5 files changed, 98 insertions, 53 deletions

diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioRecipeLoader.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioRecipeLoader.java
index 686a7a0777..422285bbb4 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioRecipeLoader.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/BioRecipeLoader.java
@@ -45,6 +45,9 @@ import net.minecraftforge.fluids.FluidRegistry;
 import net.minecraftforge.fluids.FluidStack;
 import net.minecraftforge.oredict.OreDictionary;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class BioRecipeLoader {
 
     @SuppressWarnings("deprecation")
@@ -132,9 +135,10 @@ public class BioRecipeLoader {
                 }
         );
 
-        if (LoaderReference.croploadcore && OreDictionary.getOres("cropVine").size() > 1)
-            for (int i = 0; i < OreDictionary.getOres("cropVine").size(); i++) {
-                GT_Values.RA.addExtractorRecipe(BW_Util.setStackSize(OreDictionary.getOres("cropVine").get(i),12), BioItemList.getOther(1), 500, BW_Util.getMachineVoltageFromTier(3));
+        List<ItemStack> oreCropVine = OreDictionary.getOres("cropVine", false);
+        if (LoaderReference.croploadcore && !oreCropVine.isEmpty())
+            for (ItemStack stack : oreCropVine) {
+                GT_Values.RA.addExtractorRecipe(BW_Util.setStackSize(stack, 12), BioItemList.getOther(1), 500, BW_Util.getMachineVoltageFromTier(3));
             }
         else
             GT_Values.RA.addExtractorRecipe(new ItemStack(Blocks.vine, 12), BioItemList.getOther(1), 500, BW_Util.getMachineVoltageFromTier(3));
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/StaticRecipeChangeLoaders.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/StaticRecipeChangeLoaders.java
index c0aabd973d..f4be3df605 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/StaticRecipeChangeLoaders.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/StaticRecipeChangeLoaders.java
@@ -38,6 +38,7 @@ import gregtech.api.objects.GT_ItemStack;
 import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_OreDictUnificator;
 import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
 import gregtech.api.util.GT_Utility;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemStack;
@@ -135,22 +136,26 @@ public class StaticRecipeChangeLoaders {
                     for (OrePrefixes prefixes : OrePrefixes.values()) {
                         if (!werkstoff.hasItemType(prefixes))
                             continue;
-                        if (OreDictionary.getOres(prefixes + s).size() <= 1)
+                        String fullOreName = prefixes + s;
+                        List<ItemStack> ores = OreDictionary.getOres(fullOreName, false);
+                        if (ores.isEmpty())
                             continue;
-                        for (int j = 0; j < OreDictionary.getOres(prefixes + s).size(); j++) {
-                            ItemStack toReplace = OreDictionary.getOres(prefixes + s).get(j);
+                        for (ItemStack toReplace : ores) {
                             ItemStack replacement = werkstoff.get(prefixes);
                             if (toReplace == null || GT_Utility.areStacksEqual(toReplace, replacement) || replacement == null || replacement.getItem() == null)
                                 continue;
                             for (GT_Recipe.GT_Recipe_Map map : GT_Recipe.GT_Recipe_Map.sMappings) {
-                                HashSet<GT_Recipe> toRem = new HashSet<>();
-                                for (GT_Recipe recipe : map.mRecipeList) {
-                                    boolean removal = map.equals(GT_Recipe.GT_Recipe_Map.sFluidExtractionRecipes) || map.equals(GT_Recipe.GT_Recipe_Map.sFluidSolidficationRecipes);
+                                nextRecipe:
+                                for (Iterator<GT_Recipe> iterator = map.mRecipeList.iterator(); iterator.hasNext(); ) {
+                                    GT_Recipe recipe = iterator.next();
+                                    boolean removal = map.equals(GT_Recipe_Map.sFluidExtractionRecipes) || map.equals(GT_Recipe_Map.sFluidSolidficationRecipes);
                                     for (int i = 0; i < recipe.mInputs.length; i++) {
                                         if (!GT_Utility.areStacksEqual(recipe.mInputs[i], toReplace))
                                             continue;
-                                        if (removal)
-                                            toRem.add(recipe);
+                                        if (removal) {
+                                            iterator.remove();
+                                            continue nextRecipe;
+                                        }
                                         else {
                                             int amount = recipe.mInputs[i].stackSize;
                                             recipe.mInputs[i] = BW_Util.setStackSize(replacement, amount);
@@ -159,8 +164,10 @@ public class StaticRecipeChangeLoaders {
                                     for (int i = 0; i < recipe.mOutputs.length; i++) {
                                         if (!GT_Utility.areStacksEqual(recipe.mOutputs[i], toReplace))
                                             continue;
-                                        if (removal)
-                                            toRem.add(recipe);
+                                        if (removal) {
+                                            iterator.remove();
+                                            continue nextRecipe;
+                                        }
                                         else {
                                             int amount = recipe.mOutputs[i].stackSize;
                                             recipe.mOutputs[i] = BW_Util.setStackSize(replacement, amount);
@@ -169,15 +176,16 @@ public class StaticRecipeChangeLoaders {
                                     if (recipe.mSpecialItems instanceof ItemStack) {
                                         if (!GT_Utility.areStacksEqual((ItemStack) recipe.mSpecialItems, toReplace))
                                             continue;
-                                        if (removal)
-                                            toRem.add(recipe);
+                                        if (removal) {
+                                            iterator.remove();
+                                            continue nextRecipe;
+                                        }
                                         else {
                                             int amount = ((ItemStack) recipe.mSpecialItems).stackSize;
                                             recipe.mSpecialItems = BW_Util.setStackSize(replacement, amount);
                                         }
                                     }
                                 }
-                                map.mRecipeList.removeAll(toRem);
                             }
                         }
                     }
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java
index 65c677dc55..21735f43b0 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/LuVTierEnhancer.java
@@ -28,11 +28,11 @@ import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
 import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
 import com.github.bartimaeusnek.bartworks.system.material.processingLoaders.AfterLuVTierEnhacement;
 import com.github.bartimaeusnek.bartworks.util.BW_Util;
-import gregtech.api.enums.ItemList;
-import gregtech.api.enums.Materials;
-import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.*;
 import gregtech.api.objects.ItemData;
 import gregtech.api.util.*;
+import gregtech.api.util.GT_Recipe.GT_Recipe_AssemblyLine;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.CraftingManager;
 import net.minecraft.item.crafting.IRecipe;
@@ -93,20 +93,25 @@ public class LuVTierEnhancer implements Runnable {
 
     private static void replaceAllRecipes(Collection<ItemStack> LuVMachines, OrePrefixes[] LuVMaterialsGenerated, List<IRecipe> bufferedRecipeList){
         LuVTierEnhancer.replaceOsmiridiumInLuVRecipes();
-        LuVMachines.stream().forEach(stack -> {
 
-                    Predicate recipeFilter = obj -> obj instanceof GT_Shaped_Recipe && GT_Utility.areStacksEqual(((GT_Shaped_Recipe) obj).getRecipeOutput(), stack, true);
-
-                    GT_Recipe.GT_Recipe_AssemblyLine.sAssemblylineRecipes.forEach(
-                            recipe -> rewriteAsslineRecipes(stack, LuVMaterialsGenerated, recipe));
-
-                    GT_Recipe.GT_Recipe_Map.sMappings.forEach(
-                            map -> map.mRecipeList.forEach(
-                                    recipe -> rewriteMachineRecipes(stack, LuVMaterialsGenerated, recipe)));
+        for (GT_Recipe_AssemblyLine sAssemblylineRecipe : GT_Recipe_AssemblyLine.sAssemblylineRecipes) {
+            for (ItemStack stack : LuVMachines) {
+                rewriteAsslineRecipes(stack, LuVMaterialsGenerated, sAssemblylineRecipe);
+            }
+        }
 
-                    rewriteCraftingRecipes(bufferedRecipeList, LuVMaterialsGenerated, recipeFilter);
+        for (GT_Recipe_Map map : GT_Recipe_Map.sMappings) {
+            for (GT_Recipe recipe : map.mRecipeList) {
+                for (ItemStack stack : LuVMachines) {
+                    rewriteMachineRecipes(stack, LuVMaterialsGenerated, recipe);
                 }
-        );
+            }
+        }
+
+        for (ItemStack stack : LuVMachines) {
+            Predicate recipeFilter = obj -> obj instanceof GT_Shaped_Recipe && GT_Utility.areStacksEqual(((GT_Shaped_Recipe) obj).getRecipeOutput(), stack, true);
+            rewriteCraftingRecipes(bufferedRecipeList, LuVMaterialsGenerated, recipeFilter);
+        }
     }
 
     private static void addDreamcraftItemListItems(Collection LuVMachines){
@@ -135,25 +140,23 @@ public class LuVTierEnhancer implements Runnable {
         }
     }
 
-    private static void rewriteMachineRecipes(ItemStack stack, OrePrefixes[] LuVMaterialsGenerated, GT_Recipe recipe){
+    private static void rewriteMachineRecipes(ItemStack stack, OrePrefixes[] LuVMaterialsGenerated, GT_Recipe recipe) {
+        if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, stack, false)) {
             for (OrePrefixes prefixes : LuVMaterialsGenerated) {
-                if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, stack, false)) {
-                    LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
-                    LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
-                }
-                if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, stack, false)) {
-                    LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
-                    LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
-                }
-            }
-            if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, stack, false)) {
-                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidInputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
-                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidOutputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
+                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
+                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
             }
-            if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, stack, false)) {
-                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidInputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
-                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidOutputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
+            LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidInputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
+            LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidOutputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
+        }
+        if (LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, stack, false)) {
+            for (OrePrefixes prefixes : LuVMaterialsGenerated) {
+                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mInputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
+                LuVTierEnhancer.doStacksCointainAndReplace(recipe.mOutputs, GT_OreDictUnificator.get(prefixes, Materials.Chrome, 1), true, WerkstoffLoader.LuVTierMaterial.get(prefixes));
             }
+            LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidInputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
+            LuVTierEnhancer.doStacksCointainAndReplace(recipe.mFluidOutputs, Materials.Chrome.getMolten(1), true, WerkstoffLoader.LuVTierMaterial.getMolten(1).getFluid());
+        }
     }
     private static void rewriteAsslineRecipes(ItemStack stack, OrePrefixes[] LuVMaterialsGenerated, GT_Recipe.GT_Recipe_AssemblyLine recipe){
         for (OrePrefixes prefixes : LuVMaterialsGenerated) {
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java
index 41bd0aad4c..757fc9ea7b 100644
--- a/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/system/material/GT_Enhancement/PlatinumSludgeOverHaul.java
@@ -27,6 +27,7 @@ import com.github.bartimaeusnek.bartworks.MainMod;
 import com.github.bartimaeusnek.bartworks.system.material.BW_MetaGenerated_Items;
 import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;
 import com.github.bartimaeusnek.bartworks.util.BW_Util;
+import com.github.bartimaeusnek.bartworks.util.CachedReflectionUtils;
 import com.github.bartimaeusnek.crossmod.BartWorksCrossmod;
 import cpw.mods.fml.common.registry.GameRegistry;
 import gregtech.api.enums.GT_Values;
@@ -212,8 +213,9 @@ public class PlatinumSludgeOverHaul {
         //furnace
         for (Object entry : FurnaceRecipes.smelting().getSmeltingList().entrySet()) {
             Map.Entry realEntry = (Map.Entry) entry;
-            if (GT_Utility.isStackValid(realEntry.getKey()) && BW_Util.checkStackAndPrefix((ItemStack) realEntry.getKey()))
-                if ((!GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey()).mPrefix.equals(dust) && !GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey()).mPrefix.equals(dustTiny)) || !GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey()).mMaterial.mMaterial.equals(Materials.Platinum))
+            if (GT_Utility.isStackValid(realEntry.getKey()) && BW_Util.checkStackAndPrefix((ItemStack) realEntry.getKey())) {
+                ItemData association = GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getKey());
+                if ((!association.mPrefix.equals(dust) && !association.mPrefix.equals(dustTiny)) || !association.mMaterial.mMaterial.equals(Materials.Platinum))
                     if (GT_Utility.isStackValid(realEntry.getValue()) && BW_Util.checkStackAndPrefix((ItemStack) realEntry.getValue())){
                         ItemData ass = GT_OreDictUnificator.getAssociation((ItemStack) realEntry.getValue());
                         if (ass.mMaterial.mMaterial.equals(Materials.Platinum))
@@ -223,6 +225,7 @@ public class PlatinumSludgeOverHaul {
                             if (!PlatinumSludgeOverHaul.isInBlackList((ItemStack) realEntry.getKey()))
                                 realEntry.setValue(PDMetallicPowder.get(ass.mPrefix == nugget ? dustTiny : dust, ((ItemStack) realEntry.getValue()).stackSize * 2));
                     }
+            }
         }
         //vanilla crafting
         CraftingManager.getInstance().getRecipeList().forEach(PlatinumSludgeOverHaul::setnewMaterialInRecipe);
@@ -396,7 +399,7 @@ public class PlatinumSludgeOverHaul {
                 else if (LoaderReference.miscutils) {
                     try {
                         if (Class.forName("gtPlusPlus.api.objects.minecraft.ShapedRecipe").isAssignableFrom(obj.getClass()))
-                            obj = FieldUtils.getField(obj.getClass(),"mRecipe",true).get(obj);
+                            obj = CachedReflectionUtils.getField(obj.getClass(),"mRecipe").get(obj);
                     } catch (ClassNotFoundException | IllegalAccessException e) {
                         e.printStackTrace();
                     }
@@ -406,14 +409,14 @@ public class PlatinumSludgeOverHaul {
         IRecipe recipe = (IRecipe) obj;
         ItemStack otpt = recipe.getRecipeOutput();
 
-        Field out = FieldUtils.getDeclaredField(recipe.getClass(), inputName, true);
+        Field out = CachedReflectionUtils.getDeclaredField(recipe.getClass(), inputName);
         if (out == null)
-            out = FieldUtils.getField(recipe.getClass(), inputName, true);
+            out = CachedReflectionUtils.getField(recipe.getClass(), inputName);
 
 
-        Field in = FieldUtils.getDeclaredField(recipe.getClass(), inputItemName, true);
+        Field in = CachedReflectionUtils.getDeclaredField(recipe.getClass(), inputItemName);
         if (in == null)
-            in = FieldUtils.getField(recipe.getClass(), inputItemName, true);
+            in = CachedReflectionUtils.getField(recipe.getClass(), inputItemName);
         if (in == null)
             return;
 
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/util/CachedReflectionUtils.java b/src/main/java/com/github/bartimaeusnek/bartworks/util/CachedReflectionUtils.java
new file mode 100644
index 0000000000..f1276c4d3d
--- /dev/null
+++ b/src/main/java/com/github/bartimaeusnek/bartworks/util/CachedReflectionUtils.java
@@ -0,0 +1,27 @@
+package com.github.bartimaeusnek.bartworks.util;
+
+import org.apache.commons.lang3.reflect.FieldUtils;
+
+import java.lang.reflect.Field;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class CachedReflectionUtils {
+    private static final ClassValue<Map<String, Field>> fields = new ConcurrentMapClassValue();
+    private static final ClassValue<Map<String, Field>> declaredFields = new ConcurrentMapClassValue();
+
+    public static Field getField(final Class<?> cls, final String fieldName) {
+        return fields.get(cls).computeIfAbsent(fieldName, f -> FieldUtils.getField(cls, f, true));
+    }
+
+    public static Field getDeclaredField(final Class<?> cls, final String fieldName) {
+        return fields.get(cls).computeIfAbsent(fieldName, f -> FieldUtils.getDeclaredField(cls, f, true));
+    }
+
+    private static class ConcurrentMapClassValue extends ClassValue<Map<String, Field>> {
+        @Override
+        protected Map<String, Field> computeValue(Class<?> type) {
+            return new ConcurrentHashMap<>();
+        }
+    }
+}