Mapped list with index

.gitignore

@@ -4,3 +4,6 @@ build/
 .project
 .settings/
 .idea/
+gradle/
+gradlew
+gradle.bat

reactfx/build.gradle

@@ -9,7 +9,7 @@ group = 'org.reactfx'
 
 dependencies {
     // Test dependencies
-    testImplementation group: 'junit', name: 'junit', version: '4.12'
+    testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.13.4'
     testImplementation group: 'org.hamcrest', name: 'hamcrest-library', version: '1.3'
     testImplementation group: 'org.junit.contrib', name: 'junit-theories', version: '4.12'
     testImplementation group: 'com.pholser', name: 'junit-quickcheck-core', version: '0.4'

reactfx/src/main/java/org/reactfx/collection/LiveList.java

@@ -3,6 +3,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -21,6 +22,7 @@
 import org.reactfx.collection.LiveList.QuasiModificationObserver;
 import org.reactfx.util.AccumulatorSize;
 import org.reactfx.util.Experimental;
+import org.reactfx.util.Tuple2;
 import org.reactfx.util.WrapperBase;
 import org.reactfx.value.Val;
 
@@ -179,6 +181,10 @@ default <F> LiveList<F> map(Function<? super E, ? extends F> f) {
         return map(this, f);
     }
 
+    default <F> LiveList<F> map(BiFunction<Integer, ? super E, ? extends F> f) {
+        return map(this, f);
+    }
+
     default <F> LiveList<F> mapDynamic(
             ObservableValue<? extends Function<? super E, ? extends F>> f) {
         return mapDynamic(this, f);
@@ -291,12 +297,25 @@ static Val<Integer> sizeOf(ObservableList<?> list) {
         return Val.create(() -> list.size(), list);
     }
 
+    /**
+     * If you wish to use the index of the element in your mapping function, check {@link #map(ObservableList, BiFunction)}.
+     * @param f a mapping function taking the element from source as input and producing a result
+     */
     static <E, F> LiveList<F> map(
             ObservableList<? extends E> list,
             Function<? super E, ? extends F> f) {
         return new MappedList<>(list, f);
     }
 
+    /**
+     * @param f a mapping function taking the index and the element from source as input and producing a result
+     */
+    static <E, F> LiveList<F> map(
+            ObservableList<? extends E> list,
+            BiFunction<Integer, ? super E, ? extends F> f) {
+        return new MappedList<>(list, f);
+    }
+
     static <E, F> LiveList<F> mapDynamic(
             ObservableList<? extends E> list,
             ObservableValue<? extends Function<? super E, ? extends F>> f) {

reactfx/src/main/java/org/reactfx/collection/MappedList.java

@@ -1,6 +1,7 @@
 package org.reactfx.collection;
 
 import java.util.List;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 
 import javafx.beans.value.ObservableValue;
@@ -13,18 +14,24 @@
 class MappedList<E, F> extends LiveListBase<F>
 implements UnmodifiableByDefaultLiveList<F> {
     private final ObservableList<? extends E> source;
-    private final Function<? super E, ? extends F> mapper;
+    private final BiFunction<Integer, ? super E, ? extends F> mapper;
 
     public MappedList(
             ObservableList<? extends E> source,
             Function<? super E, ? extends F> mapper) {
+        this(source, (index, elem) -> mapper.apply(elem));
+    }
+
+    public MappedList(
+            ObservableList<? extends E> source,
+            BiFunction<Integer, ? super E, ? extends F> mapper) {
         this.source = source;
         this.mapper = mapper;
     }
 
     @Override
     public F get(int index) {
-        return mapper.apply(source.get(index));
+        return mapper.apply(index, source.get(index));
     }
 
     @Override
@@ -44,6 +51,12 @@ private void sourceChanged(QuasiListChange<? extends E> change) {
     static <E, F> QuasiListChange<F> mappedChangeView(
             QuasiListChange<? extends E> change,
             Function<? super E, ? extends F> mapper) {
+        return mappedChangeView(change, (index, elem) -> mapper.apply(elem));
+    }
+
+    static <E, F> QuasiListChange<F> mappedChangeView(
+            QuasiListChange<? extends E> change,
+            BiFunction<Integer, ? super E, ? extends F> mapper) {
         return new QuasiListChange<F>() {
 
             @Override
@@ -63,7 +76,7 @@ public int getAddedSize() {
 
                     @Override
                     public List<? extends F> getRemoved() {
-                        return Lists.mappedView(mod.getRemoved(), mapper);
+                        return Lists.mappedView(mod.getRemoved(), elem -> mapper.apply(mod.getFrom(), elem));
                     }
                 });
             }

reactfx/src/test/java/org/reactfx/collection/ListMapTest.java

@@ -1,34 +1,30 @@
 package org.reactfx.collection;
 
 import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertLinesMatch;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
+import java.util.stream.Stream;
 
 import javafx.beans.property.IntegerProperty;
 import javafx.beans.property.SimpleIntegerProperty;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 
 import org.junit.Test;
+import org.junit.jupiter.api.DisplayName;
 import org.reactfx.value.Var;
 
 public class ListMapTest {
-
-    @Test
-    public void testGet() {
-        ObservableList<String> strings = FXCollections.observableArrayList("1", "22", "333");
-        LiveList<Integer> lengths = LiveList.map(strings, String::length);
-
-        assertEquals(Arrays.asList(1, 2, 3), lengths);
-    }
-
     @Test
     public void testChanges() {
         ObservableList<String> strings = FXCollections.observableArrayList("1", "22", "333");
         LiveList<Integer> lengths = LiveList.map(strings, String::length);
+        assertEquals(Arrays.asList(1, 2, 3), lengths);
 
         List<Integer> removed = new ArrayList<>();
         List<Integer> added = new ArrayList<>();
@@ -39,34 +35,59 @@ public void testChanges() {
             }
         });
 
+        // Set an item
         strings.set(1, "4444");
+        assertEquals(Arrays.asList(1, 4, 3), lengths);
+        assertEquals(Collections.singletonList(2), removed);
+        assertEquals(Collections.singletonList(4), added);
+
+        // Add an item
+        strings.add("7777777");
+        assertEquals(Arrays.asList(1, 4, 3, 7), lengths);
+        assertEquals(Collections.singletonList(2), removed);
+        assertEquals(Arrays.asList(4, 7), added);
 
-        assertEquals(Arrays.asList(2), removed);
-        assertEquals(Arrays.asList(4), added);
+        // Remove an item
+        strings.remove(1);
+        assertEquals(Arrays.asList(1, 3, 7), lengths);
+        assertEquals(Arrays.asList(2, 4), removed);
+        assertEquals(Arrays.asList(4, 7), added);
     }
 
     @Test
     public void testLaziness() {
         ObservableList<String> strings = FXCollections.observableArrayList("1", "22", "333");
-        IntegerProperty evaluations = new SimpleIntegerProperty(0);
-        LiveList<Integer> lengths = LiveList.map(strings, s -> {
-            evaluations.set(evaluations.get() + 1);
-            return s.length();
+        IntegerProperty evaluationsCounter = new SimpleIntegerProperty(0);
+        LiveList<Integer> lengths = LiveList.map(strings, elem -> {
+            evaluationsCounter.set(evaluationsCounter.get() + 1);
+            return elem.length();
         });
 
         lengths.observeChanges(ch -> {});
         strings.remove(1);
 
-        assertEquals(0, evaluations.get());
+        assertEquals(0, evaluationsCounter.get());
+
+        // Get the first element and the counter has increased
+        assertEquals(1, lengths.get(0).intValue());
+        assertEquals(1, evaluationsCounter.get());
+
+        // Get the second element, it will evaluate one item
+        assertEquals(3, lengths.get(1).intValue());
+        assertEquals(2, evaluationsCounter.get());
+
+        // Get again the first, it will reevaluate it
+        assertEquals(1, lengths.get(0).intValue());
+        assertEquals(3, evaluationsCounter.get());
     }
 
     @Test
     public void testLazinessOnChangeAccumulation() {
         ObservableList<String> strings = FXCollections.observableArrayList("1", "22", "333");
-        IntegerProperty evaluations = new SimpleIntegerProperty(0);
-        LiveList<Integer> lengths = LiveList.map(strings, s -> {
-            evaluations.set(evaluations.get() + 1);
-            return s.length();
+        IntegerProperty evaluationsCounter = new SimpleIntegerProperty(0);
+        LiveList<Integer> lengths = LiveList.map(strings, elem -> {
+            evaluationsCounter.set(evaluationsCounter.get() + 1);
+            return elem.length();
         });
         SuspendableList<Integer> suspendable = lengths.suspendable();
 
@@ -76,7 +97,7 @@ public void testLazinessOnChangeAccumulation() {
             strings.set(1, "abcd");
         });
 
-        assertEquals(0, evaluations.get());
+        assertEquals(0, evaluationsCounter.get());
     }
 
     @Test
@@ -99,4 +120,68 @@ public void testDynamicMap() {
             fn.setValue(s -> s.length() * s.length());
         });
     }
+
+    @Test
+    public void testIndexedList() {
+        ObservableList<String> strings = FXCollections.observableArrayList("1", "22", "333");
+        // Live map receives index,item and returns %d-%d index item
+        LiveList<String> lengths = LiveList.map(strings, (index, item) -> String.format("%d-%d", index, item.length()));
+        assertLinesMatch(Stream.of("0-1", "1-2", "2-3"), lengths.stream());
+
+        List<String> removed = new ArrayList<>();
+        List<String> added = new ArrayList<>();
+        lengths.observeChanges(ch -> {
+            for(ListModification<? extends String> mod: ch.getModifications()) {
+                removed.addAll(mod.getRemoved());
+                added.addAll(mod.getAddedSubList());
+            }
+        });
+
+        // Set a value in the list and check changes
+        strings.set(1, "4444");
+        assertLinesMatch(Stream.of("0-1", "1-4", "2-3"), lengths.stream());
+        assertEquals(Collections.singletonList("1-4"), added);
+        assertEquals(Collections.singletonList("1-2"), removed);
+
+        // Add an entry to the list and check changes
+        strings.add("7777777");
+        assertLinesMatch(Stream.of("0-1", "1-4", "2-3", "3-7"), lengths.stream());
+        assertEquals(Arrays.asList("1-4", "3-7"), added);
+        assertEquals(Collections.singletonList("1-2"), removed);
+
+        // Remove an entry to the list and check changes (note that 3-7 becomes 2-7)
+        strings.remove(2);
+        assertLinesMatch(Stream.of("0-1", "1-4", "2-7"), lengths.stream());
+        assertEquals(Arrays.asList("1-4", "3-7"), added);
+        assertEquals(Arrays.asList("1-2", "2-3"), removed);
+    }
+
+    @Test
+    @DisplayName("testLazyIndexedList")
+    public void testLazyIndexedList() {
+        ObservableList<String> strings = FXCollections.observableArrayList("1", "22", "333");
+        IntegerProperty evaluationsCounter = new SimpleIntegerProperty(0);
+        LiveList<String> lengths = LiveList.map(strings, (index, elem) -> {
+            evaluationsCounter.set(evaluationsCounter.get() + 1);
+            return String.format("%d-%d", index, elem.length());
+        });
+
+        lengths.observeChanges(ch -> {});
+        strings.remove(1);
+
+        assertEquals(0, evaluationsCounter.get());
+
+        // Get the first element and the counter has increased
+        assertEquals("0-1", lengths.get(0));
+        assertEquals(1, evaluationsCounter.get());
+
+        // Get the second element, it will evaluate one item
+        assertEquals("1-3", lengths.get(1));
+        assertEquals(2, evaluationsCounter.get());
+
+        // Get again the first, it will reevaluate it
+        assertEquals("0-1", lengths.get(0));
+        assertEquals(3, evaluationsCounter.get());
+    }
+
 }