| /******************************************************************************* |
| * Copyright (c) 2009, 2012 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.traceback; |
| |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.Stack; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.Notifier; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.ocl.ecore.OCLExpression; |
| import org.eclipse.ocl.ecore.OperationCallExp; |
| import org.eclipse.ocl.ecore.TypeExp; |
| import org.eclipse.ocl.ecore.opposites.OppositeEndFinder; |
| import org.eclipse.ocl.examples.impactanalyzer.impl.OperationBodyToCallMapper; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.InstanceScopeAnalysis; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation.UnusedEvaluationRequestFactory; |
| import org.eclipse.ocl.examples.impactanalyzer.instanceScope.unusedEvaluation.UnusedEvaluationRequestSet; |
| import org.eclipse.ocl.examples.impactanalyzer.util.AnnotatedEObject; |
| import org.eclipse.ocl.examples.impactanalyzer.util.FlatSet; |
| import org.eclipse.ocl.examples.impactanalyzer.util.IterableAsOperationCallExpKeyedSet; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OCLFactory; |
| import org.eclipse.ocl.examples.impactanalyzer.util.OperationCallExpKeyedSet; |
| import org.eclipse.ocl.utilities.PredefinedType; |
| |
| public class OperationCallTracebackStep extends BranchingTracebackStep<OperationCallExp> { |
| private static final Set<String> sourcePassThroughStdLibOpNames; |
| private static final Set<String> argumentPassThroughStdLibOpNames; |
| static { |
| sourcePassThroughStdLibOpNames = new HashSet<String>(); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.ANY_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.AS_BAG_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.AS_SET_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.AS_ORDERED_SET_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.AS_SEQUENCE_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.AT_NAME); |
| // sourcePassThroughStdLibOpNames.add(PredefinedType.ATRPRE_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.EXCLUDING_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.FIRST_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.FLATTEN_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.INCLUDING_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.INSERT_AT_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.APPEND_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.INTERSECTION_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.OCL_AS_TYPE_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.UNION_NAME); |
| sourcePassThroughStdLibOpNames.add(PredefinedType.SELECT_BY_KIND_NAME); |
| |
| argumentPassThroughStdLibOpNames = new HashSet<String>(); |
| argumentPassThroughStdLibOpNames.add(PredefinedType.INCLUDING_NAME); |
| argumentPassThroughStdLibOpNames.add(PredefinedType.INSERT_AT_NAME); |
| argumentPassThroughStdLibOpNames.add(PredefinedType.APPEND_NAME); |
| argumentPassThroughStdLibOpNames.add(PredefinedType.UNION_NAME); |
| // TODO what about "product"? |
| } |
| |
| /** |
| * If set to a non-<code>null</code> value, the step executes an all-instances query using the |
| * {@link #oppositeEndFinder}. Otherwise, the steps are performed and their results returned. |
| */ |
| private final EClass allInstancesClass; |
| private final OppositeEndFinder oppositeEndFinder; |
| |
| /** |
| * In case of a <code>selectByType</code> operation on a collection, the |
| * type in {@link AbstractTracebackStep#requiredType} must be matched |
| * exactly. In this case, this attribute is set to <code>true</code> by the |
| * constructor, and an exact type check is performed by |
| * {@link #performSubsequentTraceback(AnnotatedEObject, UnusedEvaluationRequestSet, TracebackCache, Notification)} |
| * . |
| */ |
| private final boolean requireTypeExactly; |
| |
| /** |
| * Set to <code>true</code> for operations whose body is specified again in OCL. For such operations, this step will trace |
| * back using the body expression. Except for <code>allInstances()</code> cases this will lead back to <code>self</code> or |
| * operation parameters for which then all calls to the operation will be investigated. |
| * <p> |
| * |
| * While it would be nice to restrict this traceback to the single call currently under investigation, we so far haven't found |
| * a way to combine this with the caching technique used. We would have to record the complete call stack as part of the cache |
| * key, leading to a combinatorial explosion of cache keys and therefore to almost zero cache hits.<p> |
| * |
| * Instead, we compute the results for all calls but key them by the {@link OperationCallExp} through which the traceback |
| * of <code>self</code> or any parameter variables went so that later we can filter for those whose call we're actually |
| * interested in.<p> |
| * |
| * However, this applies only for operations whose body is specified in OCL. Therefore this flag. |
| */ |
| private final boolean filterResultsByCall; |
| |
| public OperationCallTracebackStep(OperationCallExp sourceExpression, EClass context, |
| OperationBodyToCallMapper operationBodyToCallMapper, Stack<String> tupleLiteralNamesToLookFor, |
| TracebackStepCache tracebackStepCache, UnusedEvaluationRequestFactory unusedEvaluationRequestFactory, OCLFactory oclFactory) { |
| super(sourceExpression, tupleLiteralNamesToLookFor, tracebackStepCache.getOppositeEndFinder(), operationBodyToCallMapper, unusedEvaluationRequestFactory, oclFactory); |
| oppositeEndFinder = tracebackStepCache.getOppositeEndFinder(); |
| // important to enter this step before recursive lookups may occur: |
| tracebackStepCache.put(sourceExpression, tupleLiteralNamesToLookFor, this); |
| OCLExpression body = operationBodyToCallMapper.getOperationBody(sourceExpression.getReferredOperation()); |
| if (body != null) { |
| allInstancesClass = null; |
| filterResultsByCall = true; |
| requireTypeExactly = false; |
| // an OCL-specified operation; trace back using the body expression |
| getSteps().add( |
| createTracebackStepAndScopeChange(sourceExpression, body, context, operationBodyToCallMapper, |
| tupleLiteralNamesToLookFor, tracebackStepCache)); |
| } else { |
| filterResultsByCall = false; |
| String opName = sourceExpression.getReferredOperation().getName(); |
| if (opName.equals(PredefinedType.OCL_AS_TYPE_NAME)) { |
| allInstancesClass = null; |
| requireTypeExactly = false; |
| handleOclAsType(sourceExpression, context, operationBodyToCallMapper, tupleLiteralNamesToLookFor, |
| tracebackStepCache); |
| } else if (opName.equals(PredefinedType.SELECT_BY_TYPE_NAME)) { |
| allInstancesClass = null; |
| requireTypeExactly = true; |
| handleSourcePassThroughOperation(sourceExpression, context, operationBodyToCallMapper, |
| tupleLiteralNamesToLookFor, tracebackStepCache, opName); |
| } else if (sourcePassThroughStdLibOpNames.contains(opName)) { |
| allInstancesClass = null; |
| requireTypeExactly = false; |
| handleSourcePassThroughOperation(sourceExpression, context, operationBodyToCallMapper, |
| tupleLiteralNamesToLookFor, tracebackStepCache, opName); |
| } else if (opName.equals(PredefinedType.ALL_INSTANCES_NAME)) { |
| // the object from where to trace back later in the navigate method may not |
| // conform to the type on which allInstances() is invoked here; for example, the |
| // expression may navigate from the result of allInstances() across an association |
| // defined on a superclass of the one on which allInstances() was invoked. Therefore, |
| // ensure that the typing of the AllInstancesNavigationStep is correct. |
| allInstancesClass = context; |
| requireTypeExactly = false; |
| } else { |
| allInstancesClass = null; |
| requireTypeExactly = false; |
| } |
| // hope, we didn't forget stdlib operations that pass on |
| // source or argument values into their result |
| } |
| } |
| |
| private void handleSourcePassThroughOperation(OperationCallExp sourceExpression, EClass context, |
| OperationBodyToCallMapper operationBodyToCallMapper, Stack<String> tupleLiteralNamesToLookFor, |
| TracebackStepCache tracebackStepCache, String opName) { |
| // FIXME handle product |
| getSteps().add(createTracebackStepAndScopeChange(sourceExpression, (OCLExpression) sourceExpression.getSource(), |
| context, operationBodyToCallMapper, tupleLiteralNamesToLookFor, tracebackStepCache)); |
| if (argumentPassThroughStdLibOpNames.contains(opName)) { |
| int paramPos = 0; |
| if (opName.equals(PredefinedType.INSERT_AT_NAME)) { |
| // "insertAt" takes two arguments, the index and the object to add. |
| // The OCL spec says the index comes first, so getting the first argument makes no sense in this case. |
| paramPos = 1; |
| } |
| OCLExpression argument = (OCLExpression) (sourceExpression.getArgument()).get(paramPos); |
| getSteps().add(createTracebackStepAndScopeChange(sourceExpression, argument, |
| context, operationBodyToCallMapper, tupleLiteralNamesToLookFor, tracebackStepCache)); |
| } |
| } |
| |
| private void handleOclAsType(OperationCallExp sourceExpression, EClass context, |
| OperationBodyToCallMapper operationBodyToCallMapper, Stack<String> tupleLiteralNamesToLookFor, |
| TracebackStepCache tracebackStepCache) { |
| OCLExpression argument = (OCLExpression) (sourceExpression.getArgument()).get(0); |
| if (argument instanceof TypeExp) { |
| // trace the source expression of the cast |
| getSteps().add(createTracebackStepAndScopeChange(sourceExpression, (OCLExpression) sourceExpression.getSource(), |
| context, operationBodyToCallMapper, tupleLiteralNamesToLookFor, tracebackStepCache)); |
| } else { |
| throw new RuntimeException("What else could be the argument of oclAsType if not a TypeExp? " |
| + (argument.eClass()).getName()); |
| } |
| } |
| |
| /** |
| * @param changeEvent |
| * if not <code>null</code>, and the event has a non- |
| * <code>null</code> {@link Notification#getNotifier() notifier}, |
| * this notifier will be used as the lookup context in case an |
| * <code>allInstances</code> operation call needs to be traced |
| * back by computing all context instances of the overall |
| * expression; otherwise, the <code>source</code> object will be |
| * used as the lookup context for <code>allInstances</code> |
| * lookup |
| */ |
| @Override |
| protected OperationCallExpKeyedSet performSubsequentTraceback(AnnotatedEObject source, |
| UnusedEvaluationRequestSet pendingUnusedEvalRequests, |
| org.eclipse.ocl.examples.impactanalyzer.instanceScope.traceback.TracebackCache tracebackCache, |
| Notification changeEvent) { |
| OperationCallExpKeyedSet result; |
| if (allInstancesClass != null) { |
| FlatSet preResult = new FlatSet(); |
| Notifier allInstancesLookupContext; |
| if (changeEvent != null && changeEvent.getNotifier() != null) { |
| allInstancesLookupContext = (Notifier) changeEvent.getNotifier(); |
| } else { |
| allInstancesLookupContext = source.getAnnotatedObject(); |
| } |
| for (EObject roi : InstanceScopeAnalysis.getAllPossibleContextInstances( |
| allInstancesLookupContext, allInstancesClass, oppositeEndFinder)) { |
| preResult.add(annotateEObject(source, roi)); |
| } |
| result = preResult; |
| } else { |
| OperationCallExpKeyedSet preResult; |
| if (requireTypeExactly && source.eClass() != requiredType) { |
| preResult = FlatSet.emptySet(); |
| } else { |
| preResult = (OperationCallExpKeyedSet) super |
| .performSubsequentTraceback(source, pendingUnusedEvalRequests, tracebackCache, changeEvent); |
| } |
| if (filterResultsByCall && tracebackCache.getConfiguration().isOperationCallSelectionActive()) { |
| result = new IterableAsOperationCallExpKeyedSet(preResult.getCombinedResultsFor(getExpression())); |
| } else { |
| result = preResult; |
| } |
| } |
| return result; |
| } |
| |
| } |
