Update generics to couple the interface, view and builder

Author: Aeltumn

examples/src/main/kotlin/com/noxcrew/interfaces/example/CatalogueExampleInterface.kt

@@ -10,7 +10,7 @@ import org.bukkit.Material
 public class CatalogueExampleInterface : RegistrableInterface {
     override val subcommand: String = "catalogue"
 
-    override fun create(): Interface<*> = buildCombinedInterface {
+    override fun create(): Interface<*, *> = buildCombinedInterface {
         rows = 1
 
         withTransform { pane, _ ->

examples/src/main/kotlin/com/noxcrew/interfaces/example/ChangingTitleExampleInterface.kt

@@ -13,7 +13,7 @@ public class ChangingTitleExampleInterface : RegistrableInterface {
 
     override val subcommand: String = "changing-title"
 
-    override fun create(): Interface<*> = buildCombinedInterface {
+    override fun create(): Interface<*, *> = buildCombinedInterface {
         rows = 1
 
         val numberProperty = interfaceProperty(0)

examples/src/main/kotlin/com/noxcrew/interfaces/example/DelayedRequestExampleInterface.kt

@@ -21,7 +21,7 @@ public class DelayedRequestExampleInterface : RegistrableInterface {
     override val subcommand: String = "delayed"
 
     @OptIn(DelicateCoroutinesApi::class)
-    override fun create(): Interface<*> = buildCombinedInterface {
+    override fun create(): Interface<*, *> = buildCombinedInterface {
         initialTitle = text(subcommand)
         rows = 2
 

examples/src/main/kotlin/com/noxcrew/interfaces/example/MovingExampleInterface.kt

@@ -10,7 +10,7 @@ import org.bukkit.Material
 public class MovingExampleInterface : RegistrableInterface {
     override val subcommand: String = "moving"
 
-    override fun create(): Interface<*> = buildCombinedInterface {
+    override fun create(): Interface<*, *> = buildCombinedInterface {
         val countProperty = BoundInteger(4, 1, 7)
         var count by countProperty
 

examples/src/main/kotlin/com/noxcrew/interfaces/example/RegistrableInterface.kt

@@ -6,5 +6,5 @@ public interface RegistrableInterface {
 
     public val subcommand: String
 
-    public fun create(): Interface<*>
+    public fun create(): Interface<*, *>
 }

examples/src/main/kotlin/com/noxcrew/interfaces/example/TabbedExampleInterface.kt

@@ -20,7 +20,7 @@ public class TabbedExampleInterface : RegistrableInterface {
 
     override val subcommand: String = "tabbed"
 
-    override fun create(): Interface<*> = first
+    override fun create(): Interface<*, *> = first
 
     private fun CombinedInterfaceBuilder.defaults() {
         rows = 6

interfaces/src/main/kotlin/com/noxcrew/interfaces/InterfacesListeners.kt

@@ -150,7 +150,7 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
     @EventHandler
     public fun onClose(event: InventoryCloseEvent) {
         val holder = event.inventory.holder
-        val view = holder as? AbstractInterfaceView<*, *> ?: return
+        val view = holder as? AbstractInterfaceView<*, *, *> ?: return
         val reason = event.reason
 
         // Saves any persistent items stored in the given inventory before we close it
@@ -233,7 +233,7 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
         // Check if the action is prevented if this slot is not freely
         // movable
         if (!canFreelyMove(view, clickedPoint) &&
-            event.action in view.backing.properties.preventedInteractions
+            event.action in view.builder.preventedInteractions
         ) {
             event.isCancelled = true
             return
@@ -336,11 +336,11 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
      * Converts an inventory holder to an [AbstractInterfaceView] if possible. If the holder is a player
      * their currently open player interface is returned.
      */
-    public fun convertHolderToInterfaceView(holder: InventoryHolder?): AbstractInterfaceView<*, *>? {
+    public fun convertHolderToInterfaceView(holder: InventoryHolder?): AbstractInterfaceView<*, *, *>? {
         if (holder == null) return null
 
         // If it's an abstract view use that one
-        if (holder is AbstractInterfaceView<*, *>) return holder
+        if (holder is AbstractInterfaceView<*, *, *>) return holder
 
         // If it's the player's own inventory use the held one
         if (holder is HumanEntity) return getOpenInterface(holder.uniqueId)
@@ -350,13 +350,13 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
 
     /** Returns whether [clickedPoint] in [view] can be freely moved. */
     private fun canFreelyMove(
-        view: AbstractInterfaceView<*, *>,
+        view: AbstractInterfaceView<*, *, *>,
         clickedPoint: GridPoint
-    ): Boolean = view.pane.getRaw(clickedPoint) == null && !view.backing.properties.preventClickingEmptySlots
+    ): Boolean = view.pane.getRaw(clickedPoint) == null && !view.builder.preventClickingEmptySlots
 
     /** Handles a [view] being clicked at [clickedPoint] through some [event]. */
     private fun handleClick(
-        view: AbstractInterfaceView<*, *>,
+        view: AbstractInterfaceView<*, *, *>,
         clickedPoint: GridPoint,
         click: ClickType,
         event: Cancellable,
@@ -367,7 +367,7 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
 
         // Optionally cancel clicking on other slots
         if (raw == null) {
-            if (view.backing.properties.preventClickingEmptySlots) {
+            if (view.builder.preventClickingEmptySlots) {
                 event.isCancelled = true
             }
             return
@@ -384,7 +384,7 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
 
         // Forward this click to all pre-processors
         val clickContext = ClickContext(view.player, view, click, slot)
-        view.backing.properties.clickPreprocessors
+        view.builder.clickPreprocessors
             .forEach { handler -> ClickHandler.process(handler, clickContext) }
 
         // Run the click handler and deal with its result
@@ -502,7 +502,7 @@ public class InterfacesListeners private constructor(private val plugin: Plugin)
 
         // Mark the view as properly closed
         SCOPE.launch {
-            (query.view as AbstractInterfaceView<*, *>).markClosed(Reason.PLAYER)
+            (query.view as AbstractInterfaceView<*, *, *>).markClosed(Reason.PLAYER)
         }
     }
 }

interfaces/src/main/kotlin/com/noxcrew/interfaces/interfaces/ChestInterface.kt

@@ -10,8 +10,8 @@ import org.bukkit.entity.Player
 public class ChestInterface internal constructor(
     override val rows: Int,
     override val initialTitle: Component?,
-    override val properties: InterfaceProperties<Pane>
-) : Interface<Pane>, TitledInterface {
+    override val builder: ChestInterfaceBuilder
+) : Interface<ChestInterface, Pane>, TitledInterface {
 
     public companion object {
         /** The maximum number of rows for a chest GUI. */

interfaces/src/main/kotlin/com/noxcrew/interfaces/interfaces/CombinedInterface.kt

@@ -10,8 +10,8 @@ import org.bukkit.entity.Player
 public class CombinedInterface internal constructor(
     override val rows: Int,
     override val initialTitle: Component?,
-    override val properties: InterfaceProperties<CombinedPane>
-) : Interface<CombinedPane>, TitledInterface {
+    override val builder: CombinedInterfaceBuilder
+) : Interface<CombinedInterface, CombinedPane>, TitledInterface {
 
     public companion object {
         /** The maximum number of rows for a combined interface. */

interfaces/src/main/kotlin/com/noxcrew/interfaces/interfaces/Interface.kt

@@ -6,13 +6,13 @@ import com.noxcrew.interfaces.view.InterfaceView
 import org.bukkit.entity.Player
 
 /** A created interface that can be opened for a player to create a unique view. */
-public interface Interface<P : Pane> {
+public interface Interface<I : Interface<I, P>, P : Pane> {
 
     /** The amount of rows this interface contains. */
     public val rows: Int
 
-    /** The properties of this interface. */
-    public val properties: InterfaceProperties<P>
+    /** The builder that creates this interface. */
+    public val builder: InterfaceBuilder<P, I>
 
     /** Returns the total amount of rows. */
     public fun totalRows(): Int = rows

interfaces/src/main/kotlin/com/noxcrew/interfaces/interfaces/InterfaceBuilder.kt

@@ -8,7 +8,7 @@ import com.noxcrew.interfaces.transform.Transform
 import com.noxcrew.interfaces.utilities.IncrementingInteger
 
 /** Assists in creating a new interface. */
-public abstract class InterfaceBuilder<P : Pane, I : Interface<P>> : InterfaceProperties<P>() {
+public abstract class InterfaceBuilder<P : Pane, I : Interface<I, P>> : InterfaceProperties<P>() {
 
     private val transformCounter by IncrementingInteger()
     private val _transforms: MutableCollection<AppliedTransform<P>> = mutableListOf()

interfaces/src/main/kotlin/com/noxcrew/interfaces/interfaces/PlayerInterface.kt

@@ -7,8 +7,8 @@ import org.bukkit.entity.Player
 
 /** An interface that uses the entire player inventory. */
 public class PlayerInterface internal constructor(
-    override val properties: InterfaceProperties<PlayerPane>
-) : Interface<PlayerPane> {
+    override val builder: PlayerInterfaceBuilder
+) : Interface<PlayerInterface, PlayerPane> {
 
     public companion object {
         /** The maximum number of rows for a player interface. */

interfaces/src/main/kotlin/com/noxcrew/interfaces/view/AbstractInterfaceView.kt

@@ -6,6 +6,7 @@ import com.noxcrew.interfaces.InterfacesListeners
 import com.noxcrew.interfaces.event.DrawPaneEvent
 import com.noxcrew.interfaces.grid.GridPoint
 import com.noxcrew.interfaces.interfaces.Interface
+import com.noxcrew.interfaces.interfaces.InterfaceBuilder
 import com.noxcrew.interfaces.inventory.InterfacesInventory
 import com.noxcrew.interfaces.pane.CompletedPane
 import com.noxcrew.interfaces.pane.Pane
@@ -34,10 +35,10 @@ import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 
 /** The basis for the implementation of an interface view. */
-public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
+public abstract class AbstractInterfaceView<I : InterfacesInventory, T : Interface<T, P>, P : Pane>(
     override val player: Player,
     /** The interface backing this view. */
-    public val backing: Interface<P>,
+    public val backing: T,
     private val parent: InterfaceView?
 ) : InterfaceView {
 
@@ -50,7 +51,11 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
     private val semaphore = Semaphore(1)
     private val queue = AtomicInteger(0)
 
-    private val children = WeakHashMap<AbstractInterfaceView<*, *>, Unit>()
+    private val children = WeakHashMap<AbstractInterfaceView<*, *, *>, Unit>()
+
+    /** The builder used by this interface. */
+    public val builder: InterfaceBuilder<P, T>
+        get() = backing.builder
 
     /** Added persistent items added when this interface was last closed. */
     public val addedItems: MutableMap<GridPoint, ItemStack> = mutableMapOf()
@@ -96,8 +101,8 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
         openIfClosed.set(false)
 
         // Run a generic close handler if it's still opened
-        if (shouldBeOpened.compareAndSet(true, false) && (!changingView || backing.properties.callCloseHandlerOnViewSwitch)) {
-            backing.properties.closeHandlers[reason]?.invoke(reason, this)
+        if (shouldBeOpened.compareAndSet(true, false) && (!changingView || builder.callCloseHandlerOnViewSwitch)) {
+            builder.closeHandlers[reason]?.invoke(reason, this)
         }
 
         // Don't close children when changing views!
@@ -118,7 +123,7 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
     private fun setup() {
         // Determine for each trigger what transforms it updates
         val triggers = HashMultimap.create<Trigger, AppliedTransform<P>>()
-        for (transform in backing.properties.transforms) {
+        for (transform in builder.transforms) {
             for (trigger in transform.triggers) {
                 triggers.put(trigger, transform)
             }
@@ -138,7 +143,7 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
     }
 
     override fun redrawComplete() {
-        applyTransforms(backing.properties.transforms)
+        applyTransforms(builder.transforms)
     }
 
     override suspend fun open() {
@@ -148,7 +153,7 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
         shouldBeOpened.set(true)
 
         // Indicate to the parent that this child exists
-        if (parent is AbstractInterfaceView<*, *>) {
+        if (parent is AbstractInterfaceView<*, *, *>) {
             parent.children[this] = Unit
         }
 
@@ -293,14 +298,14 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
             currentInventory.set(
                 row,
                 column,
-                element.itemStack.apply { this?.let { backing.properties.itemPostProcessor?.invoke(it) } }
+                element.itemStack.apply { this?.let { builder.itemPostProcessor?.invoke(it) } }
             )
             leftovers -= row to column
             madeChanges = true
         }
 
         // Apply the overlay of persistent items on top
-        if (backing.properties.persistAddedItems) {
+        if (builder.persistAddedItems) {
             for ((point, item) in addedItems) {
                 val row = point.x
                 val column = point.y
@@ -318,7 +323,7 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
         }
 
         // If we inherit existing items we don't clear here!
-        if (!backing.properties.inheritExistingItems) {
+        if (!builder.inheritExistingItems) {
             // Empty any slots that are not otherwise edited
             for ((row, column) in leftovers) {
                 val isPlayerInventory = currentInventory.isPlayerInventory(row, column)
@@ -335,7 +340,7 @@ public abstract class AbstractInterfaceView<I : InterfacesInventory, P : Pane>(
 
     /** Saves any persistent items based on [inventory]. */
     public fun savePersistentItems(inventory: Inventory) {
-        if (!backing.properties.persistAddedItems) return
+        if (!builder.persistAddedItems) return
 
         addedItems.clear()
         val contents = inventory.contents

interfaces/src/main/kotlin/com/noxcrew/interfaces/view/ChestInterfaceView.kt

@@ -14,7 +14,7 @@ public class ChestInterfaceView internal constructor(
     player: Player,
     backing: ChestInterface,
     parent: InterfaceView?
-) : AbstractInterfaceView<ChestInterfacesInventory, Pane>(
+) : AbstractInterfaceView<ChestInterfacesInventory, ChestInterface, Pane>(
     player,
     backing,
     parent

interfaces/src/main/kotlin/com/noxcrew/interfaces/view/CombinedInterfaceView.kt

@@ -14,7 +14,7 @@ public class CombinedInterfaceView internal constructor(
     player: Player,
     backing: CombinedInterface,
     parent: InterfaceView?
-) : AbstractInterfaceView<CombinedInterfacesInventory, CombinedPane>(
+) : AbstractInterfaceView<CombinedInterfacesInventory, CombinedInterface, CombinedPane>(
     player,
     backing,
     parent

interfaces/src/main/kotlin/com/noxcrew/interfaces/view/PlayerInterfaceView.kt

@@ -15,7 +15,7 @@ import kotlin.time.Duration
 public class PlayerInterfaceView internal constructor(
     player: Player,
     backing: PlayerInterface
-) : AbstractInterfaceView<PlayerInterfacesInventory, PlayerPane>(
+) : AbstractInterfaceView<PlayerInterfacesInventory, PlayerInterface, PlayerPane>(
     player,
     backing,
     null
@@ -43,7 +43,7 @@ public class PlayerInterfaceView internal constructor(
 
         // Double-check that this inventory is open now!
         if (isOpen()) {
-            if (!backing.properties.inheritExistingItems) {
+            if (!builder.inheritExistingItems) {
                 // Clear the player's inventory!
                 player.inventory.clear()
                 if (player.openInventory.topInventory.type == InventoryType.CRAFTING ||