Add ImmutableRangeMap.toImmutableRangeMap with Key, Value, and Merge Functions (#6822)Issue 6822

guava-tests/test/com/google/common/collect/toImmutableRangeMapTest.java

@@ -0,0 +1,5 @@
+package com.google.common.collect;
+
+public class toImmutableRangeMapTest {
+
+}

guava/src/com/google/common/collect/ImmutableRangeMap.java

@@ -35,6 +35,7 @@
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
 import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.stream.Collector;
 import javax.annotation.CheckForNull;
@@ -67,6 +68,67 @@ public class ImmutableRangeMap<K extends Comparable<?>, V> implements RangeMap<K
     return CollectCollectors.toImmutableRangeMap(keyFunction, valueFunction);
   }
 
+  /**
+   * Returns a {@code Collector} that accumulates elements into a {@code ImmutableRangeMap},
+   * resolving overlapping ranges using the provided merge function.
+   *
+   * @param keyFunction the function to derive the range key from elements
+   * @param valueFunction the function to derive the value from elements
+   * @param mergeFunction the binary operator used to merge values of overlapping ranges
+   * @param <T> the type of input elements
+   * @param <K> the key type of the map, extending Comparable
+   * @param <V> the value type of the map
+   * @return a {@code Collector} that collects elements into a {@code ImmutableRangeMap}
+   */
+  public static <T, K extends Comparable<? super K>, V> Collector<T, ?, ImmutableRangeMap<K, V>> toImmutableRangeMap(
+          Function<? super T, Range<K>> keyFunction,
+          Function<? super T, ? extends V> valueFunction,
+          BinaryOperator<V> mergeFunction) {
+
+    return Collector.of(
+            TreeRangeMap::<K, V>create,  // Use type inference to create a TreeRangeMap instance.
+            (map, element) -> {
+              Range<K> key = keyFunction.apply(element);
+              V value = valueFunction.apply(element);
+
+              // Check for overlapping ranges
+              RangeMap<K, V> overlappingMap = map.subRangeMap(key);
+              if (!overlappingMap.asMapOfRanges().isEmpty()) {
+                // If there are overlapping ranges, merge the values
+                for (Map.Entry<Range<K>, V> entry : overlappingMap.asMapOfRanges().entrySet()) {
+                  V existingValue = entry.getValue();
+                  value = mergeFunction.apply(existingValue, value);
+                }
+                // Remove the original overlapping range
+                map.remove(key);
+              }
+
+              map.put(key, value);
+            },
+            (left, right) -> {
+              left.putAll(right);
+              return left;
+            },
+            map -> {
+              ImmutableList.Builder<Range<K>> rangesBuilder = new ImmutableList.Builder<>();
+              ImmutableList.Builder<V> valuesBuilder = new ImmutableList.Builder<>();
+
+              // Iterate over all ranges in the map
+              for (Map.Entry<Range<K>, V> entry : map.asMapOfRanges().entrySet()) {
+                rangesBuilder.add(entry.getKey());
+                valuesBuilder.add(entry.getValue());
+              }
+
+              // Construct an immutable ImmutableRangeMap.
+              return new ImmutableRangeMap<>(rangesBuilder.build(), valuesBuilder.build());
+            }
+    );
+  }
+
+
+
+
+
   /**
    * Returns an empty immutable range map.
    *