commons: additional collection utils

src/main/java/io/gitlab/jfronny/commons/data/MutCollection.java

@@ -0,0 +1,89 @@
+package io.gitlab.jfronny.commons.data;
+
+import java.util.*;
+
+public class MutCollection {
+    public static <K, V> Map<K, V> mapOf() {
+        return new LinkedHashMap<>();
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1) {
+        Map<K, V> map = mapOf();
+        map.put(k1, v1);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2) {
+        Map<K, V> map = mapOf(k1, v1);
+        map.put(k2, v2);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2);
+        map.put(k3, v3);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3);
+        map.put(k4, v4);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3, k4, v4);
+        map.put(k5, v5);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
+        map.put(k6, v6);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6);
+        map.put(k7, v7);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7);
+        map.put(k8, v8);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8);
+        map.put(k9, v9);
+        return map;
+    }
+
+    public static <K, V> Map<K, V> mapOf(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
+        Map<K, V> map = mapOf(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5, k6, v6, k7, v7, k8, v8, k9, v9);
+        map.put(k10, v10);
+        return map;
+    }
+
+    public static <T> Set<T> setOf() {
+        return new LinkedHashSet<>();
+    }
+
+    public static <T> Set<T> setOf(T... entries) {
+        Set<T> set = setOf();
+        set.addAll(Arrays.asList(entries));
+        return set;
+    }
+
+    public static <T> List<T> listOf() {
+        return new LinkedList<>();
+    }
+
+    public static <T> List<T> listOf(T... entries) {
+        List<T> list = listOf();
+        list.addAll(Arrays.asList(entries));
+        return list;
+    }
+}

src/main/java/io/gitlab/jfronny/commons/data/delegate/DelegateCollection.java

@@ -0,0 +1,96 @@
+package io.gitlab.jfronny.commons.data.delegate;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.function.IntFunction;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+public class DelegateCollection<T, S extends Collection<T>> extends DelegateIterable<T, S> implements Collection<T> {
+    public DelegateCollection(S delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public int size() {
+        return delegate.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return delegate.isEmpty();
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        return delegate.contains(o);
+    }
+
+    @NotNull
+    @Override
+    public Object[] toArray() {
+        return delegate.toArray();
+    }
+
+    @NotNull
+    @Override
+    public <T1> T1[] toArray(@NotNull T1[] t1s) {
+        return delegate.toArray(t1s);
+    }
+
+    @Override
+    public <T1> T1[] toArray(IntFunction<T1[]> generator) {
+        return delegate.toArray(generator);
+    }
+
+    @Override
+    public boolean add(T t) {
+        return delegate.add(t);
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        return delegate.remove(o);
+    }
+
+    @Override
+    public boolean containsAll(@NotNull Collection<?> collection) {
+        return delegate.containsAll(collection);
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends T> collection) {
+        return delegate.addAll(collection);
+    }
+
+    @Override
+    public boolean removeAll(@NotNull Collection<?> collection) {
+        return delegate.removeAll(collection);
+    }
+
+    @Override
+    public boolean removeIf(Predicate<? super T> filter) {
+        return delegate.removeIf(filter);
+    }
+
+    @Override
+    public boolean retainAll(@NotNull Collection<?> collection) {
+        return delegate.retainAll(collection);
+    }
+
+    @Override
+    public void clear() {
+        delegate.clear();
+    }
+
+    @Override
+    public Stream<T> stream() {
+        return delegate.stream();
+    }
+
+    @Override
+    public Stream<T> parallelStream() {
+        return delegate.parallelStream();
+    }
+}

src/main/java/io/gitlab/jfronny/commons/data/delegate/DelegateIterable.java

@@ -0,0 +1,29 @@
+package io.gitlab.jfronny.commons.data.delegate;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+public class DelegateIterable<T, S extends Iterable<T>> extends DelegateObject<S> implements Iterable<T> {
+    public DelegateIterable(S delegate) {
+        super(delegate);
+    }
+
+    @NotNull
+    @Override
+    public Iterator<T> iterator() {
+        return delegate.iterator();
+    }
+
+    @Override
+    public void forEach(Consumer<? super T> action) {
+        delegate.forEach(action);
+    }
+
+    @Override
+    public Spliterator<T> spliterator() {
+        return delegate.spliterator();
+    }
+}

src/main/java/io/gitlab/jfronny/commons/data/delegate/DelegateList.java

@@ -0,0 +1,75 @@
+package io.gitlab.jfronny.commons.data.delegate;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.UnaryOperator;
+
+public class DelegateList<T, S extends List<T>> extends DelegateCollection<T, S> implements List<T> {
+    public DelegateList(S delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public boolean addAll(int i, @NotNull Collection<? extends T> collection) {
+        return delegate.addAll(i, collection);
+    }
+
+    @Override
+    public void replaceAll(UnaryOperator<T> operator) {
+        delegate.replaceAll(operator);
+    }
+
+    @Override
+    public void sort(Comparator<? super T> c) {
+        delegate.sort(c);
+    }
+
+    @Override
+    public T get(int i) {
+        return delegate.get(i);
+    }
+
+    @Override
+    public T set(int i, T t) {
+        return delegate.set(i, t);
+    }
+
+    @Override
+    public void add(int i, T t) {
+        delegate.add(i, t);
+    }
+
+    @Override
+    public T remove(int i) {
+        return delegate.remove(i);
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        return delegate.indexOf(o);
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        return delegate.lastIndexOf(o);
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<T> listIterator() {
+        return delegate.listIterator();
+    }
+
+    @NotNull
+    @Override
+    public ListIterator<T> listIterator(int i) {
+        return delegate.listIterator(i);
+    }
+
+    @NotNull
+    @Override
+    public List<T> subList(int i, int i1) {
+        return delegate.subList(i, i1);
+    }
+}

src/main/java/io/gitlab/jfronny/commons/data/delegate/DelegateMap.java

@@ -0,0 +1,149 @@
+package io.gitlab.jfronny.commons.data.delegate;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.function.*;
+
+public class DelegateMap<K, V> extends DelegateObject<Map<K, V>> implements Map<K, V> {
+    public DelegateMap(Map<K, V> delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public int size() {
+        return delegate.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
+    @Override
+    public boolean containsKey(Object o) {
+        return false;
+    }
+
+    @Override
+    public boolean containsValue(Object o) {
+        return false;
+    }
+
+    @Override
+    public V get(Object o) {
+        return null;
+    }
+
+    @Nullable
+    @Override
+    public V put(K k, V v) {
+        return null;
+    }
+
+    @Override
+    public V remove(Object o) {
+        return null;
+    }
+
+    @Override
+    public void putAll(@NotNull Map<? extends K, ? extends V> map) {
+
+    }
+
+    @Override
+    public void clear() {
+
+    }
+
+    @NotNull
+    @Override
+    public Set<K> keySet() {
+        return null;
+    }
+
+    @NotNull
+    @Override
+    public Collection<V> values() {
+        return null;
+    }
+
+    @NotNull
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return null;
+    }
+
+    @Override
+    public V getOrDefault(Object key, V defaultValue) {
+        return Map.super.getOrDefault(key, defaultValue);
+    }
+
+    @Override
+    public void forEach(BiConsumer<? super K, ? super V> action) {
+        Map.super.forEach(action);
+    }
+
+    @Override
+    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
+        Map.super.replaceAll(function);
+    }
+
+    @Nullable
+    @Override
+    public V putIfAbsent(K key, V value) {
+        return Map.super.putIfAbsent(key, value);
+    }
+
+    @Override
+    public boolean remove(Object key, Object value) {
+        return Map.super.remove(key, value);
+    }
+
+    @Override
+    public boolean replace(K key, V oldValue, V newValue) {
+        return Map.super.replace(key, oldValue, newValue);
+    }
+
+    @Nullable
+    @Override
+    public V replace(K key, V value) {
+        return Map.super.replace(key, value);
+    }
+
+    @Override
+    public V computeIfAbsent(K key, @NotNull Function<? super K, ? extends V> mappingFunction) {
+        return Map.super.computeIfAbsent(key, mappingFunction);
+    }
+
+    @Override
+    public V computeIfPresent(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        return Map.super.computeIfPresent(key, remappingFunction);
+    }
+
+    @Override
+    public V compute(K key, @NotNull BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
+        return Map.super.compute(key, remappingFunction);
+    }
+
+    @Override
+    public V merge(K key, @NotNull V value, @NotNull BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
+        return Map.super.merge(key, value, remappingFunction);
+    }
+
+    @Override
+    public V set(K key, V value) {
+        return Map.super.set(key, value);
+    }
+
+    @Override
+    public Object call(Object proxy, Class<?> iface, String name, String actualName, Class<?> returnType, Class<?>[] paramTypes, Object[] args) {
+        return Map.super.call(proxy, iface, name, actualName, returnType, paramTypes, args);
+    }
+
+    @Override
+    public Iterator<Entry<K, V>> iterator() {
+        return Map.super.iterator();
+    }
+}

src/main/java/io/gitlab/jfronny/commons/data/delegate/DelegateObject.java

@@ -0,0 +1,30 @@
+package io.gitlab.jfronny.commons.data.delegate;
+
+import java.util.Objects;
+
+public class DelegateObject<T> {
+    protected final T delegate;
+
+    public DelegateObject(T delegate) {
+        this.delegate = Objects.requireNonNull(delegate) instanceof DelegateObject<?> dob ? (T) dob.unwrap() : delegate;
+    }
+
+    @Override
+    public int hashCode() {
+        return delegate.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof DelegateObject<?> dob ? delegate.equals(dob.delegate) : delegate.equals(obj);
+    }
+
+    @Override
+    public String toString() {
+        return delegate.toString();
+    }
+
+    private T unwrap() {
+        return delegate instanceof DelegateObject<?> dob ? (T) dob.unwrap() : delegate;
+    }
+}

src/main/java/io/gitlab/jfronny/commons/data/delegate/DelegateSet.java

@@ -0,0 +1,9 @@
+package io.gitlab.jfronny.commons.data.delegate;
+
+import java.util.Set;
+
+public class DelegateSet<T, S extends Set<T>> extends DelegateCollection<T, S> implements Set<T> {
+    public DelegateSet(S delegate) {
+        super(delegate);
+    }
+}

src/main/java/module-info.java

@@ -5,6 +5,7 @@ module io.gitlab.jfronny.commons {
     exports io.gitlab.jfronny.commons;
     exports io.gitlab.jfronny.commons.cache;
     exports io.gitlab.jfronny.commons.data;
+    exports io.gitlab.jfronny.commons.data.delegate;
     exports io.gitlab.jfronny.commons.io;
     exports io.gitlab.jfronny.commons.log;
     exports io.gitlab.jfronny.commons.ref;