Naming fix up to IntMap (#2631)

bbakerman · web-flow · commit abbb85644ef5 · 2021-12-06T14:19:02.000+11:00
diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/FieldLevelTrackingApproach.java b/src/main/java/graphql/execution/instrumentation/dataloader/FieldLevelTrackingApproach.java
@@ -29,16 +29,16 @@ public class FieldLevelTrackingApproach {
 
     private static class CallStack implements InstrumentationState {
 
-        private final IntMap expectedFetchCountPerLevel = new IntMap();
-        private final IntMap fetchCountPerLevel = new IntMap();
-        private final IntMap expectedStrategyCallsPerLevel = new IntMap();
-        private final IntMap happenedStrategyCallsPerLevel = new IntMap();
-        private final IntMap happenedOnFieldValueCallsPerLevel = new IntMap();
+        private final LevelMap expectedFetchCountPerLevel = new LevelMap();
+        private final LevelMap fetchCountPerLevel = new LevelMap();
+        private final LevelMap expectedStrategyCallsPerLevel = new LevelMap();
+        private final LevelMap happenedStrategyCallsPerLevel = new LevelMap();
+        private final LevelMap happenedOnFieldValueCallsPerLevel = new LevelMap();
 
         private final Set<Integer> dispatchedLevels = new LinkedHashSet<>();
 
         CallStack() {
-            expectedStrategyCallsPerLevel.increment(1, 1);
+            expectedStrategyCallsPerLevel.set(1, 1);
         }
 
         void increaseExpectedFetchCount(int level, int count) {
@@ -95,11 +95,11 @@ public boolean dispatchIfNotDispatchedBefore(int level) {
         }
 
         public void clearAndMarkCurrentLevelAsReady(int level) {
-            expectedFetchCountPerLevel.reset();
-            fetchCountPerLevel.reset();
-            expectedStrategyCallsPerLevel.reset();
-            happenedStrategyCallsPerLevel.reset();
-            happenedOnFieldValueCallsPerLevel.reset();
+            expectedFetchCountPerLevel.clear();
+            fetchCountPerLevel.clear();
+            expectedStrategyCallsPerLevel.clear();
+            happenedStrategyCallsPerLevel.clear();
+            happenedOnFieldValueCallsPerLevel.clear();
             dispatchedLevels.clear();
 
             // make sure the level is ready
diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/LevelMap.java b/src/main/java/graphql/execution/instrumentation/dataloader/LevelMap.java
@@ -4,23 +4,26 @@
 
 import java.util.Arrays;
 
+/**
+ * This data structure tracks the number of expected calls on a given level
+ */
 @Internal
-public class IntMap {
+public class LevelMap {
 
     // A reasonable default that guarantees no additional allocations for most use cases.
     private static final int DEFAULT_INITIAL_SIZE = 16;
 
     // this array is mutable in both size and contents.
     private int[] countsByLevel;
 
-    public IntMap(int initialSize) {
+    public LevelMap(int initialSize) {
         if (initialSize < 0) {
             throw new IllegalArgumentException("negative size " + initialSize);
         }
         countsByLevel = new int[initialSize];
     }
 
-    public IntMap() {
+    public LevelMap() {
         this(DEFAULT_INITIAL_SIZE);
     }
 
@@ -35,14 +38,23 @@ public int get(int level) {
     }
 
     public void increment(int level, int by) {
+        mutatePreconditions(level);
+        countsByLevel[level] += by;
+    }
+
+    public void set(int level, int newValue) {
+        mutatePreconditions(level);
+        countsByLevel[level] = newValue;
+    }
+
+    private void mutatePreconditions(int level) {
         if (level < 0) {
             throw new IllegalArgumentException("negative level " + level);
         }
         if (level + 1 > countsByLevel.length) {
             int newSize = level == 0 ? 1 : level * 2;
             countsByLevel = Arrays.copyOf(countsByLevel, newSize);
         }
-        countsByLevel[level] += by;
     }
 
     @Override
@@ -56,7 +68,7 @@ public String toString() {
         return result.toString();
     }
 
-    public void reset() {
+    public void clear() {
         Arrays.fill(countsByLevel, 0);
     }
 }
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/LevelMapTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/LevelMapTest.groovy
@@ -2,11 +2,11 @@ package graphql.execution.instrumentation.dataloader
 
 import spock.lang.Specification
 
-class IntMapTest extends Specification {
+class LevelMapTest extends Specification {
 
     def "increase adds levels"() {
         given:
-        IntMap sut = new IntMap(0) // starts empty
+        LevelMap sut = new LevelMap(0) // starts empty
 
         when:
         sut.increment(2, 42) // level 2 has count 42
@@ -19,7 +19,7 @@ class IntMapTest extends Specification {
 
     def "increase count by 10 for every level"() {
         given:
-        IntMap sut = new IntMap(0)
+        LevelMap sut = new LevelMap(0)
 
         when:
         5.times {Integer level ->
@@ -31,10 +31,9 @@ class IntMapTest extends Specification {
             sut.get(level) == 10
         }
     }
-
     def "increase yields new count"() {
         given:
-        IntMap sut = new IntMap(0)
+        LevelMap sut = new LevelMap(0)
 
         when:
         sut.increment(1, 0)
@@ -55,9 +54,32 @@ class IntMapTest extends Specification {
         sut.get(1) == 101
     }
 
+    def "set yields new value"() {
+        given:
+        LevelMap sut = new LevelMap(0)
+
+        when:
+        sut.set(1, 1)
+
+        then:
+        sut.get(1) == 1
+
+        when:
+        sut.increment(1, 100)
+
+        then:
+        sut.get(1) == 101
+
+        when:
+        sut.set(1, 666)
+
+        then:
+        sut.get(1) == 666
+    }
+
     def "toString() is important for debugging"() {
         given:
-        IntMap sut = new IntMap(0)
+        LevelMap sut = new LevelMap(0)
 
         when:
         sut.toString()
diff --git a/src/test/java/benchmark/IntMapBenchmark.java b/src/test/java/benchmark/IntMapBenchmark.java
@@ -1,6 +1,6 @@
 package benchmark;
 
-import graphql.execution.instrumentation.dataloader.IntMap;
+import graphql.execution.instrumentation.dataloader.LevelMap;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Measurement;
@@ -33,7 +33,7 @@ public void benchmarkLinkedHashMap(Blackhole blackhole) {
 
 	@Benchmark
 	public void benchmarkIntMap(Blackhole blackhole) {
-		IntMap result = new IntMap(16);
+		LevelMap result = new LevelMap(16);
 		for (int i = 0; i < 30; i++) {
 			int level = i % 10;
 			int count = i * 2;

Original file line number	Diff line number	Diff line change
`@@ -4,23 +4,26 @@`
`4`	`4`
`5`	`5`	`import java.util.Arrays;`
`6`	`6`
	`7`	`+/**`
	`8`	`+ * This data structure tracks the number of expected calls on a given level`
	`9`	`+ */`
`7`	`10`	`@Internal`
`8`		`-public class IntMap {`
	`11`	`+public class LevelMap {`
`9`	`12`
`10`	`13`	`// A reasonable default that guarantees no additional allocations for most use cases.`
`11`	`14`	`private static final int DEFAULT_INITIAL_SIZE = 16;`
`12`	`15`
`13`	`16`	`// this array is mutable in both size and contents.`
`14`	`17`	`private int[] countsByLevel;`
`15`	`18`
`16`		`- public IntMap(int initialSize) {`
	`19`	`+ public LevelMap(int initialSize) {`
`17`	`20`	`if (initialSize < 0) {`
`18`	`21`	`throw new IllegalArgumentException("negative size " + initialSize);`
`19`	`22`	`}`
`20`	`23`	`countsByLevel = new int[initialSize];`
`21`	`24`	`}`
`22`	`25`
`23`		`- public IntMap() {`
	`26`	`+ public LevelMap() {`
`24`	`27`	`this(DEFAULT_INITIAL_SIZE);`
`25`	`28`	`}`
`26`	`29`
`@@ -35,14 +38,23 @@ public int get(int level) {`
`35`	`38`	`}`
`36`	`39`
`37`	`40`	`public void increment(int level, int by) {`
	`41`	`+ mutatePreconditions(level);`
	`42`	`+ countsByLevel[level] += by;`
	`43`	`+ }`
	`44`	`+`
	`45`	`+ public void set(int level, int newValue) {`
	`46`	`+ mutatePreconditions(level);`
	`47`	`+ countsByLevel[level] = newValue;`
	`48`	`+ }`
	`49`	`+`
	`50`	`+ private void mutatePreconditions(int level) {`
`38`	`51`	`if (level < 0) {`
`39`	`52`	`throw new IllegalArgumentException("negative level " + level);`
`40`	`53`	`}`
`41`	`54`	`if (level + 1 > countsByLevel.length) {`
`42`	`55`	`int newSize = level == 0 ? 1 : level * 2;`
`43`	`56`	`countsByLevel = Arrays.copyOf(countsByLevel, newSize);`
`44`	`57`	`}`
`45`		`- countsByLevel[level] += by;`
`46`	`58`	`}`
`47`	`59`
`48`	`60`	`@Override`
`@@ -56,7 +68,7 @@ public String toString() {`
`56`	`68`	`return result.toString();`
`57`	`69`	`}`
`58`	`70`
`59`		`- public void reset() {`
	`71`	`+ public void clear() {`
`60`	`72`	`Arrays.fill(countsByLevel, 0);`
`61`	`73`	`}`
`62`	`74`	`}`