/** * De-allocates bins from a treatment * @param treatmentName The treatment * @param size The number of bins */ public Experiment deallocate(String treatmentName, int size) { allocations.deallocate(treatment(treatmentName), size); return this; }
/** * Returns treatment for an identity * @param identity The identity * @return the treatment assigned to given identity */ public Treatment getTreatment(Identity identity, AttributesMap attributes) { return allocations.getTreatment(identityToBin(identity, attributes)); }
private AllocationEntity(Allocation allocation) { this.treatment = allocation.getTreatment().getName(); this.offset = allocation.getOffset(); this.size = allocation.getSize(); } }
private TreatmentOverrideEntity(TreatmentOverride override) { this.name = override.getName(); this.treatment = override.getTreatment().getName(); this.filter = override.getFilter().toString(); } }
private Treatment getTreatmentWithOverrides(Experiment experiment, Identity identity, AttributesMap attributes) { for (TreatmentOverride override : experiment.getOverrides()) { if (override.getFilter().evaluate(attributes)) { return override.getTreatment(); } } return experiment.getTreatment(identity, attributes); }
private TreatmentEntity(Treatment treatment) { name = treatment.getName(); description = treatment.getDescription(); } }
/** * Deletes the experiment and all things associated with it */ public void delete() { owner.delete(name); }
/** * Reallocates bins from one treatment to another * @param sourceTreatmentName The source treatment * @param destinationTreatmentName The destination treatment * @param size The number of bins */ public Experiment reallocate(String sourceTreatmentName, String destinationTreatmentName, int size) { allocations.reallocate( treatment(sourceTreatmentName), treatment(destinationTreatmentName), size ); return this; }
@Override public void run() { safeInvalidate(experimentName, builderFactory.createBuilder(experimentName)); } });
public Builder addAllocation(String treatmentName, int offset, int size) { allocations.add(new Allocation(getTreatment(treatmentName), offset, size)); return this; }
/** * Removes a treatment * @param name The treatment */ public Experiment removeTreatment(String name) { final Treatment treatment = treatments.get(name); if (treatment == null) { return this; } removeOverrides(name); allocations.deallocate(treatment, Allocations.NUM_BINS); treatments.remove(name); return this; }
/** * Add a treatment override for an identity * @param treatmentName The treatment an identity should receive * @param overrideName The name of the override * @param filter A filter expression that describes which attributes this override should apply for */ public Experiment addOverride(String overrideName, String treatmentName, String filter) { final FilterExpression filterExp = FilterExpression.of(filter); final TreatmentOverride override = new TreatmentOverride(overrideName, filterExp, treatment(treatmentName)); overrides.put(overrideName, override); return this; }
/** * Creates a new experiment by name, which is not persisted until save is called */ public Experiment create(String name) { return new Experiment(this, name); }
/** * Removes all allocations */ public Experiment deallocateAll() { allocations.clear(); return this; }
public Builder createBuilder(String experimentName) { return new Builder(owner, experimentName); } }
public Experiments build() { return new Experiments(provider, strategy, executorService); } }
@Override public AllocationDto toDto(Allocation allocation) { return new AllocationDto(allocation.getTreatment().getName(), allocation.getOffset(), allocation.getSize()); }
public static Experiment copyOf(Experiment experiment) { return experiment != null ? new Experiment(experiment) : null; }