Tidy First: replace Guava with standard Java in evaluation code

Replace Guava dependencies in the evaluation engine with standard Java 8
equivalents to prepare for extraction into a zero-dependency targeting-engine module:
- checkNotNull → Objects.requireNonNull (EvaluatorImp, EvaluationContext)
- ImmutableList → Collections.unmodifiableList (ParsedSplit, CombiningMatcher)
- Lists.newArrayList / checkArgument → ArrayList / IllegalArgumentException (CombiningMatcher, SplitParser)

Author: gthea

client/src/main/java/io/split/engine/evaluator/EvaluationContext.java

@@ -3,7 +3,7 @@
 import io.split.storages.RuleBasedSegmentCacheConsumer;
 import io.split.storages.SegmentCacheConsumer;
 
-import static com.google.common.base.Preconditions.checkNotNull;
+import java.util.Objects;
 
 public class EvaluationContext {
     private final Evaluator _evaluator;
@@ -12,9 +12,9 @@ public class EvaluationContext {
 
     public EvaluationContext(Evaluator evaluator, SegmentCacheConsumer segmentCacheConsumer,
                              RuleBasedSegmentCacheConsumer ruleBasedSegmentCacheConsumer) {
-        _evaluator = checkNotNull(evaluator);
-        _segmentCacheConsumer = checkNotNull(segmentCacheConsumer);
-        _ruleBasedSegmentCacheConsumer = checkNotNull(ruleBasedSegmentCacheConsumer);
+        _evaluator = Objects.requireNonNull(evaluator);
+        _segmentCacheConsumer = Objects.requireNonNull(segmentCacheConsumer);
+        _ruleBasedSegmentCacheConsumer = Objects.requireNonNull(ruleBasedSegmentCacheConsumer);
     }
 
     public Evaluator getEvaluator() {

client/src/main/java/io/split/engine/evaluator/EvaluatorImp.java

@@ -19,7 +19,7 @@
 import java.util.List;
 import java.util.Map;
 
-import static com.google.common.base.Preconditions.checkNotNull;
+import java.util.Objects;
 
 public class EvaluatorImp implements Evaluator {
     private static final Logger _log = LoggerFactory.getLogger(EvaluatorImp.class);
@@ -33,8 +33,8 @@ public class EvaluatorImp implements Evaluator {
     public EvaluatorImp(SplitCacheConsumer splitCacheConsumer, SegmentCacheConsumer segmentCache,
                         RuleBasedSegmentCacheConsumer ruleBasedSegmentCacheConsumer,
                         FallbackTreatmentCalculator fallbackTreatmentCalculator) {
-        _splitCacheConsumer = checkNotNull(splitCacheConsumer);
-        _segmentCacheConsumer = checkNotNull(segmentCache);
+        _splitCacheConsumer = Objects.requireNonNull(splitCacheConsumer);
+        _segmentCacheConsumer = Objects.requireNonNull(segmentCache);
         _evaluationContext = new EvaluationContext(this, _segmentCacheConsumer, ruleBasedSegmentCacheConsumer);
         _fallbackTreatmentCalculator = fallbackTreatmentCalculator;
     }

client/src/main/java/io/split/engine/experiments/ParsedSplit.java

@@ -1,6 +1,7 @@
 package io.split.engine.experiments;
 
-import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.Collections;
 import io.split.engine.matchers.AttributeMatcher;
 import io.split.engine.matchers.PrerequisitesMatcher;
 import io.split.engine.matchers.RuleBasedSegmentMatcher;
@@ -26,7 +27,7 @@ public class ParsedSplit {
     private final int _seed;
     private final boolean _killed;
     private final String _defaultTreatment;
-    private final ImmutableList<ParsedCondition> _parsedCondition;
+    private final List<ParsedCondition> _parsedCondition;
     private final String _trafficTypeName;
     private final long _changeNumber;
     private final int _trafficAllocation;
@@ -120,7 +121,7 @@ public ParsedSplit(
         _seed = seed;
         _killed = killed;
         _defaultTreatment = defaultTreatment;
-        _parsedCondition = ImmutableList.copyOf(matcherAndSplits);
+        _parsedCondition = Collections.unmodifiableList(new ArrayList<>(matcherAndSplits));
         _trafficTypeName = trafficTypeName;
         _changeNumber = changeNumber;
         _algo = algo;

client/src/main/java/io/split/engine/experiments/SplitParser.java

@@ -1,6 +1,6 @@
 package io.split.engine.experiments;
 
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
 
 import io.split.client.dtos.Condition;
 import io.split.client.dtos.Partition;
@@ -39,7 +39,7 @@ public ParsedSplit parse(Split split) {
     }
 
     private ParsedSplit parseWithoutExceptionHandling(Split split) {
-        List<ParsedCondition> parsedConditionList = Lists.newArrayList();
+        List<ParsedCondition> parsedConditionList = new ArrayList<>();
         if (Objects.isNull(split.impressionsDisabled)) {
             _log.debug("impressionsDisabled field not detected for Feature flag `" + split.name + "`, setting it to `false`.");
             split.impressionsDisabled = false;

client/src/main/java/io/split/engine/matchers/CombiningMatcher.java

@@ -1,41 +1,40 @@
 package io.split.engine.matchers;
 
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
 import io.split.client.dtos.MatcherCombiner;
 import io.split.engine.evaluator.EvaluationContext;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
-import static com.google.common.base.Preconditions.checkArgument;
-
 /**
  * Combines the results of multiple matchers using the logical OR or AND.
  *
  * @author adil
  */
 public class CombiningMatcher {
 
-    private final ImmutableList<AttributeMatcher> _delegates;
+    private final List<AttributeMatcher> _delegates;
     private final MatcherCombiner _combiner;
 
     public static CombiningMatcher of(Matcher matcher) {
         return new CombiningMatcher(MatcherCombiner.AND,
-                Lists.newArrayList(AttributeMatcher.vanilla(matcher)));
+                new ArrayList<>(Arrays.asList(AttributeMatcher.vanilla(matcher))));
     }
 
     public static CombiningMatcher of(String attribute, Matcher matcher) {
         return new CombiningMatcher(MatcherCombiner.AND,
-                Lists.newArrayList(new AttributeMatcher(attribute, matcher, false)));
+                new ArrayList<>(Arrays.asList(new AttributeMatcher(attribute, matcher, false))));
     }
 
     public CombiningMatcher(MatcherCombiner combiner, List<AttributeMatcher> delegates) {
-        _delegates = ImmutableList.copyOf(delegates);
+        _delegates = Collections.unmodifiableList(new ArrayList<>(delegates));
         _combiner = combiner;
 
-        checkArgument(_delegates.size() > 0);
+        if (_delegates.isEmpty()) throw new IllegalArgumentException("Delegates must not be empty");
     }
 
     public boolean match(String key, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
@@ -60,7 +59,7 @@ private boolean and(String key, String bucketingKey, Map<String, Object> attribu
         return result;
     }
 
-    public ImmutableList<AttributeMatcher> attributeMatchers() {
+    public List<AttributeMatcher> attributeMatchers() {
         return _delegates;
     }