Massive cleanup!

Author: intisy

src/main/java/io/github/intisy/utils/collections/DoubleHashMap.java

@@ -0,0 +1,78 @@
+package io.github.intisy.utils.collections;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.stream.Collectors;
+
+/**
+ * A specialized HashMap that stores a key mapped to two values using the Doublet class.
+ * This class extends HashMap and provides additional methods to work with the two values
+ * associated with each key.
+ *
+ * @param <K> the type of keys maintained by this map
+ * @param <V1> the type of the first value
+ * @param <V2> the type of the second value
+ * @author Finn Birich
+ */
+
+@SuppressWarnings("unused")
+public class DoubleHashMap<K, V1, V2> extends HashMap<K, Doublet<V1, V2>> {
+    /**
+     * Associates the specified key with the specified values in this map.
+     * If the map previously contained a mapping for the key, the old value is replaced.
+     *
+     * @param key the key with which the specified values are to be associated
+     * @param value1 the first value to be associated with the specified key
+     * @param value2 the second value to be associated with the specified key
+     */
+    public void put(K key, V1 value1, V2 value2) {
+        super.put(key, new Doublet<>(value1, value2));
+    }
+
+    /**
+     * Returns the first value to which the specified key is mapped,
+     * or null if this map contains no mapping for the key.
+     *
+     * @param key the key whose associated first value is to be returned
+     * @return the first value to which the specified key is mapped, or
+     *         null if this map contains no mapping for the key
+     * @throws NullPointerException if the mapping for the key is null
+     */
+    public V1 getValue1(K key) {
+        return get(key).getKey();
+    }
+
+    /**
+     * Returns the second value to which the specified key is mapped,
+     * or null if this map contains no mapping for the key.
+     *
+     * @param key the key whose associated second value is to be returned
+     * @return the second value to which the specified key is mapped, or
+     *         null if this map contains no mapping for the key
+     * @throws NullPointerException if the mapping for the key is null
+     */
+    public V2 getValue2(K key) {
+        return get(key).getValue();
+    }
+
+    /**
+     * Returns a collection view of the first values contained in this map.
+     * The collection is backed by the map, so changes to the map are reflected in the collection.
+     *
+     * @return a collection view of the first values contained in this map
+     */
+    public Collection<V1> values1() {
+        return values().stream().map(Doublet::getKey).collect(Collectors.toList());
+    }
+
+    /**
+     * Returns a collection view of the second values contained in this map.
+     * The collection is backed by the map, so changes to the map are reflected in the collection.
+     *
+     * @return a collection view of the second values contained in this map
+     */
+    public Collection<V2> values2() {
+        return values().stream().map(Doublet::getValue).collect(Collectors.toList());
+    }
+}
+

src/main/java/io/github/intisy/utils/collections/Doublet.java

@@ -0,0 +1,78 @@
+package io.github.intisy.utils.collections;
+
+/**
+ * A generic class representing a key-value pair.
+ * This class is used to store two related objects together, typically as a key and its associated value.
+ * It provides methods to access and modify both the key and value.
+ *
+ * @param <K> the type of the key
+ * @param <V> the type of the value
+ * @author Finn Birich
+ */
+@SuppressWarnings("unused")
+public class Doublet<K, V> {
+    private K key;
+    private V value;
+
+    /**
+     * Constructs a new Doublet with the specified key and value.
+     *
+     * @param key the key of this doublet
+     * @param value the value of this doublet
+     */
+    public Doublet(K key, V value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    /**
+     * Returns the key of this doublet.
+     *
+     * @return the key
+     */
+    public K getKey() {
+        return key;
+    }
+
+    /**
+     * Sets the key of this doublet.
+     *
+     * @param key the new key to set
+     */
+    public void setKey(K key) {
+        this.key = key;
+    }
+
+    /**
+     * Returns the value of this doublet.
+     *
+     * @return the value
+     */
+    public V getValue() {
+        return value;
+    }
+
+    /**
+     * Sets the value of this doublet.
+     *
+     * @param value1 the new value to set
+     */
+    public void setValue1(V value1) {
+        this.value = value1;
+    }
+
+    /**
+     * Returns a string representation of this doublet.
+     * The string representation consists of the key and value separated by commas
+     * and enclosed in brackets.
+     *
+     * @return a string representation of this doublet
+     */
+    @Override
+    public String toString() {
+        return "Triplet{" +
+                "key=" + key +
+                ", value=" + value +
+                '}';
+    }
+}

src/main/java/io/github/intisy/utils/collections/Triplet.java

@@ -0,0 +1,101 @@
+package io.github.intisy.utils.collections;
+
+/**
+ * A generic class representing a triplet of objects: a key and two associated values.
+ * This class is used to store three related objects together, providing methods to
+ * access and modify each component.
+ *
+ * @param <K> the type of the key
+ * @param <V1> the type of the first value
+ * @param <V2> the type of the second value
+ * @author Finn Birich
+ */
+@SuppressWarnings("unused")
+public class Triplet<K, V1, V2> {
+    private K key;
+    private V1 value1;
+    private V2 value2;
+
+    /**
+     * Constructs a new Triplet with the specified key and two values.
+     *
+     * @param key the key of this triplet
+     * @param value1 the first value of this triplet
+     * @param value2 the second value of this triplet
+     */
+    public Triplet(K key, V1 value1, V2 value2) {
+        this.key = key;
+        this.value1 = value1;
+        this.value2 = value2;
+    }
+
+    /**
+     * Returns the key of this triplet.
+     *
+     * @return the key
+     */
+    public K getKey() {
+        return key;
+    }
+
+    /**
+     * Sets the key of this triplet.
+     *
+     * @param key the new key to set
+     */
+    public void setKey(K key) {
+        this.key = key;
+    }
+
+    /**
+     * Returns the first value of this triplet.
+     *
+     * @return the first value
+     */
+    public V1 getValue1() {
+        return value1;
+    }
+
+    /**
+     * Sets the first value of this triplet.
+     *
+     * @param value1 the new first value to set
+     */
+    public void setValue1(V1 value1) {
+        this.value1 = value1;
+    }
+
+    /**
+     * Returns the second value of this triplet.
+     *
+     * @return the second value
+     */
+    public V2 getValue2() {
+        return value2;
+    }
+
+    /**
+     * Sets the second value of this triplet.
+     *
+     * @param value2 the new second value to set
+     */
+    public void setValue2(V2 value2) {
+        this.value2 = value2;
+    }
+
+    /**
+     * Returns a string representation of this triplet.
+     * The string representation consists of the key and both values separated by commas
+     * and enclosed in brackets.
+     *
+     * @return a string representation of this triplet
+     */
+    @Override
+    public String toString() {
+        return "Triplet{" +
+                "key=" + key +
+                ", value1=" + value1 +
+                ", value2=" + value2 +
+                '}';
+    }
+}

src/main/java/io/github/intisy/utils/concurrency/RetryUtils.java

@@ -0,0 +1,55 @@
+package io.github.intisy.utils.concurrency;
+
+/**
+ * Utility class providing functionality for retrying operations that might fail.
+ * This class allows operations to be retried indefinitely until they succeed,
+ * with optional wait periods between retry attempts.
+ *
+ * @author Finn Birich
+ */
+@SuppressWarnings("unused")
+public class RetryUtils {
+    /**
+     * Executes the provided operation and retries indefinitely until it succeeds.
+     * If the operation fails, it will be retried immediately without any delay.
+     *
+     * @param retryable the operation to execute and potentially retry
+     */
+    public static void run(Retryable retryable) {
+        run(0, retryable);
+    }
+
+    /**
+     * Executes the provided operation and retries indefinitely until it succeeds.
+     * If the operation fails, it will be retried after waiting for the specified
+     * number of milliseconds. If wait is 0 or negative, retries will happen immediately.
+     *
+     * @param wait the number of milliseconds to wait between retry attempts
+     * @param retryable the operation to execute and potentially retry
+     */
+    public static void run(int wait, Retryable retryable) {
+        while (true) {
+            try {
+                retryable.run();
+                break;
+            } catch (Exception e) {
+                if (wait > 0)
+                    ThreadUtils.sleep(wait);
+            }
+        }
+    }
+
+    /**
+     * Interface for operations that can be retried.
+     * Implementations of this interface represent operations that might fail
+     * and need to be retried until they succeed.
+     */
+    public interface Retryable {
+        /**
+         * Executes the retryable operation.
+         *
+         * @throws Exception if the operation fails and should be retried
+         */
+        void run() throws Exception;
+    }
+}