Updated Evaluator

client/src/main/java/io/split/client/SplitFactoryImpl.java

@@ -66,9 +66,12 @@
 import io.split.storages.SplitCache;
 import io.split.storages.SplitCacheConsumer;
 import io.split.storages.SplitCacheProducer;
+import io.split.storages.RuleBasedSegmentCacheConsumer;
+import io.split.storages.RuleBasedSegmentCache;
 import io.split.storages.enums.OperationMode;
 import io.split.storages.memory.InMemoryCacheImp;
 import io.split.storages.memory.SegmentCacheInMemoryImpl;
+import io.split.storages.memory.RuleBasedSegmentCacheInMemoryImp;
 import io.split.storages.pluggable.adapters.UserCustomEventAdapterProducer;
 import io.split.storages.pluggable.adapters.UserCustomImpressionAdapterConsumer;
 import io.split.storages.pluggable.adapters.UserCustomImpressionAdapterProducer;
@@ -202,6 +205,7 @@ public SplitFactoryImpl(String apiToken, SplitClientConfig config) throws URISyn
 
         // Cache Initialisations
         SegmentCache segmentCache = new SegmentCacheInMemoryImpl();
+        RuleBasedSegmentCache ruleBasedSegmentCache = new RuleBasedSegmentCacheInMemoryImp();
         FlagSetsFilter flagSetsFilter = new FlagSetsFilterImpl(config.getSetsFilter());
         SplitCache splitCache = new InMemoryCacheImp(flagSetsFilter);
         ImpressionsStorage impressionsStorage = new InMemoryImpressionsStorage(config.impressionsQueueSize());
@@ -214,6 +218,7 @@ public SplitFactoryImpl(String apiToken, SplitClientConfig config) throws URISyn
         // Segments
         _segmentSynchronizationTaskImp = buildSegments(config, segmentCache, splitCache);
 
+
         SplitParser splitParser = new SplitParser();
         // SplitFetcher
         _splitFetcher = buildSplitFetcher(splitCache, splitParser, flagSetsFilter);
@@ -244,7 +249,7 @@ public SplitFactoryImpl(String apiToken, SplitClientConfig config) throws URISyn
                 config.getThreadFactory());
 
         // Evaluator
-        _evaluator = new EvaluatorImp(splitCache, segmentCache);
+        _evaluator = new EvaluatorImp(splitCache, segmentCache, ruleBasedSegmentCache);
 
         // SplitClient
         _client = new SplitClientImpl(this,
@@ -333,7 +338,9 @@ protected SplitFactoryImpl(String apiToken, SplitClientConfig config, CustomStor
         _gates = new SDKReadinessGates();
 
         _telemetrySynchronizer = new TelemetryConsumerSubmitter(customStorageWrapper, _sdkMetadata);
-        _evaluator = new EvaluatorImp(userCustomSplitAdapterConsumer, userCustomSegmentAdapterConsumer);
+        // TODO Update the instance to UserCustomRuleBasedSegmentAdapterConsumer
+        RuleBasedSegmentCacheConsumer userCustomRuleBasedSegmentAdapterConsumer = new RuleBasedSegmentCacheInMemoryImp();
+        _evaluator = new EvaluatorImp(userCustomSplitAdapterConsumer, userCustomSegmentAdapterConsumer, userCustomRuleBasedSegmentAdapterConsumer);
         _impressionsSender = PluggableImpressionSender.create(customStorageWrapper);
         _uniqueKeysTracker = createUniqueKeysTracker(config);
         _impressionsManager = buildImpressionsManager(config, userCustomImpressionAdapterConsumer,
@@ -392,6 +399,7 @@ protected SplitFactoryImpl(SplitClientConfig config) {
         SegmentCache segmentCache = new SegmentCacheInMemoryImpl();
         FlagSetsFilter flagSetsFilter = new FlagSetsFilterImpl(config.getSetsFilter());
         SplitCache splitCache = new InMemoryCacheImp(flagSetsFilter);
+        RuleBasedSegmentCache _ruleBasedSegmentCache = new RuleBasedSegmentCacheInMemoryImp();
         _splitCache = splitCache;
         _gates = new SDKReadinessGates();
         _segmentCache = segmentCache;
@@ -428,7 +436,7 @@ protected SplitFactoryImpl(SplitClientConfig config) {
                 _impressionsManager, null, null, null);
 
         // Evaluator
-        _evaluator = new EvaluatorImp(splitCache, segmentCache);
+        _evaluator = new EvaluatorImp(splitCache, segmentCache, _ruleBasedSegmentCache);
 
         EventsStorage eventsStorage = new NoopEventsStorageImp();
 

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

@@ -1,16 +1,20 @@
 package io.split.engine.evaluator;
 
+import io.split.storages.RuleBasedSegmentCacheConsumer;
 import io.split.storages.SegmentCacheConsumer;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class EvaluationContext {
     private final Evaluator _evaluator;
     private final SegmentCacheConsumer _segmentCacheConsumer;
+    private final RuleBasedSegmentCacheConsumer _ruleBasedSegmentCacheConsumer;
 
-    public EvaluationContext(Evaluator evaluator, SegmentCacheConsumer segmentCacheConsumer) {
+    public EvaluationContext(Evaluator evaluator, SegmentCacheConsumer segmentCacheConsumer,
+                             RuleBasedSegmentCacheConsumer ruleBasedSegmentCacheConsumer) {
         _evaluator = checkNotNull(evaluator);
         _segmentCacheConsumer = checkNotNull(segmentCacheConsumer);
+        _ruleBasedSegmentCacheConsumer = checkNotNull(ruleBasedSegmentCacheConsumer);
     }
 
     public Evaluator getEvaluator() {
@@ -20,4 +24,8 @@ public Evaluator getEvaluator() {
     public SegmentCacheConsumer getSegmentCache() {
         return _segmentCacheConsumer;
     }
+
+    public RuleBasedSegmentCacheConsumer getRuleBasedSegmentCache() {
+        return _ruleBasedSegmentCacheConsumer;
+    }
 }

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

@@ -6,6 +6,7 @@
 import io.split.engine.experiments.ParsedSplit;
 import io.split.engine.splitter.Splitter;
 import io.split.grammar.Treatments;
+import io.split.storages.RuleBasedSegmentCacheConsumer;
 import io.split.storages.SegmentCacheConsumer;
 import io.split.storages.SplitCacheConsumer;
 import org.slf4j.Logger;
@@ -23,13 +24,16 @@ public class EvaluatorImp implements Evaluator {
     private static final Logger _log = LoggerFactory.getLogger(EvaluatorImp.class);
 
     private final SegmentCacheConsumer _segmentCacheConsumer;
+    private final RuleBasedSegmentCacheConsumer _ruleBasedSegmentCacheConsumer;
     private final EvaluationContext _evaluationContext;
     private final SplitCacheConsumer _splitCacheConsumer;
 
-    public EvaluatorImp(SplitCacheConsumer splitCacheConsumer, SegmentCacheConsumer segmentCache) {
+    public EvaluatorImp(SplitCacheConsumer splitCacheConsumer, SegmentCacheConsumer segmentCache,
+                        RuleBasedSegmentCacheConsumer ruleBasedSegmentCacheConsumer) {
         _splitCacheConsumer = checkNotNull(splitCacheConsumer);
         _segmentCacheConsumer = checkNotNull(segmentCache);
-        _evaluationContext = new EvaluationContext(this, _segmentCacheConsumer);
+        _ruleBasedSegmentCacheConsumer = checkNotNull(ruleBasedSegmentCacheConsumer);
+        _evaluationContext = new EvaluationContext(this, _segmentCacheConsumer, ruleBasedSegmentCacheConsumer);
     }
 
     @Override

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

@@ -0,0 +1,83 @@
+package io.split.engine.matchers;
+
+import io.split.engine.evaluator.EvaluationContext;
+import io.split.engine.experiments.ParsedCondition;
+import io.split.engine.experiments.ParsedRuleBasedSegment;
+
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A matcher that checks if the key is part of a user defined segment. This class
+ * assumes that the logic for refreshing what keys are part of a segment is delegated
+ * to SegmentFetcher.
+ *
+ * @author adil
+ */
+public class RuleBasedSegmentMatcher implements Matcher {
+    private final String _segmentName;
+
+    public RuleBasedSegmentMatcher(String segmentName) {
+        _segmentName = checkNotNull(segmentName);
+    }
+
+    @Override
+    public boolean match(Object matchValue, String bucketingKey, Map<String, Object> attributes, EvaluationContext evaluationContext) {
+        if (!(matchValue instanceof String)) {
+            return false;
+        }
+        ParsedRuleBasedSegment parsedRuleBasedSegment = evaluationContext.getRuleBasedSegmentCache().get(_segmentName);
+        if (parsedRuleBasedSegment == null) {
+            return false;
+        }
+
+        if (parsedRuleBasedSegment.excludedKeys().contains(matchValue)) {
+            return false;
+        }
+
+        for (String segmentName: parsedRuleBasedSegment.excludedSegments()) {
+            if (evaluationContext.getSegmentCache().isInSegment(segmentName, (String) matchValue)) {
+                return false;
+            }
+        }
+        List<ParsedCondition> conditions = parsedRuleBasedSegment.parsedConditions();
+        for (ParsedCondition parsedCondition : conditions) {
+            if (parsedCondition.matcher().match((String) matchValue, bucketingKey, attributes, evaluationContext)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 17;
+        result = 31 * result + _segmentName.hashCode();
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) return false;
+        if (this == obj) return true;
+        if (!(obj instanceof RuleBasedSegmentMatcher)) return false;
+
+        RuleBasedSegmentMatcher other = (RuleBasedSegmentMatcher) obj;
+
+        return _segmentName.equals(other._segmentName);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder bldr = new StringBuilder();
+        bldr.append("in segment ");
+        bldr.append(_segmentName);
+        return bldr.toString();
+    }
+
+    public String getSegmentName() {
+        return _segmentName;
+    }
+}