Add messagecache

- Add MessageCache
- Add MemoryMessageCache
- Add transform parameter to applyGame extension methods
- Add transform parameter to GameAnimator
- Improve documentation of GameAnimatorBuilder
- Add structure for command module

Author: DRSchlaubi

common/src/main/java/me/schlaubi/regnumutils/common/builder/GameAnimatorBuilder.java

@@ -36,7 +36,9 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 /**
  * Builder for {@link GameAnimator}.
@@ -50,10 +52,11 @@ public class GameAnimatorBuilder {
 
     private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new DefaultThreadFactory("GameAnimator"));
     private List<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game> games = new ArrayList<>();
-    private Consumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game> applier;
+    private BiConsumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game, Function<String, String>> applier;
     private long interval = 30;
     private long initialDelay = 0;
     private TimeUnit unit = TimeUnit.SECONDS;
+    private Function<String, String> transform = it -> it;
 
     /**
      * Returns the currently selected scheduler.
@@ -128,8 +131,7 @@ public GameAnimatorBuilder addGames(Collection<cc.hawkbot.regnum.client.core.dis
      *
      * @return the {@link Consumer}
      */
-    @NotNull
-    public Consumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game> getApplier() {
+    public BiConsumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game, Function<String, String>> getApplier() {
         return applier;
     }
 
@@ -140,7 +142,7 @@ public Consumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game> getAppl
      * @return the {@link GameAnimatorBuilder}
      */
     @NotNull
-    public GameAnimatorBuilder setApplier(@NotNull Consumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game> applier) {
+    public GameAnimatorBuilder setApplier(BiConsumer<cc.hawkbot.regnum.client.core.discord.GameAnimator.Game, Function<String, String>> applier) {
         this.applier = applier;
         return this;
     }
@@ -158,6 +160,7 @@ public long getInterval() {
      * Sets the interval in which the games are going to be changed.
      *
      * @param interval the interval as a long
+     * @throws IllegalArgumentException when the interval is not grater than 0
      * @return the {@link GameAnimatorBuilder}
      */
     @NotNull
@@ -172,6 +175,7 @@ public GameAnimatorBuilder setInterval(long interval) {
      *
      * @param interval the interval
      * @param unit     the {@link TimeUnit} or {@code null} if you don't want to change it
+     * @throws IllegalArgumentException when the interval is not grater than 0
      * @return the {@link GameAnimatorBuilder}
      */
     @NotNull
@@ -196,6 +200,7 @@ public long getInitialDelay() {
      * Sets the amount of time till the first animation
      *
      * @param initialDelay the amount of time as a long
+     * @throws IllegalArgumentException when the initialDelay is negative
      * @return the {@link GameAnimatorBuilder}
      */
     @NotNull
@@ -210,6 +215,7 @@ public GameAnimatorBuilder setInitialDelay(long initialDelay) {
      *
      * @param initialDelay the amount of time as a long
      * @param unit         the {@link TimeUnit} or {@code null} if you don't want to change it
+     * @throws IllegalArgumentException when the initialDelay is negative
      * @return the {@link GameAnimatorBuilder}
      */
     @NotNull
@@ -253,23 +259,43 @@ public GameAnimatorBuilder setTimeUnit(@NotNull TimeUnit unit) {
      *
      * @param jda the {@link JDA} instance
      * @return the {@link GameAnimatorBuilder}
-     * @see GameAnimatorBuilder#setApplier(Consumer)
+     * @see GameAnimatorBuilder#setApplier(BiConsumer)
      */
     @NotNull
     public GameAnimatorBuilder setJDA(JDA jda) {
-        return setApplier((game) -> JDAExtensions.applyGame(jda, game));
+        return setApplier((game, transform) -> JDAExtensions.applyGame(jda, game, transform));
     }
 
     /**
      * Uses an {@link ShardManager} instance for the Applier.
      *
      * @param shardManager the {@link ShardManager} instance
      * @return the {@link GameAnimatorBuilder}
-     * @see GameAnimatorBuilder#setApplier(Consumer)
+     * @see GameAnimatorBuilder#setApplier(BiConsumer)
      */
     @NotNull
     public GameAnimatorBuilder setShardManager(ShardManager shardManager) {
-        return setApplier((game) -> JDAExtensions.applyGame(shardManager, game));
+        return setApplier((game, transform) -> JDAExtensions.applyGame(shardManager, game, transform));
+    }
+
+    /**
+     * Returns the function that transfroms every game before applying it
+     * @return the {@link Function}
+     */
+    @NotNull
+    public Function<String, String> getTransform() {
+        return transform;
+    }
+
+    /**
+     * Sets the function that transfroms every game before applying it
+     * @param transform the {@link Function}
+     * @return the {@link GameAnimatorBuilder}
+     */
+    @NotNull
+    public GameAnimatorBuilder setTransform(Function<String, String> transform) {
+        this.transform = transform;
+        return this;
     }
 
     /**
@@ -279,13 +305,15 @@ public GameAnimatorBuilder setShardManager(ShardManager shardManager) {
      */
     @NotNull
     public GameAnimator build() {
+        Preconditions.checkState(games.size() >= 2, "You have to register at least two games!");
         return new GameAnimator(
                 scheduler,
                 ImmutableList.copyOf(games),
                 applier,
                 interval,
                 initialDelay,
-                unit
+                unit,
+                transform
         );
     }
 }

common/src/main/java/me/schlaubi/regnumutils/common/constants/RegnumUtils.java

@@ -22,7 +22,7 @@
 /**
  * Some information about the Regnum utils library.
  */
-@SuppressWarnings("unused")
+@SuppressWarnings({"unused"})
 public class RegnumUtils {
 
     public static final String AUTHOR = "Michael \"Schlaubi\" Rittmeister";

common/src/main/kotlin/me/schlaubi/regnumutils/common/GameAnimator.kt

@@ -25,7 +25,9 @@ import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ScheduledFuture
 import java.util.concurrent.ThreadLocalRandom
 import java.util.concurrent.TimeUnit
+import java.util.function.BiConsumer
 import java.util.function.Consumer
+import java.util.function.Function
 
 /**
  * Animates the bots presence according to the specified [interval] and [TimeUnit][unit].
@@ -39,21 +41,13 @@ import java.util.function.Consumer
 class GameAnimator internal constructor(
     private val scheduler: ScheduledExecutorService,
     private val games: List<GameAnimator.Game>,
-    private val applier: Consumer<GameAnimator.Game>,
+    private val applier: BiConsumer<GameAnimator.Game, Function<String, String>>,
     private val interval: Long = 30,
     private val initialDelay: Long = 0,
-    private val unit: TimeUnit = TimeUnit.SECONDS
+    private val unit: TimeUnit = TimeUnit.SECONDS,
+    private val transform: Function<String, String>
 ) {
 
-    companion object {
-        /**
-         * Creates a new [GameAnimatorBuilder].
-         * @return the [GameAnimatorBuilder]
-         */
-        @JvmStatic
-        fun builder() = GameAnimatorBuilder()
-    }
-
     /**
      * Starts the animator.
      * @return a [ScheduledFuture] representing the task
@@ -66,6 +60,15 @@ class GameAnimator internal constructor(
      */
     fun stop(): List<Runnable> = scheduler.shutdownNow()
 
-    private fun animate() = applier.accept(games[ThreadLocalRandom.current().nextInt(games.size - 1)])
+    private fun animate() = applier.accept(games[ThreadLocalRandom.current().nextInt(games.size - 1)], transform)
+
+    companion object {
+        /**
+         * Creates a new [GameAnimatorBuilder].
+         * @return the [GameAnimatorBuilder]
+         */
+        @JvmStatic
+        fun builder() = GameAnimatorBuilder()
+    }
 }
 

common/src/main/kotlin/me/schlaubi/regnumutils/common/cache/MemoryMessageCache.kt

@@ -0,0 +1,55 @@
+/*
+ * Regnum - A Discord bot clustering system made for Hawk
+ *
+ * Copyright (C) 2019  Michael Rittmeister
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see https://www.gnu.org/licenses/.
+ */
+
+package me.schlaubi.regnumutils.common.cache
+
+import net.dv8tion.jda.api.entities.Message
+
+class MemoryMessageCache private constructor() : MessageCache {
+
+    private val storage = mutableMapOf<Long, Message>()
+
+    override val keys: MutableSet<Long>
+        get() = storage.keys
+
+    override val values: MutableCollection<Message>
+        get() = storage.values
+
+    override val size: Int
+        get() = storage.size
+
+    override fun contains(id: Long) = storage.containsKey(id)
+
+    override fun isEmpty() = storage.isEmpty()
+
+    override fun get(key: Long) = storage[key]
+
+    override fun put(key: Long, value: Message) = storage.put(key, value)
+
+    override fun remove(key: Long) = storage.remove(key)
+
+    override fun clear() = storage.clear()
+
+    companion object {
+        /**
+         * @see MessageCache.activate
+         */
+        internal fun create() = MemoryMessageCache()
+    }
+}