/*******************************************************************************
* Copyright (c) 2009, 2014 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.deltaPropagation;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EEnumLiteral;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EOperation;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EParameter;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.ocl.AbstractEvaluationVisitor;
import org.eclipse.ocl.Environment;
import org.eclipse.ocl.EvaluationEnvironment;
import org.eclipse.ocl.EvaluationHaltedException;
import org.eclipse.ocl.ecore.CallExp;
import org.eclipse.ocl.ecore.CallOperationAction;
import org.eclipse.ocl.ecore.Constraint;
import org.eclipse.ocl.ecore.EvaluationEnvironmentWithHiddenOpposites;
import org.eclipse.ocl.ecore.EvaluationVisitorImpl;
import org.eclipse.ocl.ecore.OppositePropertyCallExp;
import org.eclipse.ocl.ecore.SendSignalAction;
import org.eclipse.ocl.examples.impactanalyzer.ValueNotFoundException;
import org.eclipse.ocl.examples.impactanalyzer.impl.ImpactAnalyzerPlugin;
import org.eclipse.ocl.expressions.AssociationClassCallExp;
import org.eclipse.ocl.expressions.BooleanLiteralExp;
import org.eclipse.ocl.expressions.CollectionKind;
import org.eclipse.ocl.expressions.CollectionLiteralExp;
import org.eclipse.ocl.expressions.EnumLiteralExp;
import org.eclipse.ocl.expressions.IfExp;
import org.eclipse.ocl.expressions.IntegerLiteralExp;
import org.eclipse.ocl.expressions.InvalidLiteralExp;
import org.eclipse.ocl.expressions.IterateExp;
import org.eclipse.ocl.expressions.IteratorExp;
import org.eclipse.ocl.expressions.LetExp;
import org.eclipse.ocl.expressions.MessageExp;
import org.eclipse.ocl.expressions.NullLiteralExp;
import org.eclipse.ocl.expressions.OCLExpression;
import org.eclipse.ocl.expressions.OperationCallExp;
import org.eclipse.ocl.expressions.PropertyCallExp;
import org.eclipse.ocl.expressions.RealLiteralExp;
import org.eclipse.ocl.expressions.StateExp;
import org.eclipse.ocl.expressions.StringLiteralExp;
import org.eclipse.ocl.expressions.TupleLiteralExp;
import org.eclipse.ocl.expressions.TypeExp;
import org.eclipse.ocl.expressions.UnlimitedNaturalLiteralExp;
import org.eclipse.ocl.expressions.UnspecifiedValueExp;
import org.eclipse.ocl.expressions.VariableExp;
import org.eclipse.ocl.types.CollectionType;
import org.eclipse.ocl.util.CollectionUtil;
import org.eclipse.ocl.utilities.PredefinedType;
/**
* When a {@link ValueNotFoundException} occurs during evaluating an expression, it is not caught, logged and swallowed but
* forwarded to the caller.
* <p>
*
* All <tt>visit...</tt> operations check if the expression to evaluate is the {@link #sourceExpression} passed to the
* constructor. If so, instead of actually evaluating the expression, the {@link #valueOfSourceExpression} object is returned
* which was also passed to the constructor. This allows for partial evaluation of any {@link CallExp} with a given value for the
* source expression.
* <p>
*
* When the {@link #sourceExpression} has once been evaluated it is nulled out so that when due to recursion it is
* evaluated again, evaluation is based on the current environment and not on the cached {@link #valueOfSourceExpression}.
* Without this it could happen that, e.g., the value for a <tt>self</tt> {@link org.eclipse.ocl.ecore.VariableExp} is
* cached but would have to have a different value upon recursive evaluation.
*
* @author Axel Uhl
*
*/
public class PartialEvaluationVisitorImpl extends EvaluationVisitorImpl {
private org.eclipse.ocl.ecore.OCLExpression sourceExpression;
private Object valueOfSourceExpression;
/**
* a {@link Notification} object such that an evaluation will be based on the state *before* the notification. For example, if
* the notification indicates the removal of a reference from an element <tt>e1</tt> to an element <tt>e2</tt> across
* reference <tt>r</tt> then when during partial evaluation <tt>r</tt> is traversed starting from <tt>e1</tt> then <tt>e2</tt>
* will show in the results although in the current version of the model it would not. If <tt>null</tt>, the evaluator will
* evaluate expressions on the model as is.
*/
private Notification atPre;
/**
* @param atPre
* a {@link Notification} object such that an evaluation will be based on the state *before* the notification. For
* example, if the notification indicates the removal of a reference from an element <tt>e1</tt> to an element
* <tt>e2</tt> across reference <tt>r</tt> then when during partial evaluation <tt>r</tt> is traversed starting
* from <tt>e1</tt> then <tt>e2</tt> will show in the results although in the current version of the model it would
* not. If <tt>null</tt>, the evaluator will evaluate expressions on the model as is.
*/
public PartialEvaluationVisitorImpl(
Environment<EPackage, EClassifier, EOperation, EStructuralFeature, EEnumLiteral, EParameter, EObject, CallOperationAction, SendSignalAction, Constraint, EClass, EObject> env,
EvaluationEnvironment<EClassifier, EOperation, EStructuralFeature, EClass, EObject> evalEnv,
Map<? extends EClass, ? extends Set<? extends EObject>> extentMap,
org.eclipse.ocl.ecore.OCLExpression sourceExpression, Object valueOfSourceExpression, Notification atPre) {
super(env, evalEnv, extentMap);
this.sourceExpression = sourceExpression;
this.valueOfSourceExpression = valueOfSourceExpression;
this.atPre = atPre;
}
@Override
public Object visitOperationCallExp(OperationCallExp<EClassifier, EOperation> oc) {
if (oc == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
} else {
int opCode = oc.getOperationCode();
if (opCode == PredefinedType.AT) {
OCLExpression<EClassifier> source = oc.getSource();
List<OCLExpression<EClassifier>> args = oc.getArgument();
// evaluate source
Object sourceVal = source.accept(getVisitor());
if (sourceVal == getInvalid() || ((Collection<?>) sourceVal).isEmpty()) {
// then we know there's going to be an IndexOutOfBoundsException thrown in CollectionUtil.at; skip the
// evaluation of the argument expression which could only raise a ValueNotFoundException in case a variable
// is accessed that is not defined; but it wouldn't change the result which always will be invalid for
// an empty collection.
return getInvalid();
}
// evaluate argument
OCLExpression<EClassifier> arg = args.get(0);
if (isUndefined(sourceVal)) {
return getInvalid();
}
@SuppressWarnings("unchecked")
Collection<Object> sourceColl = (Collection<Object>) sourceVal;
// bug 183144: inputting OclInvalid should result in OclInvalid
Object argVal = arg.accept(getVisitor());
if (argVal == getInvalid()) {
return argVal;
}
// OrderedSet, Sequence::at(Integer)
if (!(argVal instanceof Integer)) {
return getInvalid();
}
int indexVal = ((Integer) argVal).intValue();
return CollectionUtil.at(sourceColl, indexVal);
}
}
return super.visitOperationCallExp(oc);
}
@Override
protected Object safeVisitExpression(OCLExpression<EClassifier> source) {
Object sourceVal;
try {
sourceVal = source.accept(getVisitor());
} catch (EvaluationHaltedException ehe) {
throw ehe;
} catch (ValueNotFoundException vnfe) {
throw vnfe;
} catch (RuntimeException e) {
sourceVal = getInvalid();
}
return sourceVal;
}
@Override
public Object visitIterateExp(IterateExp<EClassifier, EParameter> ie) {
if (ie == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitIterateExp(ie);
}
@Override
public Object visitIteratorExp(IteratorExp<EClassifier, EParameter> ie) {
if (ie == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitIteratorExp(ie);
}
@Override
public Object visitEnumLiteralExp(EnumLiteralExp<EClassifier, EEnumLiteral> el) {
if (el == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitEnumLiteralExp(el);
}
@Override
public PartialEcoreEvaluationEnvironment getEvaluationEnvironment() {
return (PartialEcoreEvaluationEnvironment) super.getEvaluationEnvironment();
}
@Override
public Object visitVariableExp(VariableExp<EClassifier, EParameter> v) {
if (v == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
// evaluate the variable in the current environment, using a special getValueOf(...) operation that
// accepts the VariableExp so as to better be able to annotate an exception in case the variable is
// unknown
return getEvaluationEnvironment().getValueOf(v);
}
@SuppressWarnings("unchecked")
@Override
public Object visitPropertyCallExp(PropertyCallExp<EClassifier, EStructuralFeature> pc) {
if (pc == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
/*
* These are the sources of the super implementation copied here which is ugly. We only want to get access to the value of
* the source expression because it may be needed for the comparison with the atPre event later.
*
* TODO evaluate source expression here and cache the result before delegating to super.visitPropertyCallExp; when then
* super.visitPropertyCallExp asks the visitor to evaluate the source expression, the result is taken from the cache
*/
EStructuralFeature property = pc.getReferredProperty();
OCLExpression<EClassifier> source = pc.getSource();
// evaluate source
Object context = source.accept(getVisitor());
Object localResult;
// if source is undefined, result is OclInvalid
if (isUndefined(context)) {
localResult = getInvalid();
} else {
OCLExpression<EClassifier> derivation = getPropertyBody(property);
if (derivation != null) {
// this is an additional property
localResult = navigate(property, derivation, context);
} else {
List<Object> qualifiers;
if (pc.getQualifier().isEmpty()) {
qualifiers = Collections.emptyList();
} else {
// handle qualified association navigation
qualifiers = new java.util.ArrayList<Object>();
for (OCLExpression<EClassifier> q : pc.getQualifier()) {
qualifiers.add(q.accept(getVisitor()));
}
}
localResult = getEvaluationEnvironment().navigateProperty(property, qualifiers, context);
if ((pc.getType() instanceof CollectionType<?, ?>) && !(localResult instanceof Collection<?>)) {
// this was an XSD "unspecified multiplicity". Now that we know what
// the multiplicity is, we can coerce it to a collection value
CollectionKind kind = ((CollectionType<EClassifier, EOperation>) pc.getType()).getKind();
Collection<Object> collection = CollectionUtil.createNewCollection(kind);
collection.add(localResult);
localResult = collection;
}
}
}
if (atPre != null && atPre.getNotifier() != null && atPre.getNotifier() == context
&& pc.getReferredProperty() == atPre.getFeature()) {
CollectionKind kind = (pc.getType() instanceof CollectionType<?, ?>) ? ((CollectionType<EClassifier, EOperation>) pc
.getType()).getKind() : null;
// evaluate property call based on the model state that existed before the change
// described by the atPre notification
switch (atPre.getEventType()) {
case Notification.ADD:
// if the addition operated on the result of the source expression, remove the element from the local results
// again
localResult = removeAt((Collection<?>) localResult, kind);
break;
case Notification.ADD_MANY:
// if the addition operated on the result of the source expression, remove the elements from the local results
// again
((Collection<?>) localResult).removeAll((Collection<?>) atPre.getNewValue());
break;
case Notification.MOVE:
// if the move operated on the result of the source expression, move the element back to the old index
// indicated by getOldIntValue()
localResult = move((Collection<?>) localResult, kind);
break;
case Notification.REMOVE:
// if the removal operated on the result of the source expression, add the element back at the index provided
localResult = insertAt((Collection<Object>) localResult, kind);
break;
case Notification.REMOVE_MANY:
// if the removal operated on the result of the source expression, add the elements back at the positions
// given in the getNewValue() int[].
// TODO restore at appropriate position if provided and collection is ordered (a list)
localResult = insertManyAt((Collection<Object>) localResult, kind);
break;
case Notification.SET:
case Notification.UNSET:
// if the setting/unsetting operated on the result of the source expression, return the old value
// TODO restore old value at position specified by index, if any, and if the local result is a collection
localResult = atPre.getOldValue();
break;
case Notification.RESOLVE:
// TODO consider avoiding filtering for RESOLVE notifications in the first place
break; // stay with new, resolved value because resolution is automatic
default:
throw new RuntimeException("Don't understand @pre notification " + atPre);
}
}
return localResult;
}
/**
* Assumes that {@link #atPre}.{@link Notification#getOldValue()} contains a collection of the
* objects that were removed and that {@link #atPre}.{@link Notification#getNewValue()} is an
* <tt>int[]</tt> describing the old positions at which the elements were removed.
*
* @param <T>
* @param into
* @param kind
*/
@SuppressWarnings("unchecked")
private <T> Collection<T> insertManyAt(Collection<T> into, CollectionKind kind) {
Collection<T> result;
int[] oldPositions = (int[]) atPre.getNewValue();
if ((kind == CollectionKind.SEQUENCE_LITERAL || kind == CollectionKind.ORDERED_SET_LITERAL)
&& atPre.getPosition() != Notification.NO_INDEX) {
if (into instanceof List<?>) {
int i=0;
for (T t : ((Collection<T>) atPre.getOldValue())) {
((List<T>) into).add(oldPositions[i++], t);
}
result = into;
} else {
// ordered but not a list; probably an OrderedSet rendered as a LinkedHashMap; we need to copy
// maybe we're lucky and can append to the end:
if (oldPositions[0] >= into.size()) {
for (T t : ((Collection<T>) atPre.getOldValue())) {
((List<T>) into).add(t);
}
result = into;
} else {
result = CollectionUtil.createNewCollection(kind);
int i = 0;
Iterator<T> removedIter = ((Collection<T>) atPre.getOldValue()).iterator();
int targetPos = 0;
for (T t : into) {
if (targetPos == oldPositions[i]) {
result.add(removedIter.next());
targetPos++;
}
result.add(t);
targetPos++;
}
}
}
} else {
into.addAll((Collection<T>) atPre.getOldValue());
result = into;
}
return result;
}
/**
* Moves the {@link #atPre}'s {@link Notification#getNewValue() new value} from the new position
* described by {@link #atPre}.{@link Notification#getPosition() getPosition()} to the old position
* described by {@link #atPre}.{@link Notification#getOldValue() getOldValue()}. Does what is needed,
* including cloning the collection and fixing the order by iteration if necessary.
*/
@SuppressWarnings("unchecked")
private <T> Collection<T> move(Collection<T> collection, CollectionKind kind) {
Collection<T> result = collection;
if ((kind == CollectionKind.SEQUENCE_LITERAL || kind == CollectionKind.ORDERED_SET_LITERAL)
&& atPre.getPosition() != Notification.NO_INDEX) {
int oldPositionBeforeMove = (Integer) atPre.getOldValue();
int newPositionAfterMove = atPre.getPosition();
if (collection instanceof List<?>) {
if (((List<?>) collection).get(atPre.getPosition()) != atPre.getNewValue()) {
throw new RuntimeException("Internal error. Didn't find " + atPre.getNewValue() + " at position "
+ atPre.getPosition());
} else {
((List<T>) collection).remove(newPositionAfterMove);
((List<T>) collection).add(oldPositionBeforeMove, (T) atPre.getNewValue());
result = collection;
}
} else {
if (oldPositionBeforeMove >= collection.size()) {
// can handle by remove and add at end
collection.remove(atPre.getNewValue());
collection.add((T) atPre.getNewValue());
} else {
// ordered but not a list; probably an OrderedSet rendered as a LinkedHashMap; we need to copy
result = CollectionUtil.createNewCollection(kind);
int sourcePos = 0;
int targetPos = 0;
for (T t : collection) {
if (targetPos == oldPositionBeforeMove) {
result.add((T) atPre.getNewValue());
targetPos++;
}
if (sourcePos != newPositionAfterMove) {
result.add(t);
targetPos++;
}
sourcePos++;
}
}
}
}
// no action required otherwise because the collection is not ordered and moving is not defined
// on an unordered collection
return result;
}
/**
* Removes {@link #atPre}'s new value from the <tt>from</tt> collection. If the collection kind indicates an ordered
* collection and the {@link #atPre} event specifies a valid index, removal will take place at the index specified after a
* check that at that index the {@link #atPre}.{@link Notification#getNewValue() getNewValue()} object is found.
* <p>
*
* Precondition: {@link #atPre} <tt>!= null</tt>
*/
private <T> Collection<T> removeAt(Collection<T> from, CollectionKind kind) {
Collection<T> result;
if ((kind == CollectionKind.SEQUENCE_LITERAL || kind == CollectionKind.ORDERED_SET_LITERAL)
&& atPre.getPosition() != Notification.NO_INDEX) {
if (from instanceof List<?>) {
if (((List<?>) from).get(atPre.getPosition()) != atPre.getNewValue()) {
throw new RuntimeException("Internal error. Didn't find " + atPre.getNewValue() + " at position "
+ atPre.getPosition());
} else {
((List<?>) from).remove(atPre.getPosition());
result = from;
}
} else {
// ordered but not a list; probably an OrderedSet rendered as a LinkedHashMap; we need to copy
result = CollectionUtil.createNewCollection(kind);
int i = 0;
for (T t : from) {
if (i++ != atPre.getPosition()) {
result.add(t);
}
}
}
} else {
from.remove(atPre.getNewValue());
result = from;
}
return result;
}
/**
* Adds {@link #atPre}'s old value to the <tt>into</tt> collection. If the collection kind indicates an ordered collection and
* the {@link #atPre} event specifies a valid index, insertion will take place at the index specified.
* <p>
*
* Precondition: {@link #atPre} <tt>!= null</tt>
*/
@SuppressWarnings("unchecked")
private <T> Collection<T> insertAt(Collection<T> into, CollectionKind kind) {
Collection<T> result;
if ((kind == CollectionKind.SEQUENCE_LITERAL || kind == CollectionKind.ORDERED_SET_LITERAL)
&& atPre.getPosition() != Notification.NO_INDEX) {
if (into instanceof List<?>) {
((List<T>) into).add(atPre.getPosition(), (T) atPre.getOldValue());
result = into;
} else {
// ordered but not a list; probably an OrderedSet rendered as a LinkedHashMap; we need to copy
// maybe we're lucky and can append to the end:
if (atPre.getPosition() >= into.size()) {
into.add((T) atPre.getOldValue());
result = into;
} else {
result = CollectionUtil.createNewCollection(kind);
int i = 0;
for (T t : into) {
if (i++ == atPre.getPosition()) {
result.add((T) atPre.getOldValue());
i++;
}
result.add(t);
}
}
}
} else {
into.add((T) atPre.getOldValue());
result = into;
}
return result;
}
@Override
public Object visitAssociationClassCallExp(AssociationClassCallExp<EClassifier, EStructuralFeature> ae) {
if (ae == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitAssociationClassCallExp(ae);
}
@Override
public Object visitIfExp(IfExp<EClassifier> ie) {
if (ie == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitIfExp(ie);
}
@Override
public Object visitTypeExp(TypeExp<EClassifier> t) {
if (t == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitTypeExp(t);
}
@Override
public Object visitStateExp(StateExp<EClassifier, EObject> s) {
if (s == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitStateExp(s);
}
@Override
public Object visitMessageExp(MessageExp<EClassifier, CallOperationAction, SendSignalAction> m) {
if (m == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitMessageExp(m);
}
@Override
public Object visitUnspecifiedValueExp(UnspecifiedValueExp<EClassifier> uv) {
if (uv == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitUnspecifiedValueExp(uv);
}
@Override
public Object visitIntegerLiteralExp(IntegerLiteralExp<EClassifier> il) {
if (il == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitIntegerLiteralExp(il);
}
@Override
public Object visitUnlimitedNaturalLiteralExp(UnlimitedNaturalLiteralExp<EClassifier> literalExp) {
if (literalExp == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitUnlimitedNaturalLiteralExp(literalExp);
}
@Override
public Object visitRealLiteralExp(RealLiteralExp<EClassifier> rl) {
if (rl == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitRealLiteralExp(rl);
}
@Override
public Object visitStringLiteralExp(StringLiteralExp<EClassifier> sl) {
if (sl == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitStringLiteralExp(sl);
}
@Override
public Object visitBooleanLiteralExp(BooleanLiteralExp<EClassifier> bl) {
if (bl == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitBooleanLiteralExp(bl);
}
@Override
public Object visitInvalidLiteralExp(InvalidLiteralExp<EClassifier> il) {
if (il == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitInvalidLiteralExp(il);
}
@Override
public Object visitNullLiteralExp(NullLiteralExp<EClassifier> il) {
if (il == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitNullLiteralExp(il);
}
@Override
public Object visitLetExp(LetExp<EClassifier, EParameter> l) {
if (l == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitLetExp(l);
}
@Override
public Object visitCollectionLiteralExp(CollectionLiteralExp<EClassifier> cl) {
if (cl == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitCollectionLiteralExp(cl);
}
@Override
public Object visitTupleLiteralExp(TupleLiteralExp<EClassifier, EStructuralFeature> tl) {
if (tl == sourceExpression) {
sourceExpression = null;
return valueOfSourceExpression;
}
return super.visitTupleLiteralExp(tl);
}
/**
* Does the same as the {@link AbstractEvaluationVisitor} implementation but additionally catches the
* {@link ValueNotFoundException} and in that case passes on the exception instead of turning it into an <tt>OclInvalid</tt>
* value.
*
* @param expression
* an OCL expression to evaluate
*
* @return the result of the evaluation
*/
@Override
public Object visitExpression(OCLExpression<EClassifier> expression) {
try {
return expression.accept(getVisitor());
} catch (EvaluationHaltedException e) {
// evaluation stopped on demand, propagate further
throw e;
} catch (ValueNotFoundException e) {
throw e;
} catch (RuntimeException e) {
String msg = e.getLocalizedMessage();
if (msg == null) {
msg = "(no message)";
}
ImpactAnalyzerPlugin.log(Diagnostic.ERROR, ImpactAnalyzerPlugin.IGNORED_EXCEPTION_WARNING,
"Evaluation failed with an exception: " + msg, e);
// failure to evaluate results in invalid
return getInvalid();
}
}
@SuppressWarnings("unchecked")
public Object visitOppositePropertyCallExp(OppositePropertyCallExp pc) {
if (pc == getSourceExpression()) {
setSourceExpression(null);
return getValueOfSourceExpression();
}
/*
* These are the sources of the super implementation copied here which is ugly. We only want to get access to the value of
* the source expression because it may be needed for the comparison with the atPre event later.
*
* TODO evaluate source expression here and cache the result before delegating to super.visitPropertyCallExp; when then
* super.visitPropertyCallExp asks the visitor to evaluate the source expression, the result is taken from the cache
*/
EReference property = pc.getReferredOppositeProperty();
OCLExpression<EClassifier> source = pc.getSource();
// evaluate source
Object context = source.accept(getVisitor());
Object localResult;
// if source is undefined, result is OclInvalid
if (isUndefined(context)) {
localResult = getInvalid();
} else {
// TODO consider introduction of derivation expressions also for opposite property; for now it's not supported
/* OCLExpression<EClassifier> derivation = getPropertyBody(property);
if (derivation != null) {
// this is an additional property
localResult = navigate(property, derivation, context);
} else {
*/
localResult = ((EvaluationEnvironmentWithHiddenOpposites) getEvaluationEnvironment()).navigateOppositeProperty(property, context);
if ((pc.getType() instanceof CollectionType<?, ?>) && !(localResult instanceof Collection<?>)) {
// this was an XSD "unspecified multiplicity". Now that we know what
// the multiplicity is, we can coerce it to a collection value
CollectionKind kind = ((CollectionType<EClassifier, EOperation>) pc.getType()).getKind();
Collection<Object> collection = CollectionUtil.createNewCollection(kind);
collection.add(localResult);
localResult = collection;
}
// }
}
// for @pre with opposite properties there can't be any ordering
if (getAtPre() != null
// the source of the opposite property call expression is the target of a normal EMF notification
// because the notification talks about a forward reference; the old and new value described by the
// event may be a collection of elements or a single element. Check if the source appears somewhere
// in the notification's old or new value:
&& ((getAtPre().getOldValue() != null && ((getAtPre().getOldValue() instanceof Collection<?> &&
((Collection<?>) getAtPre().getOldValue()).contains(context)) || getAtPre().getOldValue() == context))
|| (getAtPre().getNewValue() != null && ((getAtPre().getNewValue() instanceof Collection<?> &&
((Collection<?>) getAtPre().getNewValue()).contains(context)) || getAtPre().getNewValue() == context)))
&& pc.getReferredOppositeProperty() == getAtPre().getFeature()) {
// evaluate property call based on the model state that existed before the change
// described by the atPre notification
switch (getAtPre().getEventType()) {
case Notification.ADD:
case Notification.ADD_MANY:
// if the addition operated on the result of the source expression, remove the element from the local results
// again
((Collection<?>) localResult).remove(getAtPre().getNotifier());
break;
case Notification.MOVE:
// there is no ordering for opposite properties in Ecore; it's safe to ignore this notification
break;
case Notification.REMOVE:
case Notification.REMOVE_MANY:
// if the removal operated on the result of the source expression, add the element back at the index provided
((Collection<Object>) localResult).add(getAtPre().getNotifier());
break;
case Notification.SET:
case Notification.UNSET:
if (getAtPre().getOldValue() == context) {
// the notification tells that previously the source context was referenced by the notifier;
// re-add the notifier to the result:
((Collection<Object>) localResult).add(getAtPre().getNotifier());
} else if (getAtPre().getNewValue() == context) {
// the notification tells that after the change the source context is referenced by the notifier;
// remove the notifier from the result:
((Collection<Object>) localResult).remove(getAtPre().getNotifier());
}
break;
default:
throw new RuntimeException("Don't understand @pre notification " + getAtPre());
}
}
return localResult;
}
protected org.eclipse.ocl.ecore.OCLExpression getSourceExpression() {
return sourceExpression;
}
protected void setSourceExpression(org.eclipse.ocl.ecore.OCLExpression sourceExpression) {
this.sourceExpression = sourceExpression;
}
protected Object getValueOfSourceExpression() {
return valueOfSourceExpression;
}
protected Notification getAtPre() {
return atPre;
}
}