public AttributesMap filter(Set<String> keys) { final ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder(); for (Entry<String, Object> entry : entrySet()) { if (keys.contains(entry.getKey())) { builder.put(entry); } } return new AttributesMap(builder.build()); }
public Long getNumber(String name) { return getValue(name, Long.class, null); }
/** * generates a hash code used to assign identity to treatment * @param seed a seed value to randomize the resulting hash from experiment to experiment for the same identity * @param hashAttributes a set of attributes that should be used to compute the hash code * @param attributes a map of attribute values */ public long computeHash(int seed, Set<String> hashAttributes, AttributesMap attributes) { final IdentityBuilder builder = IdentityBuilder.seed(seed); final Iterable<String> names = hashAttributes.isEmpty() ? attributes.keySet() : hashAttributes; for (String name : names) { final Class<?> type = attributes.getType(name); if (type == String.class) { builder.putString(attributes.getString(name)); } else if (type == Long.class) { builder.putLong(attributes.getNumber(name)); } else if (type == Boolean.class) { builder.putBoolean(attributes.getBoolean(name)); } } return builder.hash(); }
/** * Returns all active treatments for all active experiments for an identity, taking overrides into account */ public Map<Experiment, Treatment> getActiveTreatments(Identity identity) { strategy.onCacheRead(context); final Map<Experiment, Treatment> result = Maps.newHashMap(); final AttributesMap attributes = identity .computeAttributes() .filter(Identity.getSupportedAttributes(identity.getClass())); for (final Experiment experiment : cache.getActiveExperiments().values()) { if (!experiment.getFilter().evaluate(attributes)) { continue; } final Treatment treatment = getTreatmentWithOverrides(experiment, identity, attributes); if (treatment == null) { continue; } result.put(experiment, treatment); } return result; }
public AttributesMap build() { return new AttributesMap(builder.build()); } }
doReturn(AttributesMap.empty()).when(identity).computeAttributes(); final Experiment obj5 = experiments.getActiveTreatments(identity).keySet().iterator().next();
private Class<?> getType(FilterParser.ValueContext context) { if (context.IDENTIFIER() != null) { // identifier return attributes.getType(context.IDENTIFIER().getText()); } else { // constant final FilterParser.ConstantContext constant = context.constant(); if (constant.STRING() != null) { return String.class; } else if (constant.NUMBER() != null) { return Long.class; } else if (constant.BOOLEAN() != null) { return Boolean.class; } return null; } }
private Comparable getValue(FilterParser.ValueContext context) { if (context.IDENTIFIER() != null) { // identifier final String identifier = context.IDENTIFIER().getText(); final Class<?> type = attributes.getType(identifier); if (type == String.class) { return attributes.getString(identifier); } else if (type == Long.class) { return attributes.getNumber(identifier); } else if (type == Boolean.class) { return attributes.getBoolean(identifier); } return null; } else { // constant final FilterParser.ConstantContext constant = context.constant(); if (constant.STRING() != null) { final String value = constant.STRING().getText(); return value.length() == 2 ? "" : value.substring(1, value.length() - 1); } else if (constant.NUMBER() != null) { return Long.parseLong(constant.NUMBER().getText()); } else if (constant.BOOLEAN() != null) { return Boolean.parseBoolean(constant.BOOLEAN().getText()); } return null; } }
/** * Returns the current active treatment for an experiment name and identity, taking overrides into account */ public Treatment getActiveTreatment(String experimentName, Identity identity) { strategy.onCacheRead(experimentName, context); final Experiment experiment = cache.getActiveExperiments().get(experimentName); final AttributesMap attributes = identity .computeAttributes() .filter(Identity.getSupportedAttributes(identity.getClass())); if (experiment == null || !experiment.getFilter().evaluate(attributes)) { return null; } return getTreatmentWithOverrides(experiment, identity, attributes); }
final Class<?> type = attributes.getType(name); stack.push(!attributes.getString(name).isEmpty()); } else if (type == Long.class) { stack.push(attributes.getNumber(name) != 0); } else if (type == Boolean.class) { stack.push(attributes.getBoolean(name)); } else { stack.push(false);
public Boolean getBoolean(String name) { return getValue(name, Boolean.class, null); }
public String getString(String name, String defaultValue) { return getValue(name, String.class, defaultValue); }
public String getString(String name) { return getValue(name, String.class, null); }
public Long getNumber(String name, long defaultValue) { return getValue(name, Long.class, defaultValue); }
public Boolean getBoolean(String name, boolean defaultValue) { return getValue(name, Boolean.class, defaultValue); }