impl: rework RecipeManager and RecipeIndex

* sort custom recipes based on priority
* immutable RecipeIndex

Author: WolfyScript

api/src/main/kotlin/com/wolfyscript/customcrafting/recipes/RecipeManager.kt

@@ -2,6 +2,7 @@ package com.wolfyscript.customcrafting.recipes
 
 import com.wolfyscript.customcrafting.recipes.data.RecipeEvaluationResult
 import com.wolfyscript.customcrafting.recipes.data.RecipeInput
+import com.wolfyscript.customcrafting.resource.LoadedRecipe
 import com.wolfyscript.scafall.identifier.Key
 
 /**
@@ -15,6 +16,10 @@ import com.wolfyscript.scafall.identifier.Key
  */
 interface RecipeManager {
 
+    companion object {
+        const val LOG_PREFIX = "[Recipe Manager] "
+    }
+
     fun <I: RecipeInput, D: RecipeEvaluationResult.Data, T: CustomRecipe<I,D>> evaluateRecipesOfType(type: RecipeType<T>, input: I, context: EvaluationContext): RecipeEvaluationResult<D,T>?
 
     fun disableRecipe(recipe: Key)
@@ -25,10 +30,38 @@ interface RecipeManager {
 
     val disabledRecipes: Set<Key>
 
-    fun getRecipe(key: Key): CustomRecipe<*,*>?
+    /**
+     * Gets a [RecipeReference] to the recipe with the given [key].
+     *
+     * While the reference can be cached, the recipe value of the reference should not be cached separately!
+     */
+    fun getRecipe(key: Key): RecipeReference<*>?
+
+    /**
+     * Registers new recipes or updates existing recipes in the [RecipeManager] and re-indexes them by type and key.
+     */
+    fun registerOrUpdateRecipes(recipes: Collection<LoadedRecipe>)
+
+    /**
+     * Removes the recipes from the [RecipeManager] and re-indexes the recipes by type and key.
+     */
+    fun removeRecipes(vararg recipes: Key)
 
-    fun removeRecipe(key: Key)
+    /**
+     * Gets all the recipe references in the [RecipeManager].
+     */
+    fun recipes(): Collection<RecipeReference<*>>
 
-    fun updateRecipe(key: Key, recipe: CustomRecipe<*,*>)
+}
 
+inline fun <reified T : CustomRecipe<*, *>> RecipeManager.getRecipeTyped(key: Key, type: RecipeType<T>): RecipeReference<T>? {
+    val ref = getRecipe(key) ?: return null
+    if (ref.type != type) {
+        return null
+    }
+    return try {
+        ref as? RecipeReference<T>
+    } catch (_: ClassCastException) {
+        null
+    }
 }

api/src/main/kotlin/com/wolfyscript/customcrafting/recipes/RecipeReference.kt

@@ -13,7 +13,7 @@ import com.wolfyscript.scafall.identifier.Key
  *
  * It should always be checked if the recipe is available before accessing it (even if you registered a recipe yourself, other plugins may remove it).
  */
-interface RecipeReference<T: CustomRecipe<*,*>> {
+interface RecipeReference<out T: CustomRecipe<*,*>> {
 
     /**
      * The key of the recipe in the RecipeIndex

common/src/main/kotlin/com/wolfyscript/customcrafting/core/commands/RecipesCommand.kt

@@ -78,7 +78,7 @@ object RecipesCommand {
     private fun printStatus(ctx: CommandContext<CommandSourceStack>, customCrafting: CustomCraftingCommon) {
         val recipeManager = customCrafting.recipeManager
 
-        val totalRecipeCount = recipeManager.index.values().count()
+        val totalRecipeCount = recipeManager.recipes().count()
         val ccRecipesCount = recipeManager.recipesLoadedByCC.size
         val thirdPartyRecipeCount = totalRecipeCount - ccRecipesCount
         val disabledRecipeCount = recipeManager.disabledRecipes.size

common/src/main/kotlin/com/wolfyscript/customcrafting/recipes/RecipeIndex.kt

@@ -1,60 +1,107 @@
 package com.wolfyscript.customcrafting.recipes
 
-import com.google.common.collect.Multimap
-import com.google.common.collect.Multimaps
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableListMultimap
+import com.google.common.collect.ImmutableMap
 import com.wolfyscript.customcrafting.recipes.data.RecipeEvaluationResult
 import com.wolfyscript.customcrafting.recipes.data.RecipeInput
+import com.wolfyscript.customcrafting.resource.LoadedRecipe
 import com.wolfyscript.scafall.identifier.Key
-import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap
-import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet
 import java.util.*
 
-class RecipeIndex {
+/**
+ * The internal index of all the custom recipes.
+ * Recipes are indexed by their [Key] and [RecipeType].
+ *
+ * This index is immutable, and should be updated using [registerOrUpdateAll] and [removeBatch].
+ * That way, the index is thread-safe and prevents concurrent modification issues.
+ *
+ * [RecipeReferences][RecipeReference] are used to prevent caching of the recipe objects directly and causing memory leaks, because the objects may be removed/updated at any time.
+ */
+internal class RecipeIndex {
 
-    private val recipes: MutableSet<CustomRecipe<*, *>> = ObjectOpenHashSet()
+    companion object {
+        private val recipeValueComparator: Comparator<RecipeReference<*>> = Comparator.comparing { it.value?.priority ?: 0 }
+    }
 
+    private val recipes: List<CustomRecipe<*, *>>
     // reference those recipes, but do not hold on to those object references directly
-    internal val byKey: MutableMap<Key, RecipeReference<*>> = Object2ObjectOpenHashMap()
-    internal val byType: Multimap<RecipeType<*>, RecipeReference<*>> =
-        Multimaps.newSetMultimap(Object2ObjectOpenHashMap()) { ObjectOpenHashSet() }
+    internal val byKey: Map<Key, RecipeReference<*>>
+    internal val byType: ImmutableListMultimap<RecipeType<*>, RecipeReference<*>>
 
-    fun values(): Collection<RecipeReference<*>> {
-        return Collections.unmodifiableCollection(byKey.values)
-    }
+    constructor(recipes: Collection<LoadedRecipe>) {
+        val recipesBuilder = ImmutableList.builder<CustomRecipe<*, *>>()
+        val byKeyBuilder = ImmutableMap.builder<Key, RecipeReference<*>>()
+        val byTypeBuilder = ImmutableListMultimap.Builder<RecipeType<*>, RecipeReference<*>>()
+        byTypeBuilder.orderValuesBy(recipeValueComparator)
 
-    fun <T : CustomRecipe<*, *>> register(key: Key, recipe: T): RecipeReference<T> = synchronized(this) {
-        if (byKey.containsKey(key)) {
-            return byKey[key]!! as RecipeReference<T>
+        recipes.forEach {
+            recipesBuilder.add(it.recipe)
+            val ref = RecipeReferenceImpl(it.key, it.recipe)
+            byTypeBuilder.put(it.recipe.type, ref)
+            byKeyBuilder.put(it.key, ref)
         }
-        val ref = RecipeReferenceImpl(key, recipe)
-        byKey[key] = ref
-        byType.put(recipe.type, ref)
-        return ref
+
+        this.byType = byTypeBuilder.build()
+        this.byKey = byKeyBuilder.build()
+        this.recipes = recipesBuilder.build()
+    }
+
+    constructor(recipes: List<CustomRecipe<*, *>>, byKey: Map<Key, RecipeReference<*>>, byType: ImmutableListMultimap<RecipeType<*>, RecipeReference<*>>) {
+        this.recipes = recipes
+        this.byKey = byKey
+        this.byType = byType
+    }
+
+    fun values(): Collection<RecipeReference<*>> {
+        return Collections.unmodifiableCollection(byKey.values)
     }
 
     fun get(key: Key): RecipeReference<*>? = synchronized(this) {
         return byKey[key]
     }
 
-    fun remove(key: Key) = synchronized(this) {
-        val recipeRef = byKey[key]
-        if (recipeRef != null) {
-            val recipe = recipeRef.value
-            recipes.remove(recipe)
-            byType.remove(recipeRef.type, recipeRef)
-            byKey.remove(key)
+    fun registerOrUpdateAll(recipes: Collection<LoadedRecipe>) : RecipeIndex {
+        val updatedRecipes = ArrayList<CustomRecipe<*,*>>(recipes.size + this.recipes.size)
+        val byKeyBuilder = ImmutableMap.builder<Key, RecipeReference<*>>()
+        val byTypeBuilder = ImmutableListMultimap.Builder<RecipeType<*>, RecipeReference<*>>()
+        byTypeBuilder.orderValuesBy(recipeValueComparator)
+
+        updatedRecipes.addAll(this.recipes)
+        val updatedByKey = byKey.toMutableMap()
+        for (recipe in recipes) {
+            val existing = updatedByKey.remove(recipe.key)
+            updatedRecipes.remove(existing?.value)
+            updatedRecipes.add(recipe.recipe)
+
+            val ref = RecipeReferenceImpl(recipe.key, recipe.recipe)
+            byTypeBuilder.put(recipe.recipe.type, ref)
+            byKeyBuilder.put(recipe.key, ref)
         }
+
+        return RecipeIndex(updatedRecipes, byKeyBuilder.build(), byTypeBuilder.build())
     }
 
-    inline fun <reified T : CustomRecipe<*, *>> getRecipeTyped(key: Key, type: RecipeType<T>): T? = synchronized(this) {
-        val recipe = get(key) ?: return null
-        if (recipe.type != type) {
-            return null
+    fun removeBatch(vararg keys: Key) : RecipeIndex {
+        val updatedByKey = byKey.toMutableMap()
+        for (key in keys) {
+            updatedByKey.remove(key)
+        }
+        val recipesBuilder = ImmutableList.builder<CustomRecipe<*, *>>()
+        val byTypeBuilder = ImmutableListMultimap.Builder<RecipeType<*>, RecipeReference<*>>()
+        byTypeBuilder.orderValuesBy(recipeValueComparator)
+        updatedByKey.keys.forEach { key ->
+            val ref = byKey[key]
+            ref?.value?.let { recipe ->
+                recipesBuilder.add(recipe)
+                val ref = RecipeReferenceImpl(key, recipe)
+                byTypeBuilder.put(recipe.type, ref)
+            }
         }
-        return type.recipeClass.cast(recipe)
+        return RecipeIndex(recipesBuilder.build(), updatedByKey.toMap(), byTypeBuilder.build())
     }
 
-    fun <I : RecipeInput, D : RecipeEvaluationResult.Data, T : CustomRecipe<I, D>> byType(type: RecipeType<T>): Collection<RecipeReference<T>> = synchronized(this) {
+    fun <I : RecipeInput, D : RecipeEvaluationResult.Data, T : CustomRecipe<I, D>> byType(type: RecipeType<T>): Collection<RecipeReference<T>> {
         return byType.get(type) as Collection<RecipeReference<T>>
     }