private TreatmentEntity(Treatment treatment) { name = treatment.getName(); description = treatment.getDescription(); } }
/** * Adds a treatment * @param name The name */ public Experiment addTreatment(String name) { treatments.put(name, new Treatment(name)); return this; }
/** * Removes all overrides for a given treatment * @param treatmentName The treatment to remove overrides for */ public Experiment removeOverrides(String treatmentName) { final Treatment treatment = treatments.get(treatmentName); if (treatment == null) { return this; } final Iterator<Entry<String, TreatmentOverride>> iterator = overrides.entrySet().iterator(); while (iterator.hasNext()) { final Entry<String, TreatmentOverride> entry = iterator.next(); if (entry.getValue().getTreatment().equals(treatment)) { iterator.remove(); } } return this; }
private Experiment(Experiment toCopy) { this.owner = toCopy.owner; this.name = toCopy.name; this.treatments = Maps.newConcurrentMap(); for (final Treatment treatment : toCopy.getTreatments()) { this.treatments.put(treatment.getName(), new Treatment(treatment.getName(), treatment.getDescription())); } final List<Allocation> allocations = Lists.newArrayList(); for (final Allocation allocation : toCopy.getAllocations()) { final Treatment treatment = this.treatments.get(allocation.getTreatment().getName()); allocations.add(new Allocation(treatment, allocation.getOffset(), allocation.getSize())); } this.allocations = new Allocations(allocations); this.overrides = Maps.newConcurrentMap(); for (final TreatmentOverride override : toCopy.getOverrides()) { final Treatment treatment = this.treatments.get(override.getTreatment().getName()); final TreatmentOverride newOverride = new TreatmentOverride(override.getName(), override.getFilter(), treatment); overrides.put(override.getName(), newOverride); } this.seed = toCopy.seed; this.description = toCopy.description; this.filter = toCopy.filter; this.hashAttributes = Sets.newLinkedHashSet(toCopy.getHashAttributes()); this.active = toCopy.active; this.created = toCopy.created; this.modified = toCopy.modified; this.activated = toCopy.activated; this.deactivated = toCopy.deactivated; }
/** * Removes all treatments */ public Experiment clearTreatments() { final List<Treatment> toRemove = Lists.newArrayList(treatments.values()); for (final Treatment treatment : toRemove) { removeTreatment(treatment.getName()); } return this; }
final Set<String> missingTreatments = Sets.newHashSet(); for (final Treatment treatment : experiment.getTreatments()) { missingTreatments.add(treatment.getName()); existingTreatment.setDescription(treatment.getDescription()); } else { experiment.addTreatment(treatment.getName(), treatment.getDescription());
@POST @Path("/{treatmentName}") public void updateTreatment(@PathParam("experimentName") String experimentName, @PathParam("treatmentName") String treatmentName, @Valid UpdateTreatmentRequest request) { final Experiment experiment = ensureExists(experiments.get(experimentName)); final Treatment treatment = ensureExists(ensureExists(experiment).getTreatment(treatmentName)); if (request.getDescription() != null) { treatment.setDescription(request.getDescription().orNull()); } experiment.save(); }
private AllocationEntity(Allocation allocation) { this.treatment = allocation.getTreatment().getName(); this.offset = allocation.getOffset(); this.size = allocation.getSize(); } }
@Override public TreatmentDto toDto(Treatment treatment) { return new TreatmentDto(treatment.getName(), treatment.getDescription()); }
private TreatmentOverrideEntity(TreatmentOverride override) { this.name = override.getName(); this.treatment = override.getTreatment().getName(); this.filter = override.getFilter().toString(); } }
private void mergeAdjacentAllocations() { // merge all adjacent allocations for the same treatment if (allocations.size() < 2) { return; } final List<Allocation> newList = Lists.newArrayList(); int totalSize = allocations.get(0).getSize(); int offset = allocations.get(0).getOffset(); Treatment treatment = allocations.get(0).getTreatment(); for (int i=1; i<allocations.size(); i++) { final Allocation allocation = allocations.get(i); if (!allocation.getTreatment().equals(treatment)) { // different treatment newList.add(new Allocation(treatment, offset, totalSize)); totalSize = allocation.getSize(); offset = allocation.getOffset(); treatment = allocation.getTreatment(); } else { // same treatment, accumulate size totalSize += allocation.getSize(); } } newList.add(new Allocation(treatment, offset, totalSize)); allocations = newList; }
/** * Adds a treatment * @param name The name * @param description The description */ public Experiment addTreatment(String name, String description) { treatments.put(name, new Treatment(name, description)); return this; }
println( "treatment: %s, offset: %d, size: %d", allocation.getTreatment().getName(), allocation.getOffset(), allocation.getSize() println("name: %s, description: %s", treatment.getName(), treatment.getDescription()); println(); println("name: %s, description: %s", activeTreatment.getName(), activeTreatment.getDescription()); println(); "experiment: %s, treatment: %s, description: %s", entry.getKey().getName(), entry.getValue().getName(), entry.getValue().getDescription() );
@Override public AllocationDto toDto(Allocation allocation) { return new AllocationDto(allocation.getTreatment().getName(), allocation.getOffset(), allocation.getSize()); }
/** * De-allocates bins from a treatment * @param treatment The treatment * @param size The number of bins */ public void deallocate(Treatment treatment, int size) { final Iterator<Allocation> iter = allocations.iterator(); int sizeLeft = size; while (iter.hasNext()) { final Allocation next = iter.next(); if (next.getTreatment().equals(treatment)) { sizeLeft -= next.getSize(); iter.remove(); } if (sizeLeft < 0) { // a piece could not be evenly split by the amount we wanted to deallocate, need to add back in allocations.add(new Allocation(treatment, next.getOffset() + next.getSize() + sizeLeft, -sizeLeft)); break; } } sortAllocations(); mergeAdjacentAllocations(); rebuildAllocationTables(); }
public Builder addTreatment(String name, String description) { treatments.put(name, new Treatment(name, description)); return this; }
@Override public TreatmentOverrideDto toDto(TreatmentOverride override) { return new TreatmentOverrideDto( override.getName(), override.getFilter().toString(), override.getTreatment().getName() ); }
lastOffset = next.getOffset() + next.getSize(); if (!next.getTreatment().equals(source)) { continue;
getUnallocatedSize() >= size, "not enough free bins to allocate treatment %s with size %s given %s unallocated bin(s)", treatment.getName(), size, getUnallocatedSize()