public DseConflictSet(ConflictResolver resolver, ConflictResolver activationOrderingConflictResolver, IStateCoder stateCoder) { this.resolver = resolver; activationOrderingConflictSet = activationOrderingConflictResolver.createConflictSet(); activationCodesConflictSet = new ActivationCodesConflictSet(activationOrderingConflictSet, stateCoder); }
@Override public boolean addActivation(Activation<?> activation) { activationCodesConflictSet.addActivation(activation); return activationOrderingConflictSet.addActivation(activation); }
public Activation<?> getActivationById(Object activationId) { return activationCodes.getActivation(activationId); }
public void backtrackXTimes(int steps) { for (int i = steps; i > 0; i--) { domain.getCommandStack().undo(); trajectory.backtrack(); } activationCodes.updateActivationCodes(); logger.debug("Backtracked " + steps + " times."); }
protected void reinitWithActivations(ConflictSet nextActivationsConflictSet) { this.nextActivationsConflictSet = nextActivationsConflictSet; activationCodes.clear(); for (Activation<?> activation : nextActivationsConflictSet.getNextActivations()) { Object activationCode = createActivationCode(activation); activationCodes.addActivation(activation, activationCode); } }
public Collection<Object> getTransitionsFromCurrentState() { return activationCodes.getCurrentActivationCodes(); }
public Object getTransitionByActivation(Activation<?> activation) { return activationCodes.getActivationId(activation); }
@Override public boolean removeActivation(Activation<?> activation) { activationCodesConflictSet.removeActivation(activation); return activationOrderingConflictSet.removeActivation(activation); }
public void changeActivationOrderingConflictSet(ChangeableConflictSet newActivationOrderingConflictSet) { for (Activation<?> activation : activationOrderingConflictSet.getConflictingActivations()) { newActivationOrderingConflictSet.addActivation(activation); } activationCodesConflictSet.reinitWithActivations(newActivationOrderingConflictSet); ChangeableConflictSet tmp = activationOrderingConflictSet; activationOrderingConflictSet = newActivationOrderingConflictSet; prevActivationOrderingConflictSet = tmp; }
public void undoUntilRoot() { while(trajectory.canStepBack()) { domain.getCommandStack().undo(); trajectory.backtrack(); } activationCodes.updateActivationCodes(); logger.debug("Backtracked to root."); }
continue; Object activationCode = createActivationCode(activation); activationCodes.addActivation(activation, activationCode); activationCodes.clear(); for (Activation<?> activation : nextActivationsConflictSet.getNextActivations()) { Object activationCode = createActivationCode(activation); activationCodes.addActivation(activation, activationCode);
public Collection<Object> getUntraversedTransitionsFromCurrentState() { if (designSpace == null) { throw new DSEException("Unsupported without a design space"); } Object currentState = trajectory.getCurrentStateId(); Collection<Object> traversedIds = designSpace.getActivationIds(currentState); List<Object> untraversedTransitions = new ArrayList<>(); for (Object activationId : activationCodes.getCurrentActivationCodes()) { if (!traversedIds.contains(activationId)) { untraversedTransitions.add(activationId); } } return untraversedTransitions; }
public int backtrackUntilLastCommonActivation(Object[] newTrajectory) { Iterator<Object> currentTrajectoryIterator = trajectory.getTrajectory().iterator(); if (!currentTrajectoryIterator.hasNext()) { return 0; } int indexOfLastCommonActivation = 0; for (Object activationCode : newTrajectory) { if (currentTrajectoryIterator.hasNext()) { Object activationCodeFromCurrent = currentTrajectoryIterator.next(); if (activationCodeFromCurrent.equals(activationCode)) { indexOfLastCommonActivation++; } else { break; } } else { // current trajectory is smaller break; } } int numberOfBacktracks = trajectory.getDepth() - indexOfLastCommonActivation; if (numberOfBacktracks > 0) { for (int i = numberOfBacktracks; i > 0; i--) { domain.getCommandStack().undo(); trajectory.backtrack(); } activationCodes.updateActivationCodes(); } logger.debug("Backtracked " + numberOfBacktracks + " times."); return indexOfLastCommonActivation; }
newStateId = stateCoder.createStateCode(); activationCodes.updateActivationCodes();
public boolean undoLastTransformation() { if (!trajectory.canStepBack()) { return false; } domain.getCommandStack().undo(); activationCodes.updateActivationCodes(); Object lastActivationId = trajectory.getLastActivationId(); trajectory.backtrack(); if (handlers != null) { for (IExploreEventHandler iExploreEventHandler : handlers) { iExploreEventHandler.undo(lastActivationId); } } logger.debug("Backtrack."); return true; }
activationCodes.updateActivationCodes();
activationCodesConflictSet.updateActivationCodes();