| /******************************************************************************* |
| * Copyright (c) 2009, 2011 SAP AG and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * SAP AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation; |
| |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.ocl.ecore.Variable; |
| import org.eclipse.ocl.ecore.opposites.OppositeEndFinder; |
| import org.eclipse.ocl.examples.impactanalyzer.ValueNotFoundException; |
| import org.eclipse.ocl.examples.impactanalyzer.deltaPropagation.VariableValueNotFoundInfo; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory; |
| |
| |
| |
| public class UnusedEvaluationRequestSet { |
| /** |
| * If the result says that {@link #hasProvenUnused() unused was proven}, there won't be a {@link #getNewRequestSet() new request set} |
| * delivered. Otherwise, the new request set delivered by {@link #getNewRequestSet()} is the request set updated by setting |
| * a variable value in the remaining {@link UnusedEvaluationRequest}s as well as having removed those requests that were |
| * evaluated due to the variable inference and that returned <code>false</code>. Those requests whose evaluation was triggered |
| * by the variable inference but which failed due to another unknown variable are entered again, this time with the now |
| * unknown variable as key. |
| * |
| * @author Axel Uhl (D043530) |
| * |
| */ |
| public static class UnusedEvaluationResult { |
| private final boolean provedUnused; |
| private final UnusedEvaluationRequestSet newRequestSet; |
| private UnusedEvaluationResult(boolean provedUnused, UnusedEvaluationRequestSet newRequestSet) { |
| this.provedUnused = provedUnused; |
| this.newRequestSet = newRequestSet; |
| } |
| public boolean hasProvenUnused() { |
| return provedUnused; |
| } |
| public UnusedEvaluationRequestSet getNewRequestSet() { |
| return newRequestSet; |
| } |
| public String toString() { |
| return "[unused: "+provedUnused+", newRequestSet: "+newRequestSet+"]"; |
| } |
| } |
| |
| /** |
| * Keys requests to evaluate an OCL expression to check whether a changed subexpression is not used. |
| * Key is the variable whose value was unknown the last time the expression was to be evaluated. |
| * See also {@link ValueNotFoundException}. |
| */ |
| private final Map<Variable, Set<UnusedEvaluationRequest>> requests; |
| |
| private UnusedEvaluationRequestSet(Map<Variable, Set<UnusedEvaluationRequest>> requests) { |
| this.requests = requests; |
| } |
| |
| @Override |
| public int hashCode() { |
| final int prime = 31; |
| int result = 1; |
| result = prime * result + ((requests == null) ? 0 : requests.hashCode()); |
| return result; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| if (obj == null) { |
| return false; |
| } |
| if (!(obj instanceof UnusedEvaluationRequestSet)) { |
| return false; |
| } |
| UnusedEvaluationRequestSet other = (UnusedEvaluationRequestSet) obj; |
| if (requests == null) { |
| if (other.requests != null) { |
| return false; |
| } |
| } else if (!requests.equals(other.requests)) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Computes a new set of {@link UnusedEvaluationRequest}s by copying all those {@link #requests requests} not keyed by a |
| * variable that entered or left scope. Those requests whose unknown variable left or entered scope can't be inferred anymore |
| * along this traceback chain. Therefore, we can remove their corresponding requests. |
| * <p> |
| * |
| * For all remaining requests, we remove the slots for any variable contained in <code>variablesThatLeavOrEnterScope</code>. |
| */ |
| public UnusedEvaluationRequestSet createReducedSet(Set<Variable> variablesThatLeaveOrEnterScope, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory) { |
| UnusedEvaluationRequestSet result = this; |
| if (!requests.isEmpty() && !variablesThatLeaveOrEnterScope.isEmpty()) { |
| boolean changed = false; |
| Map<Variable, Set<UnusedEvaluationRequest>> remainingRequestsUpdated = new HashMap<Variable, Set<UnusedEvaluationRequest>>(); |
| for (Map.Entry<Variable, Set<UnusedEvaluationRequest>> e : requests.entrySet()) { |
| if (!variablesThatLeaveOrEnterScope.contains(e.getKey())) { |
| // the request did not become obsolete due to its unknown variable |
| boolean setChanged = false; |
| UnusedEvaluationRequest[] newSet = new UnusedEvaluationRequest[e.getValue().size()]; |
| int newSetIndex = 0; |
| for (UnusedEvaluationRequest request : e.getValue()) { |
| UnusedEvaluationRequest newRequest = request.getRequestWithSlotsRemoved(variablesThatLeaveOrEnterScope, |
| unusedEvaluationRequestFactory); |
| if (newRequest != request) { |
| changed = true; |
| setChanged = true; |
| } |
| if (!newRequest.hasOneOrMoreSlots()) { |
| throw new RuntimeException( |
| "Internal error: an UnusedEvaluationRequest whose unknown variable is still in scope " |
| + "claims to have lost all its slots; the slot for the unknown variable should, however, still be there."); |
| } |
| newSet[newSetIndex++] = newRequest; |
| } |
| if (setChanged) { |
| Set<UnusedEvaluationRequest> newSetAsSet = new HashSet<UnusedEvaluationRequest>(); |
| for (int i=0; i<newSetIndex; i++) { |
| newSetAsSet.add(newSet[i]); |
| } |
| remainingRequestsUpdated.put(e.getKey(), newSetAsSet); |
| } else { |
| remainingRequestsUpdated.put(e.getKey(), e.getValue()); |
| } |
| } else { |
| changed = true; // the request got dropped |
| } |
| } |
| if (changed) { |
| result = new UnusedEvaluationRequestSet(remainingRequestsUpdated); |
| } else { |
| result = this; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Announces that the value for a variable was inferred. All contained {@link UnusedEvaluationRequest}s that have a slot for |
| * this variable are cloned and the value inferred is stored in the cloned request. If the variable is the unknown variable |
| * for any of the requests managed by this set, the request is re-evaluated. If the request evaluates to <code>false</code>, |
| * it is silently removed from the new request set returned. If the request evaluates to <code>true</code>, further evaluation |
| * is aborted immediately, and the method just returns the fact that one of the requests evaluated to <code>true</code>. If |
| * the request evaluation fails due to an unknown variable, the request is returned in the |
| * {@link UnusedEvaluationResult#getNewRequestSet() new request set} keyed by the now unknown variable. |
| * @param oclFactory TODO |
| * |
| * @return a result that tells whether unusedness could be proven and which tells the potentially transformed |
| * next {@link UnusedEvaluationRequestSet} which may be this unchanged object in case no request had a slot for |
| * the variable inferred, or a new set which contains the re-organized and possibly cloned requests. |
| */ |
| public UnusedEvaluationResult setVariable(Variable variable, EObject value, OppositeEndFinder oppositeEndFinder, |
| org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache tracebackCache, OCLFactory oclFactory) { |
| UnusedEvaluationResult result; |
| boolean changed = false; |
| Map<Variable, Set<UnusedEvaluationRequest>> newRequestSet = new HashMap<Variable, Set<UnusedEvaluationRequest>>(); |
| // enter variable value into those requests that have a slot for it |
| for (Map.Entry<Variable, Set<UnusedEvaluationRequest>> e : requests.entrySet()) { |
| UnusedEvaluationRequest[] newSet = new UnusedEvaluationRequest[e.getValue().size()]; |
| int newSetIndex = 0; |
| boolean setChanged = false; |
| for (UnusedEvaluationRequest request : e.getValue()) { |
| UnusedEvaluationRequest clonedRequest = request.setInferredVariableValue(variable, value, |
| tracebackCache.getUnusedEvaluationRequestFactory()); |
| newSet[newSetIndex++] = clonedRequest; |
| if (clonedRequest != request) { |
| changed = true; |
| setChanged = true; |
| } |
| } |
| if (!setChanged) { |
| newRequestSet.put(e.getKey(), e.getValue()); |
| } else { |
| Set<UnusedEvaluationRequest> set = new HashSet<UnusedEvaluationRequest>(); |
| for (int i=0; i<newSetIndex; i++) { |
| set.add(newSet[i]); |
| } |
| newRequestSet.put(e.getKey(), set); |
| } |
| } |
| // now re-evaluate those that previously failed because variable was unknown |
| Collection<UnusedEvaluationRequest> triggered = newRequestSet.get(variable); |
| if (triggered != null) { |
| newRequestSet.remove(variable); |
| changed = true; |
| UnusedEvaluationRequestSet nextSet = new UnusedEvaluationRequestSet(newRequestSet); |
| UnusedEvaluationResult preResult = evaluate(triggered, oppositeEndFinder, tracebackCache, oclFactory); |
| result = new UnusedEvaluationResult(preResult.hasProvenUnused(), nextSet.merge(preResult.getNewRequestSet())); |
| } else { |
| result = new UnusedEvaluationResult(/* provedUnused */ false, changed ? new UnusedEvaluationRequestSet(newRequestSet) : this); |
| } |
| return result; |
| } |
| |
| /** |
| * Evaluates the <code>requestsToEvaluate</code>. If any of them returns <code>true</code> from its |
| * {@link UnusedEvaluationRequest#evaluate(OppositeEndFinder, OCLFactory)} method, a result will be returned that returns |
| * <code>true</code> from its {@link UnusedEvaluationResult#hasProvenUnused()} method. Otherwise, that result's method will |
| * return <code>false</code>. If any request's evaluation failed for an unknown variable, the request will be added to a new |
| * {@link UnusedEvaluationRequestSet} which is part of this method's result (see |
| * {@link UnusedEvaluationResult#getNewRequestSet()}), keyed by the unknown {@link Variable}. |
| * |
| * @param requestsToEvaluate |
| * may be <code>null</code> which will immediately cause the result to be a combination of <code>false</code> and a |
| * new, empty {@link UnusedEvaluationRequestSet}. |
| */ |
| public static UnusedEvaluationResult evaluate(Collection<UnusedEvaluationRequest> requestsToEvaluate, |
| OppositeEndFinder oppositeEndFinder, TracebackCache tracebackCache, OCLFactory oclFactory) { |
| UnusedEvaluationResult result = null; |
| Map<Variable, Set<UnusedEvaluationRequest>> newRequestSet = null; |
| if (requestsToEvaluate != null) { |
| newRequestSet = new HashMap<Variable, Set<UnusedEvaluationRequest>>(2); |
| for (UnusedEvaluationRequest request : requestsToEvaluate) { |
| Object evaluationResult = tracebackCache.getCachedEvaluationResult(request); |
| if (evaluationResult == null) { |
| evaluationResult = request.checkValuePresentForAllRequiredVariables(); |
| if (evaluationResult == null) { // all inevitably required variables defined |
| try { |
| evaluationResult = request.evaluate(oppositeEndFinder, oclFactory); |
| } catch (ValueNotFoundException vnfe) { |
| evaluationResult = vnfe; |
| } |
| } |
| tracebackCache.cacheEvaluationResult(request, evaluationResult); |
| } |
| if (evaluationResult instanceof VariableValueNotFoundInfo) { |
| // re-add the request, but this time for the now unknown variable |
| Variable unknownVariable = (Variable) ((VariableValueNotFoundInfo) evaluationResult).getVariableExp() |
| .getReferredVariable(); |
| Set<UnusedEvaluationRequest> newSet = newRequestSet.get(unknownVariable); |
| if (newSet == null) { |
| newSet = new HashSet<UnusedEvaluationRequest>(); |
| newRequestSet.put(unknownVariable, newSet); |
| } |
| newSet.add(request); |
| } else { |
| // must be boolean, indicating result of successful evaluation |
| if ((Boolean) evaluationResult) { |
| result = new UnusedEvaluationResult(/* provedUnused */true, /* newRequestSet */null); |
| break; |
| } else { |
| // else, simply don't add the resolved request anymore because it was unable to prove unused |
| } |
| } |
| } |
| } |
| if (result == null) { |
| result = new UnusedEvaluationResult(/* provedUnused */false, newRequestSet == null || newRequestSet.isEmpty() ? null |
| : new UnusedEvaluationRequestSet(newRequestSet)); |
| } |
| return result; |
| } |
| |
| /** |
| * Produces a new instance of this class whose {@link #requests} map holds the combined sets of {@link UnusedEvaluationRequest}s |
| * from this and the <code>other</code> set. |
| * |
| * @param other may be <code>null</code>, which makes the method return <code>this</code> unchanged |
| */ |
| public UnusedEvaluationRequestSet merge(UnusedEvaluationRequestSet other) { |
| if (other == null || other.requests.isEmpty()) { |
| if (requests.isEmpty()) { |
| return null; |
| } else { |
| return this; |
| } |
| } else if (requests.isEmpty()) { |
| return other; |
| } else { |
| Map<Variable, Set<UnusedEvaluationRequest>> newRequests = new HashMap<Variable, Set<UnusedEvaluationRequest>>( |
| requests); |
| for (Map.Entry<Variable, Set<UnusedEvaluationRequest>> e : other.requests.entrySet()) { |
| if (!e.getValue().isEmpty()) { |
| Set<UnusedEvaluationRequest> set = newRequests.get(e.getKey()); |
| if (set == null || set.isEmpty()) { |
| set = e.getValue(); |
| } else { |
| Set<UnusedEvaluationRequest> newSet = new HashSet<UnusedEvaluationRequest>(set.size() + 1); |
| newSet.addAll(set); |
| newSet.addAll(e.getValue()); |
| set = newSet; |
| } |
| newRequests.put(e.getKey(), set); |
| } |
| } |
| return new UnusedEvaluationRequestSet(newRequests); |
| } |
| } |
| |
| public String toString() { |
| StringBuilder result = new StringBuilder("requests by unknown variable: ["); |
| boolean firstVariable = true; |
| for (Map.Entry<Variable, Set<UnusedEvaluationRequest>> e : requests.entrySet()) { |
| if (!firstVariable) { |
| result.append(", "); |
| } else { |
| firstVariable = false; |
| } |
| result.append(e.getKey().getName()); |
| result.append(": ["); |
| boolean first = true; |
| for (UnusedEvaluationRequest request : e.getValue()) { |
| if (!first) { |
| result.append(","); |
| } else { |
| first = false; |
| } |
| result.append(request); |
| } |
| result.append("]"); |
| } |
| result.append("]"); |
| return result.toString(); |
| } |
| } |
