/*******************************************************************************
* Copyright (c) 2008-2011 Chair for Applied Software Engineering,
* Technische Universitaet Muenchen.
* 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:
******************************************************************************/
package org.eclipse.emf.emfstore.server.conflictDetection;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isAttribute;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isCreateDelete;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isMultiAtt;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isMultiAttMove;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isMultiAttSet;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isMultiRef;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isMultiRefSet;
import static org.eclipse.emf.emfstore.server.model.versioning.operations.util.OperationUtil.isSingleRef;
import java.util.HashSet;
import java.util.Set;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.emfstore.common.model.ModelElementId;
import org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.AttributeOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.CompositeOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.ContainmentType;
import org.eclipse.emf.emfstore.server.model.versioning.operations.CreateDeleteOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.FeatureOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.MultiAttributeMoveOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.MultiAttributeOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.MultiAttributeSetOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.MultiReferenceMoveOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.MultiReferenceOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.MultiReferenceSetOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.ReferenceOperation;
import org.eclipse.emf.emfstore.server.model.versioning.operations.SingleReferenceOperation;
/**
* A conflict detection strategy that will operate on a per attribute and feature level.
*
* @author chodnick
* @author wesendon
*/
// BEGIN COMPLEX CODE
public class IndexSensitiveConflictDetectionStrategy implements ConflictDetectionStrategy {
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.emfstore.server.conflictDetection.ConflictDetectionStrategy#doConflict(org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation,
* org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation)
*/
public boolean doConflict(AbstractOperation operationA, AbstractOperation operationB) {
if (operationA instanceof CompositeOperation) {
CompositeOperation compA = (CompositeOperation) operationA;
for (AbstractOperation op : compA.getSubOperations()) {
if (doConflict(op, operationB)) {
return true;
}
}
return false;
} else if (operationB instanceof CompositeOperation) {
CompositeOperation compB = (CompositeOperation) operationB;
for (AbstractOperation op : compB.getSubOperations()) {
if (doConflict(operationA, op)) {
return true;
}
}
return false;
}
return doConflictHard(operationA, operationB);
}
/**
* Hard conflicts change the toplogogy of the model element graph. This method returns, given the operations in
* question, whether such a conflict exists.
*
* @param operationA any operation
* @param operationB any operation
* @return true if topology of the resulting model element graph depends on serialization of operationA and
* operationB false otherwise
*/
private boolean doConflictHard(AbstractOperation operationA, AbstractOperation operationB) {
if (isCreateDelete(operationA)) {
return doConflictHardCreateDelete((CreateDeleteOperation) operationA, operationB);
}
if (isCreateDelete(operationB)) {
return doConflictHardCreateDelete((CreateDeleteOperation) operationB, operationA);
}
if (isAttribute(operationA) && isAttribute(operationB)) {
return doConflictHardAttributes((AttributeOperation) operationA, (AttributeOperation) operationB);
}
if (isMultiAtt(operationA) && isMultiAtt(operationB)) {
return doConflictHardMultiAttributes((MultiAttributeOperation) operationA,
(MultiAttributeOperation) operationB);
}
if (isMultiAttSet(operationA) && isMultiAttSet(operationB)) {
return doConflictHardMultiAttributeSets((MultiAttributeSetOperation) operationA,
(MultiAttributeSetOperation) operationB);
}
if (isMultiAttSet(operationA) && isMultiAtt(operationB)) {
return doConflictHardMultiAttAndSet((MultiAttributeOperation) operationB,
(MultiAttributeSetOperation) operationA);
}
if (isMultiAtt(operationA) && isMultiAttSet(operationB)) {
return doConflictHardMultiAttAndSet((MultiAttributeOperation) operationA,
(MultiAttributeSetOperation) operationB);
}
if (isMultiAttMove(operationA) && isMultiAttMove(operationB)) {
return doConflictHardMultiAttributeMoves((MultiAttributeMoveOperation) operationA,
(MultiAttributeMoveOperation) operationB);
}
if (isMultiAttMove(operationA) && isMultiAtt(operationB)) {
return doConflictHardMultiAttAndMove((MultiAttributeMoveOperation) operationA,
(MultiAttributeOperation) operationB);
}
if (isMultiAtt(operationA) && isMultiAttMove(operationB)) {
return doConflictHardMultiAttAndMove((MultiAttributeMoveOperation) operationB,
(MultiAttributeOperation) operationA);
}
if (isMultiAttSet(operationA) && isMultiAttMove(operationB)) {
return doConflictHardMultiAttMoveAndSet((MultiAttributeMoveOperation) operationB,
(MultiAttributeSetOperation) operationA);
}
if (isMultiAttMove(operationA) && isMultiAttSet(operationB)) {
return doConflictHardMultiAttMoveAndSet((MultiAttributeMoveOperation) operationA,
(MultiAttributeSetOperation) operationB);
}
if (isSingleRef(operationA) && isSingleRef(operationB)) {
return doConflictHardSingleReferences((SingleReferenceOperation) operationA,
(SingleReferenceOperation) operationB);
}
if (isSingleRef(operationA) && isMultiRef(operationB)) {
return doConflictHardSingleMultiReferences((SingleReferenceOperation) operationA,
(MultiReferenceOperation) operationB);
}
if (isMultiRef(operationA) && isSingleRef(operationB)) {
return doConflictHardSingleMultiReferences((SingleReferenceOperation) operationB,
(MultiReferenceOperation) operationA);
}
if (isSingleRef(operationA) && isMultiRefSet(operationB)) {
return doConflictHardSingeMultiSet((SingleReferenceOperation) operationA,
(MultiReferenceSetOperation) operationB);
}
if (isMultiRefSet(operationA) && isSingleRef(operationB)) {
return doConflictHardSingeMultiSet((SingleReferenceOperation) operationB,
(MultiReferenceSetOperation) operationA);
}
if (isMultiRef(operationA) && isMultiRefSet(operationB)) {
return doConflictHardMultiReferenceAndSet((MultiReferenceOperation) operationA,
(MultiReferenceSetOperation) operationB);
}
if (isMultiRefSet(operationA) && isMultiRef(operationB)) {
return doConflictHardMultiReferenceAndSet((MultiReferenceOperation) operationB,
(MultiReferenceSetOperation) operationA);
}
if (isMultiRefSet(operationA) && isMultiRefSet(operationB)) {
return doConflictHardMultiReferenceSet((MultiReferenceSetOperation) operationA,
(MultiReferenceSetOperation) operationB);
}
if (isMultiRef(operationA) && isMultiRef(operationB)) {
return doConflictHardMultiReferences((MultiReferenceOperation) operationA,
(MultiReferenceOperation) operationB);
}
return false;
}
private boolean doConflictHardSingeMultiSet(SingleReferenceOperation opA, MultiReferenceSetOperation opB) {
if (!bothContaining(opA, opB)) {
return false;
}
return (opA.getNewValue() != null && isSame(opA.getNewValue(), opB.getNewValue()));
}
private boolean doConflictHardMultiAttributeMoves(MultiAttributeMoveOperation operationA,
MultiAttributeMoveOperation operationB) {
// this is a soft conflict
return false;
}
private boolean doConflictHardMultiAttributeSets(MultiAttributeSetOperation operationA,
MultiAttributeSetOperation operationB) {
if (!sameFeatureAndId(operationA, operationB)) {
return false;
}
if (operationA.getIndex() == operationB.getIndex()
&& isDifferent(operationA.getNewValue(), operationB.getNewValue())) {
return true;
}
return false;
}
private boolean doConflictHardMultiReferenceSet(MultiReferenceSetOperation operationA,
MultiReferenceSetOperation operationB) {
if (sameFeatureAndId(operationA, operationB)) {
if (operationA.getIndex() == operationB.getIndex()
&& isDifferent(operationA.getNewValue(), operationB.getNewValue())) {
return true;
}
} else {
if (!bothContaining(operationA, operationB)) {
return false;
}
return isSame(operationA.getNewValue(), operationB.getNewValue());
}
return false;
}
private boolean doConflictHardMultiReferenceAndSet(MultiReferenceOperation operationA,
MultiReferenceSetOperation operationB) {
if (sameFeatureAndId(operationA, operationB)) {
if (!operationA.isAdd()) {
for (ModelElementId id : operationA.getReferencedModelElements()) {
if (id.equals(operationB.getOldValue())) {
return true;
}
}
}
} else {
if (!bothContaining(operationA, operationB)) {
return false;
}
if (!operationA.isAdd()) {
return false;
}
return containsId(operationA.getReferencedModelElements(), operationB.getNewValue());
}
return false;
}
private boolean doConflictHardMultiAttAndMove(MultiAttributeMoveOperation operationB,
MultiAttributeOperation operationA) {
if (!sameFeatureAndId(operationA, operationB)) {
return false;
}
int index = getLowestIndex(operationA.getIndexes());
if (index == -1) {
return false;
}
return (index <= operationB.getOldIndex() || index <= operationB.getNewIndex());
}
private boolean doConflictHardMultiAttMoveAndSet(MultiAttributeMoveOperation operationA,
MultiAttributeSetOperation operationB) {
if (!sameFeatureAndId(operationA, operationB)) {
return false;
}
if (between(operationB.getIndex(), operationA.getOldIndex(), operationA.getNewIndex())) {
return true;
}
return false;
}
private boolean doConflictHardMultiAttAndSet(MultiAttributeOperation operationB,
MultiAttributeSetOperation operationA) {
if (!sameFeatureAndId(operationA, operationB)) {
return false;
}
int index = getLowestIndex(operationB.getIndexes());
if (index == -1) {
return false;
}
return (index <= operationA.getIndex());
}
private boolean doConflictHardMultiAttributes(MultiAttributeOperation operationA, MultiAttributeOperation operationB) {
if (!sameFeatureAndId(operationA, operationB)) {
return false;
}
return true;
}
private boolean doConflictHardCreateDelete(CreateDeleteOperation opA, AbstractOperation opB) {
// creates do not conflict with anything, by definition
if (isCreateOperation(opA)) {
return false;
}
if (isCreateOperation(opB)) {
return false;
}
// we have a delete here
// we need to check whether the other operation changes any of the deleted elements
if (opB instanceof CreateDeleteOperation) {
Set<ModelElementId> allDeletedElementsA = getAllDeletedElements(opA);
Set<ModelElementId> allDeletedElementsB = getAllDeletedElements((CreateDeleteOperation) opB);
boolean intersecting = allDeletedElementsA.removeAll(allDeletedElementsB);
if (intersecting && !allDeletedElementsA.isEmpty()) {
return true;
}
return false;
} else {
for (ModelElementId m : getAllDeletedElements(opA)) {
if (changesModelElement(opB, m)) {
return true;
}
}
}
// we need to check whether the cross reference change do conflict with the other op
for (ReferenceOperation referenceOperation : opA.getSubOperations()) {
if (doConflictHard(referenceOperation, opB)) {
return true;
}
}
return false;
}
private Set<ModelElementId> getAllDeletedElements(CreateDeleteOperation op) {
// EObject element = op.getModelElement();
return new HashSet<ModelElementId>(op.getEObjectToIdMap().values());
// Set<EObject> allDeleteTreeElements = ModelUtil.getAllContainedModelElements(element, false);
// allDeleteTreeElements.add(op.getModelElement());
// Set<ModelElementId> result = new HashSet<ModelElementId>(allDeleteTreeElements.size());
// for (EObject modelElement : allDeleteTreeElements) {
// result.add(ModelUtil.getProject(modelElement).getModelElementId(modelElement));
// }
// return result;
}
private boolean doConflictHardMultiReferences(MultiReferenceOperation opA, MultiReferenceOperation opB) {
if (sameFeatureAndId(opA, opB)) {
// if add and remove meet, there might be a hard conflict
if (opA.isAdd() != opB.isAdd()) {
for (ModelElementId mA : opA.getOtherInvolvedModelElements()) {
for (ModelElementId mB : opB.getOtherInvolvedModelElements()) {
if (mA.equals(mB)) {
return true;
}
}
}
}
return false;
} else {
if (!bothContaining(opA, opB)) {
return false;
}
if (!(opA.isAdd() == opB.isAdd())) {
return false;
}
for (ModelElementId mA : opA.getOtherInvolvedModelElements()) {
for (ModelElementId mB : opB.getOtherInvolvedModelElements()) {
if (mA.equals(mB)) {
return true;
}
}
}
}
return false;
}
private boolean doConflictHardSingleMultiReferences(SingleReferenceOperation opA, MultiReferenceOperation opB) {
if (!bothContaining(opA, opB)) {
return false;
}
if (!opB.isAdd()) {
return false;
}
for (ModelElementId id : opB.getOtherInvolvedModelElements()) {
if (id.equals(opA.getNewValue())) {
return true;
}
}
return false;
}
private boolean doConflictHardSingleReferences(SingleReferenceOperation opA, SingleReferenceOperation opB) {
if (sameFeatureAndId(opA, opB)) {
// unless both operations set the same new value
if (isDifferent(opA.getNewValue(), opB.getNewValue())) {
return true;
}
return false;
} else {
if (!bothContaining(opA, opB)) {
return false;
}
return (opA.getNewValue() != null && isSame(opA.getNewValue(), opB.getNewValue()));
}
}
private boolean doConflictHardAttributes(AttributeOperation opA, AttributeOperation opB) {
// if same object's same feature is set, there's a potential conflict
if (sameFeatureAndId(opA, opB)) {
// unless both operations set the same new value
if (isSame(opA.getNewValue(), opB.getNewValue())) {
return false;
}
return true;
}
return false;
}
/**
* This method tests whether the both give operations change the same multifeature on the same object. If so, and
* additionally the order of items in the multifeature depends on the serialization of the operations, there is an
* index integrity conflict, and the method returns true. TODO: MultiAttribute and MultiReferenceSet operations only
* implemented for hard conflict.
*
* @param operationA any operation
* @param operationB any operation
* @return true if an index integrity conflict exists, false otherwise
*/
public boolean doConflictIndexIntegrity(AbstractOperation operationA, AbstractOperation operationB) {
if (operationA instanceof CompositeOperation) {
CompositeOperation compA = (CompositeOperation) operationA;
for (AbstractOperation op : compA.getSubOperations()) {
if (doConflictIndexIntegrity(op, operationB)) {
return true;
}
}
return false;
} else if (operationB instanceof CompositeOperation) {
CompositeOperation compB = (CompositeOperation) operationB;
for (AbstractOperation op : compB.getSubOperations()) {
if (doConflictIndexIntegrity(operationA, op)) {
return true;
}
}
return false;
}
if (operationA instanceof MultiReferenceOperation && operationB instanceof MultiReferenceOperation) {
return doConflictIndexIntegrityMultiReferences((MultiReferenceOperation) operationA,
(MultiReferenceOperation) operationB);
}
if (operationA instanceof SingleReferenceOperation && operationB instanceof MultiReferenceOperation) {
return doConflictIndexIntegritySingleMultiReferences((SingleReferenceOperation) operationA,
(MultiReferenceOperation) operationB);
}
if (operationB instanceof SingleReferenceOperation && operationA instanceof MultiReferenceOperation) {
return doConflictIndexIntegritySingleMultiReferences((SingleReferenceOperation) operationB,
(MultiReferenceOperation) operationA);
}
if (operationA instanceof MultiReferenceMoveOperation && operationB instanceof MultiReferenceMoveOperation) {
return doConflictIndexIntegrityMultiMoveReferences((MultiReferenceMoveOperation) operationA,
(MultiReferenceMoveOperation) operationB);
}
if (operationA instanceof MultiReferenceMoveOperation && operationB instanceof MultiReferenceOperation) {
return doConflictIndexIntegrityMultiMoveMultiReferences((MultiReferenceMoveOperation) operationA,
(MultiReferenceOperation) operationB);
}
if (operationB instanceof MultiReferenceMoveOperation && operationA instanceof MultiReferenceOperation) {
return doConflictIndexIntegrityMultiMoveMultiReferences((MultiReferenceMoveOperation) operationB,
(MultiReferenceOperation) operationA);
}
if (operationA instanceof MultiReferenceMoveOperation && operationB instanceof SingleReferenceOperation) {
return doConflictIndexIntegrityMultiMoveSingleReferences((MultiReferenceMoveOperation) operationA,
(SingleReferenceOperation) operationB);
}
if (operationB instanceof MultiReferenceMoveOperation && operationA instanceof SingleReferenceOperation) {
return doConflictIndexIntegrityMultiMoveSingleReferences((MultiReferenceMoveOperation) operationB,
(SingleReferenceOperation) operationA);
}
if (operationA instanceof SingleReferenceOperation && operationB instanceof SingleReferenceOperation) {
return doConflictIndexIntegritySingleReferences((SingleReferenceOperation) operationA,
(SingleReferenceOperation) operationB);
}
return false;
}
private boolean doConflictIndexIntegritySingleReferences(SingleReferenceOperation opA, SingleReferenceOperation opB) {
// Due to refactoring: The opposite case is covered by the second operation created by bidirectional links.
return false;
}
private boolean doConflictIndexIntegrityMultiMoveSingleReferences(MultiReferenceMoveOperation opA,
SingleReferenceOperation opB) {
// Due to refactoring: MultiMove only occurs on multifeatures, so it can't conflict with a single operation. The
// opposite case is covered by the second operation created by bidirectional links.
return false;
}
private boolean doConflictIndexIntegrityMultiMoveMultiReferences(MultiReferenceMoveOperation opA,
MultiReferenceOperation opB) {
// 2 cases
// regular vs. regular
// regular vs. opposite
// regular vs. regular
if (opA.getModelElementId().equals(opB.getModelElementId())
&& opA.getFeatureName().equals(opB.getFeatureName())) {
if (containsId(opB.getReferencedModelElements(), opA.getReferencedModelElementId())) {
if (opB.isAdd()) {
return true;
}
return false;
} else {
// so there is an add or remove and a move going on on different objects but on the same feature
if (opB.isAdd() && opB.getIndex() >= opA.getNewIndex()) {
return true;
} else if (!opB.isAdd()
&& (opB.getIndex() + opB.getReferencedModelElements().size() - 1) < opA.getNewIndex()) {
return true;
}
return false;
}
}
return false;
}
private boolean doConflictIndexIntegrityMultiMoveReferences(MultiReferenceMoveOperation opA,
MultiReferenceMoveOperation opB) {
if (opA.getModelElementId().equals(opB.getModelElementId())
&& opA.getFeatureName().equals(opB.getFeatureName())) {
if (opA.getReferencedModelElementId().equals(opB.getReferencedModelElementId())) {
return opA.getNewIndex() != opB.getNewIndex();
} else {
return opA.getNewIndex() == opB.getNewIndex();
}
}
return false;
}
private boolean doConflictIndexIntegritySingleMultiReferences(SingleReferenceOperation opA,
MultiReferenceOperation opB) {
return false;
}
private boolean doConflictIndexIntegrityMultiReferences(MultiReferenceOperation opA, MultiReferenceOperation opB) {
// 3 cases to look for
// regular vs. regular
// regular vs. opposite
// opposite vs. regular
// case 1: regular vs. regular
if (opA.getModelElementId().equals(opB.getModelElementId())
&& opA.getFeatureName().equals(opB.getFeatureName())) {
if (opA.isAdd() && opB.isAdd()) {
// make sure that some of the added things are different
if (opA.getIndex() == opB.getIndex()) {
for (ModelElementId mA : opA.getOtherInvolvedModelElements()) {
if (!containsId(opB.getOtherInvolvedModelElements(), mA)) {
return true;
}
}
for (ModelElementId mB : opB.getOtherInvolvedModelElements()) {
// if all were the same, this would be identical operations, thus no index conflict
if (!containsId(opA.getOtherInvolvedModelElements(), mB)) {
return true;
}
}
} else {
return true;
}
}
if (opA.isAdd() != opB.isAdd()) {
for (ModelElementId mA : opA.getOtherInvolvedModelElements()) {
if (!containsId(opB.getOtherInvolvedModelElements(), mA)) {
if (opB.getReferencedModelElements().size() == 1
&& opA.getReferencedModelElements().size() == 1) {
if (opA.isAdd()) {
return opA.getIndex() > opB.getIndex() && opA.getIndex() != 0 && opB.getIndex() != 0;
} else {
return opA.getIndex() < opB.getIndex() && opA.getIndex() != 0 && opB.getIndex() != 0;
}
} else {
return true;
}
}
}
for (ModelElementId mB : opB.getOtherInvolvedModelElements()) {
if (!containsId(opA.getOtherInvolvedModelElements(), mB)) {
if (opB.getReferencedModelElements().size() == 1
&& opA.getReferencedModelElements().size() == 1) {
if (opA.isAdd()) {
return opA.getIndex() > opB.getIndex() && opA.getIndex() != 0 && opB.getIndex() != 0;
} else {
return opA.getIndex() < opB.getIndex() && opA.getIndex() != 0 && opB.getIndex() != 0;
}
} else {
return true;
}
}
}
}
}
return false;
}
/**
* {@inheritDoc} TODO multiattribute and mulitreferenceset operations are not yet considerered
*
* @see org.eclipse.emf.emfstore.server.conflictDetection.ConflictDetectionStrategy#isRequired(org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation,
* org.eclipse.emf.emfstore.server.model.versioning.operations.AbstractOperation)
*/
public boolean isRequired(AbstractOperation requiredOperation, AbstractOperation operation) {
// composite operation decomposition section
if (requiredOperation instanceof CompositeOperation) {
CompositeOperation compA = (CompositeOperation) requiredOperation;
for (AbstractOperation op : compA.getSubOperations()) {
if (isRequired(op, operation)) {
return true;
}
}
return false;
} else if (operation instanceof CompositeOperation) {
CompositeOperation compB = (CompositeOperation) operation;
for (AbstractOperation op : compB.getSubOperations()) {
if (isRequired(requiredOperation, op)) {
return true;
}
}
return false;
}
// non-composite op handling
if (requiredOperation instanceof CreateDeleteOperation) {
return isRequiredCreate((CreateDeleteOperation) requiredOperation, operation);
} else if (requiredOperation instanceof MultiReferenceOperation
&& operation instanceof MultiReferenceMoveOperation) {
return isRequiredMultiByMoveReference((MultiReferenceOperation) requiredOperation,
(MultiReferenceMoveOperation) operation);
} else if (requiredOperation instanceof MultiReferenceOperation && operation instanceof MultiReferenceOperation) {
return isRequiredMutiByMultiReference((MultiReferenceOperation) requiredOperation,
(MultiReferenceOperation) operation);
} else if (requiredOperation instanceof SingleReferenceOperation
&& operation instanceof MultiReferenceMoveOperation) {
return isRequiredSingleByMoveReference((SingleReferenceOperation) requiredOperation,
(MultiReferenceMoveOperation) operation);
} else if (requiredOperation instanceof SingleReferenceOperation
&& operation instanceof MultiReferenceOperation) {
return isRequiredSingleByMultiReference((SingleReferenceOperation) requiredOperation,
(MultiReferenceOperation) operation);
}
return false;
}
private boolean isRequiredSingleByMultiReference(SingleReferenceOperation requiredOperation,
MultiReferenceOperation operation) {
return false;
}
private boolean isRequiredSingleByMoveReference(SingleReferenceOperation requiredOperation,
MultiReferenceMoveOperation operation) {
if (!requiredOperation.isBidirectional()) {
return false;
}
boolean sameFeature = requiredOperation.getOppositeFeatureName().equals(operation.getFeatureName());
boolean sameMovedElement = requiredOperation.getModelElementId()
.equals(operation.getReferencedModelElementId());
boolean sameElement = isSame(requiredOperation.getNewValue(), operation.getModelElementId());
return (sameElement && sameFeature && sameMovedElement);
}
private boolean isRequiredMutiByMultiReference(MultiReferenceOperation requiredOperation,
MultiReferenceOperation operation) {
return false;
}
private boolean isRequiredMultiByMoveReference(MultiReferenceOperation requiredOperation,
MultiReferenceMoveOperation operation) {
boolean sameElement = requiredOperation.getModelElementId().equals(operation.getModelElementId());
boolean sameFeature = requiredOperation.getFeatureName().equals(operation.getFeatureName());
// require the add of the element, that is moved around
if (sameElement && sameFeature) {
for (ModelElementId modelElementId : requiredOperation.getReferencedModelElements()) {
if (modelElementId.equals(operation.getReferencedModelElementId())) {
return true;
}
}
}
return false;
}
private boolean isRequiredCreate(CreateDeleteOperation requiredOperation, AbstractOperation operation) {
if (!requiredOperation.isDelete()) {
// in case of a delete, it only requires the create if the deleted element is created,
// creates of subelements in the deltree are not required
if (operation instanceof CreateDeleteOperation) {
CreateDeleteOperation op = (CreateDeleteOperation) operation;
if (op.isDelete() && op.getModelElementId().equals(requiredOperation.getModelElementId())) {
return true;
}
return false;
}
// in case of a single ref op, we don't need to require it if the create references the old value
if (operation instanceof SingleReferenceOperation) {
SingleReferenceOperation op = (SingleReferenceOperation) operation;
if (isSame(op.getOldValue(), requiredOperation.getModelElementId())) {
return false;
}
}
if (changesModelElement(operation, requiredOperation.getModelElementId())) {
return true;
}
}
return false;
}
// helper methods
private static boolean isDifferent(Object a, Object b) {
// if both are null, they are not different
if (a == null && b == null) {
return false;
}
// if either is null now, the other is not, so the objects ARE different
if (a == null || b == null) {
return true;
}
// if neither is null, let the objects sort out equality
return !a.equals(b);
}
private static boolean isSame(Object a, Object b) {
// if both are null, they are the same
if (a == null && b == null) {
return true;
}
// if either is null now, the other is not, so the objects ARE different
if (a == null || b == null) {
return false;
}
// if neither is null, let the objects sort out equality
return a.equals(b);
}
private boolean bothContaining(ReferenceOperation opA, ReferenceOperation opB) {
return ContainmentType.CONTAINMENT.equals(opA.getContainmentType())
&& ContainmentType.CONTAINMENT.equals(opB.getContainmentType());
}
private boolean sameFeatureAndId(FeatureOperation operationA, FeatureOperation operationB) {
return (isSame(operationA.getModelElementId(), operationB.getModelElementId()) && isSame(
operationA.getFeatureName(), operationB.getFeatureName()));
}
private boolean between(int index, int lower, int upper) {
if (lower > upper) {
return between(index, upper, lower);
}
return (lower <= index && index <= upper);
}
private int getLowestIndex(EList<Integer> indexes) {
int result = -1;
for (Integer tmp : indexes) {
if (result >= tmp || result == -1) {
result = tmp;
}
}
return result;
}
private static boolean isCreateOperation(AbstractOperation op) {
if (op instanceof CreateDeleteOperation) {
CreateDeleteOperation cdop = (CreateDeleteOperation) op;
return !cdop.isDelete();
}
return false;
}
private boolean containsId(Iterable<ModelElementId> list, ModelElementId id) {
for (ModelElementId m : list) {
if (m.equals(id)) {
return true;
}
}
return false;
}
/**
* Tests whether an operation changes a given model element.
*
* @param op the op to examine
* @param id the modelelement to check
* @return if the operation changes the given model element
*/
public static boolean changesModelElement(AbstractOperation op, ModelElementId id) {
for (ModelElementId m : op.getAllInvolvedModelElements()) {
if (m.equals(id)) {
return true;
}
}
return false;
}
// END COMPLEX CODE
}