More work on async methods

src/main/kotlin/com/dmdirc/ktirc/IrcClient.kt

 import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.messages.sendJoin
+import com.dmdirc.ktirc.messages.tagMap
 import com.dmdirc.ktirc.model.*
 import com.dmdirc.ktirc.util.RemoveIn
 import kotlinx.coroutines.Deferred
      * This should only be needed to send raw/custom commands; standard messages can be sent using the
      * extension methods in [com.dmdirc.ktirc.messages] such as TODO: sendJoinAsync.
      *
-     * This method will return immediately. If the server supports the labeled-responses capability,
-     * the returned [Deferred] will be eventually populated with the response from the server. If
-     * the server does not support the capability, or the response times out, `null` will be supplied.
+     * This method will return immediately. The returned [Deferred] will eventually be populated with
+     * the server's response. If the server supports the labeled-responses capability, a label will
+     * be added to the outgoing message to identify the correct response; otherwise the [matcher]
+     * will be invoked on all incoming events to select the appropriate response.
+     *
+     * If the response times out, `null` will be supplied instead of an event.
      *
      * @param command The command to be sent.
      * @param arguments The arguments to the command.
+     * @param matcher The matcher to use to find a matching event.
      * @return A deferred [IrcEvent]? that contains the server's response to the command.
      */
-    fun sendAsync(command: String, vararg arguments: String) = sendAsync(emptyMap(),  command, *arguments)
+    fun sendAsync(command: String, arguments: Array<String>, matcher: (IrcEvent) -> Boolean) = sendAsync(tagMap(), command, arguments, matcher)
 
     /**
      * Sends the given command to the IRC server, and waits for a response back.
      * This should only be needed to send raw/custom commands; standard messages can be sent using the
      * extension methods in [com.dmdirc.ktirc.messages] such as TODO: sendJoinAsync.
      *
-     * This method will return immediately. If the server supports the labeled-responses capability,
-     * the returned [Deferred] will be eventually populated with the response from the server. If
-     * the server does not support the capability, or the response times out, `null` will be supplied.
+     * This method will return immediately. The returned [Deferred] will eventually be populated with
+     * the server's response. If the server supports the labeled-responses capability, a label will
+     * be added to the outgoing message to identify the correct response; otherwise the [matcher]
+     * will be invoked on all incoming events to select the appropriate response.
+     *
+     * If the response times out, `null` will be supplied instead of an event.
      *
      * @param tags The IRCv3 tags to prefix the message with, if any.
      * @param command The command to be sent.
      * @param arguments The arguments to the command.
+     * @param matcher The matcher to use to find a matching event.
      * @return A deferred [IrcEvent]? that contains the server's response to the command.
      */
-    fun sendAsync(tags: Map<MessageTag, String>, command: String, vararg arguments: String): Deferred<IrcEvent?>
+    fun sendAsync(tags: Map<MessageTag, String>, command: String, arguments: Array<String>, matcher: (IrcEvent) -> Boolean): Deferred<IrcEvent?>
 
 }
 

src/main/kotlin/com/dmdirc/ktirc/IrcClientImpl.kt

                 ?: log.warning { "No send channel for command: $command" }
     }
 
-    override fun sendAsync(tags: Map<MessageTag, String>, command: String, vararg arguments: String) = async {
-        if (serverState.supportsLabeledResponses) {
-            val label = generateLabel(this@IrcClientImpl)
-            val channel = Channel<IrcEvent>(1)
-            serverState.labelChannels[label] = channel
+    override fun sendAsync(tags: Map<MessageTag, String>, command: String, arguments: Array<String>, matcher: (IrcEvent) -> Boolean) = async {
+        val label = generateLabel(this@IrcClientImpl)
+        val channel = Channel<IrcEvent>(1)
+
+        if (serverState.asyncResponseState.supportsLabeledResponses) {
+            serverState.asyncResponseState.pendingResponses[label] = channel to { event -> event.metadata.label == label }
             send(tags + (MessageTag.Label to label), command, *arguments)
-            withTimeoutOrNull(asyncTimeout) { channel.receive() }.also { serverState.labelChannels.remove(label) }
         } else {
+            serverState.asyncResponseState.pendingResponses[label] = channel to matcher
             send(tags, command, *arguments)
-            null
         }
+
+        withTimeoutOrNull(asyncTimeout) {
+            channel.receive()
+        }.also { serverState.asyncResponseState.pendingResponses.remove(label) }
     }
 
     override fun connect() {

src/main/kotlin/com/dmdirc/ktirc/events/handlers/LabelledResponseHandler.kt

 internal class LabelledResponseHandler : EventHandler {
 
     override fun processEvent(client: IrcClient, event: IrcEvent) {
-        event.metadata.label?.let {
-            GlobalScope.launch {
-                client.serverState.labelChannels[it]?.send(event)
-            }
-        }
+        client.serverState.asyncResponseState.pendingResponses.values
+                .filter { it.second(event) }
+                .forEach {
+                    GlobalScope.launch {
+                        it.first.send(event)
+                    }
+                }
     }
 
 }

src/main/kotlin/com/dmdirc/ktirc/model/ServerState.kt

     internal val batches = mutableMapOf<String, Batch>()
 
     /**
-     * Counter for ensuring sent labels are unique.
-     */
-    internal val labelCounter = AtomicLong(0)
-
-    /**
-     * Whether or not the server supports labeled responses.
-     */
-    internal val supportsLabeledResponses: Boolean
-        get() = Capability.LabeledResponse in capabilities.enabledCapabilities
-
-    /**
-     * Channels waiting for a label to be received.
+     * Asynchronous command state.
      */
-    internal val labelChannels = mutableMapOf<String, SendChannel<IrcEvent>>()
+    internal val asyncResponseState = AsyncResponseState(capabilities)
 
     /**
      * Determines if the given mode is one applied to a user of a channel, such as 'o' for operator.
         capabilities.reset()
         sasl.reset()
         batches.clear()
+        asyncResponseState.reset()
+    }
+
+}
+
+internal class AsyncResponseState(private val capabilities : CapabilitiesState) {
+
+
+    /**
+     * Counter for ensuring sent labels are unique.
+     */
+    internal val labelCounter = AtomicLong(0)
+
+    /**
+     * Whether or not the server supports labeled responses.
+     */
+    internal val supportsLabeledResponses: Boolean
+        get() = Capability.LabeledResponse in capabilities.enabledCapabilities
+
+    /**
+     * Channels waiting for a response to be received.
+     */
+    internal val pendingResponses = mutableMapOf<String, Pair<SendChannel<IrcEvent>, (IrcEvent) -> Boolean>>()
+
+    internal fun reset() {
         labelCounter.set(0)
-        labelChannels.clear()
+        pendingResponses.clear()
     }
 
 }

src/main/kotlin/com/dmdirc/ktirc/util/Labels.kt

 
 internal fun defaultGenerateLabel(ircClient: IrcClient): String {
     val time = currentTimeProvider().toEpochSecond(ZoneOffset.UTC)
-    val counter = ircClient.serverState.labelCounter.incrementAndGet()
+    val counter = ircClient.serverState.asyncResponseState.labelCounter.incrementAndGet()
     return ByteArray(6) {
         when {
             it < 3 -> (time shr it and 0xff).toByte()

src/test/kotlin/com/dmdirc/ktirc/IrcClientImplTest.kt

         client.socketFactory = mockSocketFactory
         client.connect()
 
-        client.sendAsync(tagMap(), "testing", "123")
+        client.sendAsync(tagMap(), "testing", arrayOf("123")) { false }
 
         assertLineReceived("testing 123")
     }
         client.serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
         client.connect()
 
-        client.sendAsync(tagMap(), "testing", "123")
+        client.sendAsync(tagMap(), "testing", arrayOf("123")) { false }
 
         assertLineReceived("@draft/label=abc123 testing 123")
     }
         client.serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
         client.connect()
 
-        client.sendAsync(tagMap(MessageTag.AccountName to "x"), "testing", "123")
+        client.sendAsync(tagMap(MessageTag.AccountName to "x"), "testing", arrayOf("123")) { false }
 
         assertLineReceived("@account=x;draft/label=abc123 testing 123")
     }

src/test/kotlin/com/dmdirc/ktirc/model/ServerStateTest.kt

 
 import com.dmdirc.ktirc.TestConstants
 import com.dmdirc.ktirc.events.EventMetadata
+import com.dmdirc.ktirc.events.IrcEvent
 import kotlinx.coroutines.channels.Channel
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
     fun `indicates labels are enabled when cap is present`() {
         val serverState = ServerState("acidBurn", "")
         serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
-        assertTrue(serverState.supportsLabeledResponses)
+        assertTrue(serverState.asyncResponseState.supportsLabeledResponses)
     }
 
     @Test
     fun `indicates labels are not enabled when cap is absent`() {
         val serverState = ServerState("acidBurn", "")
-        assertFalse(serverState.supportsLabeledResponses)
+        assertFalse(serverState.asyncResponseState.supportsLabeledResponses)
     }
 
     @Test
         capabilities.advertisedCapabilities["sasl"] = "sure"
         sasl.saslBuffer = "in progress"
         batches["batch"] = Batch("type", emptyList(), EventMetadata(TestConstants.time))
-        labelCounter.set(100)
-        labelChannels["#thegibson"] = Channel(1)
+        asyncResponseState.labelCounter.set(100)
+        asyncResponseState.pendingResponses["#thegibson"] = Pair<Channel<IrcEvent>, (IrcEvent) -> Boolean>(Channel(1)) { false }
 
         reset()
 
         assertTrue(capabilities.advertisedCapabilities.isEmpty())
         assertEquals("", sasl.saslBuffer)
         assertTrue(batches.isEmpty())
-        assertEquals(0, labelCounter.get())
-        assertTrue(labelChannels.isEmpty())
+        assertEquals(0, asyncResponseState.labelCounter.get())
+        assertTrue(asyncResponseState.pendingResponses.isEmpty())
     }
 
 }

src/test/kotlin/com/dmdirc/ktirc/util/LabelsTest.kt

 
     @Test
     fun `increments the label id when generating labels`() {
-        assertEquals(0L, fakeServerState.labelCounter.get())
+        assertEquals(0L, fakeServerState.asyncResponseState.labelCounter.get())
         defaultGenerateLabel(ircClient)
-        assertEquals(1L, fakeServerState.labelCounter.get())
+        assertEquals(1L, fakeServerState.asyncResponseState.labelCounter.get())
         defaultGenerateLabel(ircClient)
-        assertEquals(2L, fakeServerState.labelCounter.get())
+        assertEquals(2L, fakeServerState.asyncResponseState.labelCounter.get())
     }
 
     @Test
     fun `generates unique labels at different times with the same counter value`() {
         currentTimeProvider = { TestConstants.time }
         val label1 = defaultGenerateLabel(ircClient)
-        fakeServerState.labelCounter.set(0L)
+        fakeServerState.asyncResponseState.labelCounter.set(0L)
         currentTimeProvider = { TestConstants.otherTime }
         val label2 = defaultGenerateLabel(ircClient)
         assertNotEquals(label1, label2)