Add some utilities.

Author: vLuckyyy

eternalcode-commons-bukkit/src/main/java/com/eternalcode/commons/bukkit/runnable/OnlinePlayersRunnable.java

@@ -0,0 +1,56 @@
+package com.eternalcode.commons.bukkit.runnable;
+
+import java.util.Collection;
+import java.util.function.Consumer;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public abstract class OnlinePlayersRunnable implements Runnable {
+
+    public static OnlinePlayersRunnable consuming(Consumer<Player> consumer) {
+        if (consumer == null) {
+            throw new IllegalArgumentException("Consumer cannot be null");
+        }
+
+        return new OnlinePlayersRunnable() {
+            @Override
+            public void runFor(Player player) {
+                consumer.accept(player);
+            }
+        };
+    }
+
+    public static Runnable asRunnable(Consumer<Player> consumer) {
+        return consuming(consumer);
+    }
+
+    @Override
+    public final void run() {
+        Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
+
+        if (onlinePlayers.isEmpty()) {
+            return;
+        }
+
+        for (Player player : onlinePlayers) {
+            if (player != null && player.isOnline()) {
+                try {
+                    runFor(player);
+                }
+                catch (Exception exception) {
+                    handlePlayerException(player, exception);
+                }
+            }
+        }
+    }
+
+    protected void handlePlayerException(Player player, Exception exception) {
+        Bukkit.getLogger().warning(
+            String.format(
+                "Error processing player %s: %s",
+                player.getName(), exception.getMessage())
+        );
+    }
+
+    public abstract void runFor(Player player);
+}

eternalcode-commons-shared/src/main/java/com/eternalcode/commons/ThrowingFunction.java

@@ -0,0 +1,51 @@
+package com.eternalcode.commons;
+
+/*
+ * Copyright (c) 2021 dzikoysk
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.util.function.Function;
+
+@FunctionalInterface
+public interface ThrowingFunction<T, R, E extends Throwable> {
+
+    static <T, S extends Exception> ThrowingFunction<T, T, S> identity() {
+        return t -> t;
+    }
+    /**
+     * Map throwing function in default stream api with exception consume support
+     *
+     * @param function         the function to apply
+     * @param exceptionHandler the exception consumer
+     * @param <T>              type of function parameter
+     * @param <R>              type of function result
+     * @param <E>              type of exception
+     * @return a new function
+     */
+    @SuppressWarnings("unchecked")
+    static <T, R, E extends Throwable> Function<T, R> asFunction(
+        ThrowingFunction<T, R, E> function,
+        Function<E, R> exceptionHandler) {
+        return value -> {
+            try {
+                return function.apply(value);
+            }
+            catch (Throwable exception) {
+                return exceptionHandler.apply((E) exception);
+            }
+        };
+    }
+    R apply(T t) throws E;
+}

eternalcode-commons-shared/src/main/java/com/eternalcode/commons/algorithm/BatchProcessor.java

@@ -0,0 +1,96 @@
+package com.eternalcode.commons.algorithm;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * Utility for processing collections in batches.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Batch_processing">Batch processing - Wikipedia</a>
+ */
+public class BatchProcessor<T> {
+
+    private final List<T> elements;
+    private final int batchSize;
+    private int position;
+
+    /**
+     * Creates a new batch processor.
+     *
+     * @param elements  collection to process
+     * @param batchSize size of each batch (must be > 0)
+     */
+    public BatchProcessor(Collection<T> elements, int batchSize) {
+        if (batchSize <= 0) {
+            throw new IllegalArgumentException("Batch size must be greater than 0");
+        }
+
+        this.elements = new ArrayList<>(elements);
+        this.batchSize = batchSize;
+        this.position = 0;
+    }
+
+    /**
+     * Processes the next batch of elements.
+     *
+     * @param processor action to apply to each element
+     * @return true if more elements remain, false if all processed
+     */
+    public boolean processNext(Consumer<T> processor) {
+        if (position >= elements.size()) {
+            return false;
+        }
+
+        int endPosition = Math.min(position + batchSize, elements.size());
+        List<T> currentBatch = elements.subList(position, endPosition);
+
+        currentBatch.forEach(processor);
+
+        position = endPosition;
+        return position < elements.size();
+    }
+
+    /**
+     * Resets processor to start from beginning.
+     */
+    public void reset() {
+        position = 0;
+    }
+
+    public int getBatchSize() {
+        return batchSize;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public int getTotalSize() {
+        return elements.size();
+    }
+
+    public boolean isComplete() {
+        return position >= elements.size();
+    }
+
+    public int getRemainingCount() {
+        return Math.max(0, elements.size() - position);
+    }
+
+    public int getProcessedBatchCount() {
+        return (position + batchSize - 1) / batchSize;
+    }
+
+    public int getTotalBatchCount() {
+        return (elements.size() + batchSize - 1) / batchSize;
+    }
+
+    public double getProgress() {
+        if (elements.isEmpty()) {
+            return 1.0;
+        }
+        return (double) position / elements.size();
+    }
+}

eternalcode-commons-shared/src/main/java/com/eternalcode/commons/concurrent/FutureHandler.java

@@ -0,0 +1,39 @@
+package com.eternalcode.commons.concurrent;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public final class FutureHandler<T> implements BiConsumer<T, Throwable> {
+
+    private static final Logger LOGGER = Logger.getLogger(FutureHandler.class.getName());
+
+    private final Consumer<T> success;
+
+    private FutureHandler(Consumer<T> success) {
+        this.success = success;
+    }
+
+    public static <T> FutureHandler<T> whenSuccess(Consumer<T> success) {
+        return new FutureHandler<>(success);
+    }
+
+    public static <T> T handleException(Throwable cause) {
+        LOGGER.log(
+            Level.SEVERE,
+            String.format("Caught an exception in future execution: %s", cause.getMessage()),
+            cause);
+        return null;
+    }
+
+    @Override
+    public void accept(T value, Throwable cause) {
+        if (cause != null) {
+            LOGGER.log(Level.SEVERE, "Caught an exception in future execution: " + cause.getMessage(), cause);
+            return;
+        }
+
+        success.accept(value);
+    }
+}

eternalcode-commons-shared/src/main/java/com/eternalcode/commons/time/DurationTickUtil.java

@@ -0,0 +1,29 @@
+package com.eternalcode.commons.time;
+
+import java.time.Duration;
+
+/**
+ * Utility for converting Duration to Minecraft server ticks.
+ *
+ * @see <a href="https://minecraft.wiki/w/Tick">Tick - Minecraft Wiki</a>
+ */
+public final class DurationTickUtil {
+
+    private static final int TICK_DURATION_MILLIS = 50;
+
+    private DurationTickUtil() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    /**
+     * Converts Duration to Minecraft server ticks.
+     * One tick equals 50 milliseconds (20 TPS).
+     *
+     * @param duration the duration to convert
+     * @return number of ticks
+     * @throws ArithmeticException if the result overflows an int
+     */
+    public static int durationToTicks(Duration duration) {
+        return Math.toIntExact(duration.toMillis() / TICK_DURATION_MILLIS);
+    }
+}