Naming

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/bavet/common/AbstractGroupNode.java

@@ -17,7 +17,7 @@ public abstract class AbstractGroupNode<InTuple_ extends Tuple, OutTuple_ extend
 
     private final int groupStoreIndex;
     /**
-     * Unused when {@link #hasMultipleGroups} is false.
+     * Unused when {@link #hasGroupKeyFunction} is false.
      */
     private final Function<InTuple_, GroupKey_> groupKeyFunction;
     /**
@@ -32,18 +32,18 @@ public abstract class AbstractGroupNode<InTuple_ extends Tuple, OutTuple_ extend
      * Some code paths may decide to not supply a grouping function.
      * In that case, every tuple accumulates into {@link #singletonGroup} and not to {@link #groupMap}.
      */
-    private final boolean hasMultipleGroups;
+    private final boolean hasGroupKeyFunction;
     /**
      * Some code paths may decide to not supply a collector.
      * In that case, we skip the code path that would attempt to use it.
      */
     private final boolean hasCollector;
     /**
-     * Used when {@link #hasMultipleGroups} is true, otherwise {@link #singletonGroup} is used.
+     * Used when {@link #hasGroupKeyFunction} is true, otherwise {@link #singletonGroup} is used.
      */
     private final Map<Object, Group<OutTuple_, ResultContainer_>> groupMap;
     /**
-     * Used when {@link #hasMultipleGroups} is false, otherwise {@link #groupMap} is used.
+     * Used when {@link #hasGroupKeyFunction} is false, otherwise {@link #groupMap} is used.
      *
      * @implNote The field is lazy initialized in order to maintain the same semantics as with the groupMap above.
      *           When all tuples are removed, the field will be set to null, as if the group never existed.
@@ -60,14 +60,14 @@ protected AbstractGroupNode(int groupStoreIndex, Function<InTuple_, GroupKey_> g
         this.groupKeyFunction = groupKeyFunction;
         this.supplier = supplier;
         this.finisher = finisher;
-        this.hasMultipleGroups = groupKeyFunction != null;
+        this.hasGroupKeyFunction = groupKeyFunction != null;
         this.hasCollector = supplier != null;
         /*
          * Not using the default sizing to 1000.
          * The number of groups can be very small, and that situation is not unlikely.
          * Therefore, the size of these collections is kept default.
          */
-        this.groupMap = hasMultipleGroups ? new HashMap<>() : null;
+        this.groupMap = hasGroupKeyFunction ? new HashMap<>() : null;
         this.propagationQueue = hasCollector ? new DynamicPropagationQueue<>(nextNodesTupleLifecycle,
                 group -> {
                     var outTuple = group.getTuple();
@@ -99,7 +99,7 @@ public final void insert(InTuple_ tuple) {
                     "Impossible state: the input for the tuple (%s) was already added in the tupleStore."
                             .formatted(tuple));
         }
-        var userSuppliedKey = hasMultipleGroups ? groupKeyFunction.apply(tuple) : null;
+        var userSuppliedKey = hasGroupKeyFunction ? groupKeyFunction.apply(tuple) : null;
         createTuple(tuple, userSuppliedKey);
     }
 
@@ -124,7 +124,7 @@ private void createTuple(InTuple_ tuple, GroupKey_ userSuppliedKey) {
 
     private Group<OutTuple_, ResultContainer_> getOrCreateGroup(GroupKey_ userSuppliedKey) {
         var groupMapKey = useAssertingGroupKey ? new AssertingGroupKey<>(userSuppliedKey) : userSuppliedKey;
-        if (hasMultipleGroups) {
+        if (hasGroupKeyFunction) {
             // Avoids computeIfAbsent in order to not create lambdas on the hot path.
             var group = groupMap.get(groupMapKey);
             if (group == null) {
@@ -178,7 +178,7 @@ public final void update(InTuple_ tuple) {
             insert(tuple);
             return;
         }
-        if (!hasMultipleGroups) {
+        if (!hasGroupKeyFunction) {
             updateGroup(tuple, oldGroup);
             return;
         }
@@ -220,7 +220,7 @@ private void updateGroup(InTuple_ tuple, Group<OutTuple_, ResultContainer_> oldG
      */
     private void killOutTuple(Group<OutTuple_, ResultContainer_> group, boolean killGroup) {
         if (killGroup) {
-            var groupKey = hasMultipleGroups ? group.getGroupKey() : null;
+            var groupKey = hasGroupKeyFunction ? group.getGroupKey() : null;
             var oldGroup = removeGroup(groupKey);
             if (oldGroup == null) {
                 throw new IllegalStateException("""
@@ -255,7 +255,7 @@ private void killOutTuple(Group<OutTuple_, ResultContainer_> group, boolean kill
     }
 
     private Group<OutTuple_, ResultContainer_> removeGroup(Object groupKey) {
-        if (hasMultipleGroups) {
+        if (hasGroupKeyFunction) {
             return groupMap.remove(groupKey);
         } else {
             var oldGroup = singletonGroup;