make objectstorage more usable, add guildOnly to SubCommand annotation

Author: devoxin

src/main/kotlin/me/devoxin/flight/api/CommandClient.kt

@@ -263,11 +263,6 @@ class CommandClient(
             return false
         }
 
-        if (!ctx.isFromGuild && props.guildOnly) {
-            dispatchSafely { it.onCheckFailed(ctx, cmd, CheckType.GUILD_CHECK) }
-            return false
-        }
-
         if (ctx.isFromGuild) {
             if (props.userPermissions.isNotEmpty()) {
                 val userCheck = props.userPermissions.filterNot { ctx.member!!.hasPermission(ctx.guildChannel!!, it) }
@@ -291,6 +286,13 @@ class CommandClient(
                 dispatchSafely { it.onCheckFailed(ctx, cmd, CheckType.NSFW_CHECK) }
                 return false
             }
+        } else {
+            val subcommandProperties = (ctx.invokedCommand as? SubCommandFunction)?.properties
+
+            if (props.guildOnly || subcommandProperties?.guildOnly == true) {
+                dispatchSafely { it.onCheckFailed(ctx, cmd, CheckType.GUILD_CHECK) }
+                return false
+            }
         }
 
         return eventListeners.all { it.onCommandPreInvoke(ctx, cmd) }

src/main/kotlin/me/devoxin/flight/api/annotations/SubCommand.kt

@@ -12,5 +12,6 @@ package me.devoxin.flight.api.annotations
 @Target(AnnotationTarget.FUNCTION)
 annotation class SubCommand(
     val aliases: Array<String> = [],
-    val description: String = "No description available"
+    val description: String = "No description available",
+    val guildOnly: Boolean = false
 )

src/main/kotlin/me/devoxin/flight/api/entities/ObjectStorage.kt

@@ -1,18 +1,28 @@
 package me.devoxin.flight.api.entities
 
 import java.util.concurrent.ConcurrentHashMap
+import kotlin.collections.MutableMap.MutableEntry
 
-class ObjectStorage {
+class ObjectStorage : MutableMap<String, Any> {
     private val map = ConcurrentHashMap<String, Any>()
 
-    val size: Int
+    override val size: Int
         get() = map.size
 
+    override val entries: MutableSet<MutableEntry<String, Any>>
+        get() = map.entries
+
+    override val keys: MutableSet<String>
+        get() = map.keys
+
+    override val values: MutableCollection<Any>
+        get() = map.values
+
     operator fun set(key: String, value: Any) {
         map[key] = value
     }
 
-    operator fun get(key: String): Any? {
+    override operator fun get(key: String): Any? {
         return map[key]
     }
 
@@ -28,10 +38,23 @@ class ObjectStorage {
 
     @Suppress("UNCHECKED_CAST")
     fun <T : Any> computeIfAbsent(key: String, initializer: (String) -> T): T {
-        return map.computeIfAbsent(key, initializer) as T
+        return map.computeIfAbsent(key, initializer) as? T
+            ?: throw IllegalStateException("Computed object is not of type T!")
     }
 
-    fun clear() {
+    override fun clear() {
         map.clear()
     }
+
+    override fun isEmpty() = map.isEmpty()
+
+    override fun remove(key: String): Any? = map.remove(key)
+
+    override fun putAll(from: Map<out String, Any>) = map.putAll(from)
+
+    override fun put(key: String, value: Any): Any? = map.put(key, value)
+
+    override fun containsValue(value: Any) = map.containsValue(value)
+
+    override fun containsKey(key: String) = map.containsKey(key)
 }