Add channel mode enum, method to get mode

Groundwork for #5

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

  * Describes a user in a channel, and their modes.
  */
 data class ChannelUser(var nickname: String, var modes: String = "")
+
+/**
+ * The types of supported channel modes, and what parameters they require.
+ *
+ * These must be sorted according to the order they are sent in the CHANMODES server feature.
+ */
+enum class ChannelModeType {
+    /** The mode adds or removes an entry for a list. It must have a param to add or remove. */
+    List,
+    /** The mode has a parameter that must be present to set it or unset it. */
+    SetUnsetParameter,
+    /** The mode has a parameter that must be present to set it, but is unset without one. */
+    SetParameter,
+    /** The mode does not take parameters in any case. */
+    NoParameter;
+
+    /**
+     * Whether this mode requires a parameter to be set or not.
+     */
+    val needsParameterToSet: Boolean
+        get() = this != NoParameter
+
+    /**
+     * Whether this mode requires a parameter to be unset or not.
+     */
+    val needsParameterToUnset: Boolean
+        get() = this != NoParameter && this != SetParameter
+
+}

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

 package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.io.CaseMapping
+import com.dmdirc.ktirc.util.logger
 import kotlin.reflect.KClass
 
 /**
  */
 class ServerState internal constructor(initialNickname: String, initialServerName: String) {
 
+    private val log by logger()
+
     /** Whether we've received the 'Welcome to IRC' (001) message. */
     internal var receivedWelcome = false
 
     /** The capabilities we have negotiated with the server (from IRCv3). */
     val capabilities = CapabilitiesState()
 
+    /**
+     * Determines what type of channel mode the given character is, based on the server features.
+     *
+     * If the mode isn't found, or the server hasn't provided modes, it is presumed to be [ChannelModeType.NoParameter].
+     */
+    fun channelModeType(mode: Char): ChannelModeType {
+        features[ServerFeature.ChannelModes]?.forEachIndexed { index, modes ->
+            if (mode in modes) {
+                return ChannelModeType.values()[index]
+            }
+        }
+
+        log.warning { "Unknown channel mode $mode, assuming it's boolean" }
+        return ChannelModeType.NoParameter
+    }
+
 }
 
 /**

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

+package com.dmdirc.ktirc.model
+
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+internal class ChannelStateTest {
+
+    @Test
+    fun `ChannelModeType identifies which modes need parameters to set`() {
+        assertTrue(ChannelModeType.List.needsParameterToSet)
+        assertTrue(ChannelModeType.SetUnsetParameter.needsParameterToSet)
+        assertTrue(ChannelModeType.SetParameter.needsParameterToSet)
+        assertFalse(ChannelModeType.NoParameter.needsParameterToSet)
+    }
+
+    @Test
+    fun `ChannelModeType identifies which modes need parameters to unset`() {
+        assertTrue(ChannelModeType.List.needsParameterToUnset)
+        assertTrue(ChannelModeType.SetUnsetParameter.needsParameterToUnset)
+        assertFalse(ChannelModeType.SetParameter.needsParameterToUnset)
+        assertFalse(ChannelModeType.NoParameter.needsParameterToUnset)
+    }
+
+}

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

         assertEquals(ServerStatus.Disconnected, serverState.status)
     }
 
+    @Test
+    fun `returns mode type for known channel mode`() {
+        val serverState = ServerState("acidBurn", "")
+        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+        assertEquals(ChannelModeType.List, serverState.channelModeType('a'))
+        assertEquals(ChannelModeType.SetUnsetParameter, serverState.channelModeType('d'))
+        assertEquals(ChannelModeType.SetParameter, serverState.channelModeType('e'))
+        assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('g'))
+    }
+
+    @Test
+    fun `returns NoParameter for unknown channel mode`() {
+        val serverState = ServerState("acidBurn", "")
+        serverState.features[ServerFeature.ChannelModes] = arrayOf("ab", "cd", "ef", "gh")
+        assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('z'))
+    }
+
+    @Test
+    fun `returns NoParameter for channel modes if feature doesn't exist`() {
+        val serverState = ServerState("acidBurn", "")
+        assertEquals(ChannelModeType.NoParameter, serverState.channelModeType('b'))
+    }
+
 }
 
 internal class ModePrefixMappingTest {