remove config logger loading in ConfigLoader

config/src/main/java/module-info.java

@@ -4,10 +4,9 @@ import org.xbib.config.SystemConfigLogger;
 import org.xbib.settings.SettingsLoader;
 
 module org.xbib.config {
+    requires transitive org.xbib.settings.datastructures;
     exports org.xbib.config;
     uses ConfigLogger;
     uses SettingsLoader;
     provides ConfigLogger with NullConfigLogger, SystemConfigLogger;
-    requires org.xbib.settings.api;
-    requires transitive org.xbib.settings.datastructures;
 }

config/src/main/java/org/xbib/config/ConfigLoader.java

@@ -16,8 +16,6 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Optional;
-import java.util.ServiceLoader;
 import java.util.stream.Collectors;
 import org.xbib.settings.Settings;
 import org.xbib.settings.SettingsBuilder;
@@ -36,18 +34,8 @@ public class ConfigLoader {
     private ConfigLoader() {
     }
 
-    private static class Holder {
-        private static ConfigLogger createConfigLogger() {
-            ServiceLoader<ConfigLogger> serviceLoader = ServiceLoader.load(ConfigLogger.class);
-            Optional<ConfigLogger> optionalConfigLogger = serviceLoader.findFirst();
-            return optionalConfigLogger.orElse(new NullConfigLogger());
-        }
-
-        private static final ConfigLoader configLoader = new ConfigLoader().withLogger(createConfigLogger());
-    }
-
     public static ConfigLoader getInstance() {
-        return Holder.configLoader;
+        return new ConfigLoader();
     }
 
     public ConfigLoader withLogger(ConfigLogger logger) {

datastructures-api/src/main/java/org/xbib/datastructures/api/SortedSetMultimap.java

@@ -71,13 +71,7 @@ public interface SortedSetMultimap<K extends Object, V extends Object>
      * behavior as {@link #get}, returning a live collection. When passed a key that is not present,
      * however, {@code asMap().get(Object)} returns {@code null} instead of an empty collection.
      *
-     * <p><b>Note:</b> The returned map's values are guaranteed to be of type {@link SortedSet}. To
+     * <p><b>Note:</b> The returned map's values are guaranteed to be of type {@link SortedSet}.
-     * obtain this map with the more specific generic type {@code Map<K, SortedSet<V>>}, call {@link
-     * Multimaps#asMap(SortedSetMultimap)} instead. <b>However</b>, the returned map <i>itself</i> is
-     * not necessarily a {@link SortedMap}: A {@code SortedSetMultimap} must expose the <i>values</i>
-     * for a given key in sorted order, but it need not expose the <i>keys</i> in sorted order.
-     * Individual {@code SortedSetMultimap} implementations, like those built with {@link
-     * MultimapBuilder#treeKeys()}, may make additional guarantees.
      */
     @Override
     Map<K, Collection<V>> asMap();

datastructures-common/src/main/java/org/xbib/datastructures/common/AbstractMultiMap.java

@@ -15,7 +15,7 @@ import java.util.Set;
  */
 public abstract class AbstractMultiMap<K, V> implements MultiMap<K, V> {
 
-    private final Map<K, Collection<V>> map;
+    protected final Map<K, Collection<V>> map;
 
     public AbstractMultiMap() {
         this(null);

datastructures-immutable/src/main/java/org/xbib/datastructures/immutable/order/Ordering.java

@@ -95,8 +95,7 @@ import static org.xbib.datastructures.immutable.ImmutableMap.checkNonnegative;
  * <h3>For Java 8 users</h3>
  *
  * <p>If you are using Java 8, this class is now obsolete. Most of its functionality is now provided
- * by {@link java.util.stream.Stream Stream} and by {@link Comparator} itself, and the rest can now
+ * by {@link java.util.stream.Stream Stream} and by {@link Comparator} itself. See each method below for
- * be found as static methods in our new {@link Comparators} class. See each method below for
  * further instructions. Whenever possible, you should change any references of type {@code
  * Ordering} to be of type {@code Comparator} instead. However, at this time we have no plan to
  * <i>deprecate</i> this class.
@@ -393,8 +392,6 @@ public abstract class Ordering<T> implements Comparator<T> {
      * <p>Note that {@code ordering.lexicographical().reverse()} is not equivalent to {@code
      * ordering.reverse().lexicographical()} (consider how each would order {@code [1]} and {@code [1,
      * 1]}).
-     *
-     * <p><b>Java 8 users:</b> Use {@link Comparators#lexicographical(Comparator)} instead.
      */
     // type parameter <S> lets us avoid the extra <String> in statements like:
     // Ordering<Iterable<String>> o =
@@ -698,7 +695,7 @@ public abstract class Ordering<T> implements Comparator<T> {
      * only when the resulting list may need further modification, or may contain {@code null}. The
      * input is not modified. The returned list has random access.
      *
-     * <p>Unlike {@link Sets#newTreeSet(Iterable)}, this method does not discard elements that are
+     * <p>Unlike {@link java.util.Sets#newTreeSet(Iterable)}, this method does not discard elements that are
      * duplicates according to the comparator. The sort performed is <i>stable</i>, meaning that such
      * elements will appear in the returned list in the same order they appeared in {@code elements}.
      *
@@ -719,7 +716,7 @@ public abstract class Ordering<T> implements Comparator<T> {
      * Returns an <b>immutable</b> list containing {@code elements} sorted by this ordering. The input
      * is not modified.
      *
-     * <p>Unlike {@link Sets#newTreeSet(Iterable)}, this method does not discard elements that are
+     * <p>Unlike {@link java.util.Sets#newTreeSet(Iterable)}, this method does not discard elements that are
      * duplicates according to the comparator. The sort performed is <i>stable</i>, meaning that such
      * elements will appear in the returned list in the same order they appeared in {@code elements}.
      *
@@ -739,7 +736,7 @@ public abstract class Ordering<T> implements Comparator<T> {
      * equal to the element that preceded it, according to this ordering. Note that this is always
      * true when the iterable has fewer than two elements.
      *
-     * <p><b>Java 8 users:</b> Use the equivalent {@link Comparators#isInOrder(Iterable, Comparator)}
+     * <p><b>Java 8 users:</b> Use the equivalent {@link java.util.Comparators#isInOrder(Iterable, Comparator)}
      * instead, since the rest of {@code Ordering} is mostly obsolete (as explained in the class
      * documentation).
      */
@@ -763,7 +760,7 @@ public abstract class Ordering<T> implements Comparator<T> {
      * greater than the element that preceded it, according to this ordering. Note that this is always
      * true when the iterable has fewer than two elements.
      *
-     * <p><b>Java 8 users:</b> Use the equivalent {@link Comparators#isInStrictOrder(Iterable,
+     * <p><b>Java 8 users:</b> Use the equivalent {@link java.util.Comparators#isInStrictOrder(Iterable,
      * Comparator)} instead, since the rest of {@code Ordering} is mostly obsolete (as explained in
      * the class documentation).
      */

datastructures-tiny/src/main/java/org/xbib/datastructures/tiny/TinyMultiMap.java

@@ -30,4 +30,10 @@ public class TinyMultiMap<K, V> extends AbstractMultiMap<K, V> {
     protected Map<K, Collection<V>> newMap() {
         return TinyMap.builder();
     }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Map<K, Collection<V>> asMap() {
+        return ((TinyMap.Builder<K, Collection<V>>) map).build();
+    }
 }

datastructures-tiny/src/test/java/org/xbib/datastructures/tiny/TinyMultiMapTest.java

@@ -1,13 +1,16 @@
 package org.xbib.datastructures.tiny;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import java.util.Collection;
+import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.xbib.datastructures.common.MultiMap;
 
 public class TinyMultiMapTest {
 
     @Test
-    public void testMultiMap() {
+    public void testMultiMapPut() {
         MultiMap<String, String> multiMap = new TinyMultiMap<>();
         multiMap.put("a", "a");
         multiMap.put("a", "b");
@@ -17,4 +20,18 @@ public class TinyMultiMapTest {
         multiMap.put("b", "f");
         assertEquals("{a=[a, b, c], b=[d, e, f]}", multiMap.asMap().toString());
     }
+
+    @Test
+    public void testMultiMapValuesAreCollections() {
+        MultiMap<String, String> multiMap = new TinyMultiMap<>();
+        multiMap.put("a", "a");
+        multiMap.put("a", "b");
+        multiMap.put("a", "c");
+        multiMap.put("b", "d");
+        multiMap.put("b", "e");
+        multiMap.put("b", "f");
+        Map<String, Collection<String>> map = multiMap.asMap();
+        assertInstanceOf(Collection.class, map.get("a"));
+        assertInstanceOf(Collection.class, map.get("b"));
+    }
 }

gradle.properties

@@ -1,3 +1,3 @@
 group = org.xbib
 name = datastructures
-version = 5.0.6
+version = 5.0.7

settings.gradle

@@ -15,7 +15,6 @@ pluginManagement {
 dependencyResolutionManagement {
     versionCatalogs {
         libs {
-            version('gradle', '8.4')
             version('gradle', '8.5')
             library('chronicle-core', 'net.openhft', 'chronicle-core').version('2.21ea14')
             library('affinity', 'net.openhft', 'affinity').version('3.21ea0')
@@ -23,7 +22,7 @@ dependencyResolutionManagement {
             library('orgjson', 'org.json', 'json').version('20210307')
         }
         testLibs {
-            version('junit', '5.10.0')
+            version('junit', '5.10.2')
             version('jackson', '2.15.2')
             library('junit-jupiter-api', 'org.junit.jupiter', 'junit-jupiter-api').versionRef('junit')
             library('junit-jupiter-params', 'org.junit.jupiter', 'junit-jupiter-params').versionRef('junit')
@@ -64,7 +63,7 @@ include 'datastructures-json-minimal'
 include 'datastructures-json-noggit'
 include 'datastructures-json-simple'
 include 'datastructures-json-tiny'
-include 'datastructures-multi'
+//include 'datastructures-multi'
 include 'datastructures-queue-tape'
 include 'datastructures-raml'
 include 'datastructures-tiny'