Make state mutation funs internal

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

 
     private val items = HashSet<String>()
 
-    operator fun plusAssign(item: String) {
+    internal operator fun plusAssign(item: String) {
         if (!contains(item)) {
             items += item
         }
     }
 
-    operator fun minusAssign(item: String) {
+    internal operator fun minusAssign(item: String) {
         items.removeIf { caseMappingProvider().areEquivalent(it, item) }
     }
 
     operator fun contains(item: String) = items.any { caseMappingProvider().areEquivalent(it, item) }
 
-    override operator fun iterator() = items.iterator()
+    override operator fun iterator() = items.iterator().iterator()
 
     fun isEmpty() = items.isEmpty()
 

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

 
     operator fun get(name: String) = values.find { caseMappingProvider().areEquivalent(nameOf(it), name) }
 
-    operator fun plusAssign(value: T) {
+    internal operator fun plusAssign(value: T) {
         require(get(nameOf(value)) == null) { "Value already registered: ${nameOf(value)}"}
         values.add(value)
     }
 
-    operator fun minusAssign(name: String) {
+    internal operator fun minusAssign(name: String) {
         values.removeIf { caseMappingProvider().areEquivalent(nameOf(it), name) }
     }
 
     operator fun contains(name: String) = get(name) != null
 
-    override fun iterator() = values.iterator()
+    override fun iterator() = values.iterator().iterator()
 
-    fun clear() = values.clear()
+    internal fun clear() = values.clear()
 
-    fun removeIf(predicate: (T) -> Boolean) = values.removeIf(predicate)
+    internal fun removeIf(predicate: (T) -> Boolean) = values.removeIf(predicate)
 
 }
 

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

     @Suppress("UNCHECKED_CAST")
     operator fun <T : Any> get(feature: ServerFeature<T>) = features.getOrDefault(feature, feature.default) as? T? ?: feature.default
 
-    operator fun set(feature: ServerFeature<*>, value: Any) {
+    internal operator fun set(feature: ServerFeature<*>, value: Any) {
         require(feature.type.isInstance(value))
         features[feature] = value
     }
 
-    fun setAll(featureMap: ServerFeatureMap) = featureMap.features.forEach { feature, value -> features[feature] = value }
-    fun reset(feature: ServerFeature<*>) = features.put(feature, null)
+    internal fun setAll(featureMap: ServerFeatureMap) = featureMap.features.forEach { feature, value -> features[feature] = value }
+    internal fun reset(feature: ServerFeature<*>) = features.put(feature, null)
 
 }
 

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

     operator fun get(nickname: String) = users[nickname]
     operator fun get(user: User) = users[user.nickname]
 
-    operator fun plusAssign(details: User) { users += KnownUser(caseMappingProvider, details) }
-    operator fun minusAssign(details: User) { users -= details.nickname }
+    internal operator fun plusAssign(details: User) { users += KnownUser(caseMappingProvider, details) }
+    internal operator fun minusAssign(details: User) { users -= details.nickname }
 
-    override operator fun iterator() = users.iterator()
+    override operator fun iterator() = users.iterator().iterator()
 
-    fun removeIf(predicate: (KnownUser) -> Boolean) = users.removeIf(predicate)
+    internal fun removeIf(predicate: (KnownUser) -> Boolean) = users.removeIf(predicate)
 
-    fun update(user: User, oldNick: String = user.nickname) {
+    internal fun update(user: User, oldNick: String = user.nickname) {
         users[oldNick]?.details?.updateFrom(user)
     }
 
-    fun addToChannel(user: User, channel: String) {
+    internal fun addToChannel(user: User, channel: String) {
         users[user.nickname]?.let {
             it += channel
         } ?: run {
 
     val channels = CaseInsensitiveSet(caseMappingProvider)
 
-    operator fun plusAssign(channel: String) { channels += channel }
-    operator fun minusAssign(channel: String) { channels -= channel }
+    internal operator fun plusAssign(channel: String) { channels += channel }
+    internal operator fun minusAssign(channel: String) { channels -= channel }
     operator fun contains(channel: String) = channel in channels
 
 }