package org.eclipse.bpel.compare.ui.gef.bpel;
/*******************************************************************************
* Copyright (c) 2006, 2012, 2008 Obeo.
* 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:
* Obeo - initial API and implementation
*******************************************************************************/
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.EMFPlugin;
import org.eclipse.emf.common.util.BasicMonitor;
import org.eclipse.emf.common.util.Monitor;
import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.compare.EMFComparePlugin;
import org.eclipse.emf.compare.FactoryException;
import org.eclipse.emf.compare.match.MatchOptions;
import org.eclipse.emf.compare.match.engine.IMatchEngine;
import org.eclipse.emf.compare.match.internal.statistic.NameSimilarity;
import org.eclipse.emf.compare.match.internal.statistic.StructureSimilarity;
import org.eclipse.emf.compare.match.metamodel.Match2Elements;
import org.eclipse.emf.compare.match.metamodel.Match3Elements;
import org.eclipse.emf.compare.match.metamodel.MatchElement;
import org.eclipse.emf.compare.match.metamodel.MatchFactory;
import org.eclipse.emf.compare.match.metamodel.MatchModel;
import org.eclipse.emf.compare.match.metamodel.Side;
import org.eclipse.emf.compare.match.metamodel.UnmatchElement;
import org.eclipse.emf.compare.match.statistic.MetamodelFilter;
import org.eclipse.emf.compare.util.EFactory;
import org.eclipse.emf.compare.util.EMFCompareMap;
import org.eclipse.emf.compare.util.EMFComparePreferenceConstants;
import org.eclipse.emf.compare.util.EclipseModelUtils;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.XMIResource;
/**
* These services are useful when one wants to compare models more precisely using the method modelDiff.
*
* @author <a href="mailto:cedric.brun@obeo.fr">Cedric Brun</a>
*/
public class BPELMatchEngine implements IMatchEngine {
//public class BPELMatchEngine extends GenericMatchEngine {
/** Used while computing similarity, this defines the general threshold. */
private static final double GENERAL_THRESHOLD = 0.96d;
/** Containmnent reference for the matched elements root. */
private static final String MATCH_ELEMENT_NAME = "matchedElements"; //$NON-NLS-1$
/**
* Minimal number of attributes an element must have for content comparison.
*/
private static final int MIN_ATTRIBUTES_COUNT = 5;
/** This constant is used as key for the buffering of name similarity. */
private static final char NAME_SIMILARITY = 'n';
/** This constant is used as key for the buffering of relations similarity. */
private static final char RELATION_SIMILARITY = 'r';
/** Containmnent reference for {@link MatchElement}s' submatches. */
private static final String SUBMATCH_ELEMENT_NAME = "subMatchElements"; //$NON-NLS-1$
/** This constant is used as key for the buffering of type similarity. */
private static final char TYPE_SIMILARITY = 't';
/** Containmnent reference for the {@link MatchModel}'s unmatched elements. */
private static final String UNMATCH_ELEMENT_NAME = "unmatchedElements"; //$NON-NLS-1$
/** This constant is used as key for the buffering of value similarity. */
private static final char VALUE_SIMILARITY = 'v';
/**
* {@link MetamodelFilter} used for filtering unused features of the objects we're computing the
* similarity for.
*/
protected final MetamodelFilter filter = new MetamodelFilter();
/** Contains the options given to the match procedure. */
protected final Map<String, Object> options = new EMFCompareMap<String, Object>();
/**
* This map allows us memorize the {@link EObject} we've been able to match thanks to their functional ID.
*/
private final Map<String, EObject> matchedByID = new EMFCompareMap<String, EObject>();
/**
* This map allows us memorize the {@link EObject} we've been able to match thanks to their XMI ID.
*/
private final Map<String, EObject> matchedByXMIID = new EMFCompareMap<String, EObject>();
/**
* This map is used to cache the comparison results Pair(Element1, Element2) => [nameSimilarity,
* valueSimilarity, relationSimilarity, TypeSimilarity].
*/
private final Map<String, Double> metricsCache = new EMFCompareMap<String, Double>();
/**
* This list allows us to memorize the unMatched elements for a three-way comparison.<br/>
* <p>
* More specifically, we will populate this list with the {@link UnmatchElement}s created by the
* comparison between the left and the ancestor model, followed by the {@link UnmatchElement} created by
* the comparison between the right and the ancestor model.<br/> Those {@link UnmatchElement} will then
* be filtered to retain only those that actually cannot be matched.
* </p>
*/
private final Set<EObject> remainingUnMatchedElements = new HashSet<EObject>();
/**
* This list will be intensively used while matching elements to keep track of the unmatched ones from the
* left model.
*/
private final List<EObject> stillToFindFromModel1 = new ArrayList<EObject>();
/**
* This list will be intensively used while matching elements to keep track of the unmatched ones from the
* right model.
*/
private final List<EObject> stillToFindFromModel2 = new ArrayList<EObject>();
/**
* The options map must be initialized to avoid potential NPEs. This initializer will take care of this
* issue.
*/
{
options.putAll(loadPreferenceOptionMap());
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#contentMatch(org.eclipse.emf.ecore.EObject,
* org.eclipse.emf.ecore.EObject, org.eclipse.emf.ecore.EObject, java.util.Map)
*/
public MatchModel contentMatch(EObject leftObject, EObject rightObject, EObject ancestor,
Map<String, Object> optionMap) {
final MatchModel root = MatchFactory.eINSTANCE.createMatchModel();
setModelRoots(root, leftObject.eResource(), rightObject.eResource(), ancestor.eResource());
final Monitor monitor = createProgressMonitor();
final MatchModel leftObjectAncestorMatch = contentMatch(leftObject, ancestor, optionMap);
final MatchModel rightObjectAncestorMatch = contentMatch(rightObject, ancestor, optionMap);
final List<MatchElement> leftObjectMatchedElements = new ArrayList<MatchElement>(
leftObjectAncestorMatch.getMatchedElements());
final List<MatchElement> rightObjectMatchedElements = new ArrayList<MatchElement>(
rightObjectAncestorMatch.getMatchedElements());
// populates the unmatched elements list for later use
for (Object unMatch : leftObjectAncestorMatch.getUnmatchedElements())
remainingUnMatchedElements.add(((UnmatchElement)unMatch).getElement());
for (Object unMatch : rightObjectAncestorMatch.getUnmatchedElements())
remainingUnMatchedElements.add(((UnmatchElement)unMatch).getElement());
try {
Match3Elements subMatchRoot = null;
if (leftObjectMatchedElements.size() > 0 && rightObjectMatchedElements.size() > 0) {
final Match2Elements leftObjectMatchRoot = (Match2Elements)leftObjectMatchedElements.get(0);
final Match2Elements rightObjectMatchRoot = (Match2Elements)rightObjectMatchedElements.get(0);
subMatchRoot = MatchFactory.eINSTANCE.createMatch3Elements();
subMatchRoot.setSimilarity(absoluteMetric(leftObjectMatchRoot.getLeftElement(),
rightObjectMatchRoot.getLeftElement(), rightObjectMatchRoot.getRightElement()));
subMatchRoot.setLeftElement(leftObjectMatchRoot.getLeftElement());
subMatchRoot.setRightElement(rightObjectMatchRoot.getLeftElement());
subMatchRoot.setOriginElement(rightObjectMatchRoot.getRightElement());
redirectedAdd(root, MATCH_ELEMENT_NAME, subMatchRoot);
createSub3Match(root, subMatchRoot, leftObjectMatchRoot, rightObjectMatchRoot);
} else {
for (EObject left : leftObjectMatchedElements)
stillToFindFromModel1.add(left);
for (EObject right : rightObjectMatchedElements)
stillToFindFromModel2.add(right);
}
// We will now check through the unmatched object for matches.
processUnmatchedElements(root, subMatchRoot);
// #createSub3Match(MatchModel, Match3Element, Match2Elements,
// Match2Elements) will have updated "remainingUnMatchedElements"
final Set<EObject> remainingLeft = new HashSet<EObject>();
final Set<EObject> remainingRight = new HashSet<EObject>();
for (EObject unMatched : remainingUnMatchedElements) {
if (unMatched.eResource() == leftObject.eResource()) {
remainingLeft.add(unMatched);
final TreeIterator<EObject> iterator = unMatched.eAllContents();
while (iterator.hasNext())
remainingLeft.add(iterator.next());
} else if (unMatched.eResource() == rightObject.eResource()) {
remainingRight.add(unMatched);
final TreeIterator<EObject> iterator = unMatched.eAllContents();
while (iterator.hasNext())
remainingRight.add(iterator.next());
}
}
stillToFindFromModel1.clear();
stillToFindFromModel2.clear();
final List<Match2Elements> mappings = mapLists(new ArrayList<EObject>(remainingLeft),
new ArrayList<EObject>(remainingRight), this
.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW), monitor);
for (Match2Elements map : mappings) {
final Match3Elements subMatch = MatchFactory.eINSTANCE.createMatch3Elements();
subMatch.setLeftElement(map.getLeftElement());
subMatch.setRightElement(map.getRightElement());
if (subMatchRoot == null)
redirectedAdd(root, MATCH_ELEMENT_NAME, subMatch);
else
redirectedAdd(subMatchRoot, SUBMATCH_ELEMENT_NAME, subMatch);
}
final Map<EObject, Boolean> unMatchedElements = new EMFCompareMap<EObject, Boolean>();
for (EObject remoteUnMatch : stillToFindFromModel1) {
unMatchedElements.put(remoteUnMatch, true);
}
for (EObject unMatch : stillToFindFromModel2) {
unMatchedElements.put(unMatch, false);
}
createThreeWayUnmatchElements(root, unMatchedElements);
} catch (FactoryException e) {
EMFComparePlugin.log(e, false);
} catch (InterruptedException e) {
// Cannot be thrown since we have no monitor
}
return root;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#contentMatch(org.eclipse.emf.ecore.EObject,
* org.eclipse.emf.ecore.EObject, java.util.Map)
*/
public MatchModel contentMatch(EObject leftObject, EObject rightObject, Map<String, Object> optionMap) {
if (optionMap != null && optionMap.size() > 0)
loadOptionMap(optionMap);
final Monitor monitor = createProgressMonitor();
final MatchModel root = MatchFactory.eINSTANCE.createMatchModel();
setModelRoots(root, leftObject.eResource(), rightObject.eResource());
/*
* As we could very well be passed two EClasses (as opposed to modelMatch which compares all roots of
* a resource), we cannot filter the model.
*/
final Set<EObject> still1 = new HashSet<EObject>();
final Set<EObject> still2 = new HashSet<EObject>();
// navigate through both objects at the same time and realize mappings..
try {
if (!this.<Boolean> getOption(MatchOptions.OPTION_IGNORE_XMI_ID))
matchByXMIID(leftObject, rightObject);
if (!this.<Boolean> getOption(MatchOptions.OPTION_IGNORE_ID))
matchByID(leftObject, rightObject);
if (isSimilar(leftObject, rightObject)) {
stillToFindFromModel1.clear();
stillToFindFromModel2.clear();
final Match2Elements matchModelRoot = recursiveMappings(leftObject, rightObject, monitor);
redirectedAdd(root, MATCH_ELEMENT_NAME, matchModelRoot);
createSubMatchElements(matchModelRoot, new ArrayList<EObject>(stillToFindFromModel1),
new ArrayList<EObject>(stillToFindFromModel2), monitor);
still1.addAll(stillToFindFromModel1);
still2.addAll(stillToFindFromModel2);
createUnmatchElements(root, still1, Side.LEFT);
createUnmatchElements(root, still2, Side.RIGHT);
} else {
// The two objects passed as this method's parameters are not
// similar. Creates unmatch root.
still1.add(leftObject);
still1.add(rightObject);
createUnmatchElements(root, still1, null);
}
} catch (FactoryException e) {
EMFComparePlugin.log(e, false);
} catch (InterruptedException e) {
// Cannot be thrown since we have no monitor
}
return root;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#modelMatch(org.eclipse.emf.ecore.EObject,
* org.eclipse.emf.ecore.EObject, org.eclipse.emf.ecore.EObject, java.util.Map)
*/
public MatchModel modelMatch(EObject leftRoot, EObject rightRoot, EObject ancestor,
Map<String, Object> optionMap) throws InterruptedException {
if (optionMap != null && optionMap.size() > 0)
loadOptionMap(optionMap);
MatchModel result = null;
// Creates and sizes progress monitor
final Monitor monitor = createProgressMonitor();
int size = 1;
for (EObject root : leftRoot.eResource().getContents()) {
final Iterator<EObject> rootContent = root.eAllContents();
while (rootContent.hasNext()) {
rootContent.next();
size++;
}
}
startMonitor(monitor, size * 2);
result = doMatch(leftRoot.eResource(), rightRoot.eResource(), ancestor.eResource(), monitor);
return result;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#modelMatch(org.eclipse.emf.ecore.EObject,
* org.eclipse.emf.ecore.EObject, java.util.Map)
*/
public MatchModel modelMatch(EObject leftRoot, EObject rightRoot, Map<String, Object> optionMap)
throws InterruptedException {
if (optionMap != null && optionMap.size() > 0)
loadOptionMap(optionMap);
MatchModel result = null;
// Creates and sizes progress monitor
final Monitor monitor = createProgressMonitor();
int size = 1;
for (EObject root : leftRoot.eResource().getContents()) {
final Iterator<EObject> rootContent = root.eAllContents();
while (rootContent.hasNext()) {
rootContent.next();
size++;
}
}
startMonitor(monitor, size);
result = doMatch(leftRoot.eResource(), rightRoot.eResource(), monitor);
return result;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#reset()
*/
public void reset() {
filter.clear();
options.clear();
matchedByID.clear();
matchedByXMIID.clear();
metricsCache.clear();
remainingUnMatchedElements.clear();
stillToFindFromModel1.clear();
stillToFindFromModel2.clear();
options.putAll(loadPreferenceOptionMap());
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#resourceMatch(org.eclipse.emf.ecore.resource.Resource,
* org.eclipse.emf.ecore.resource.Resource, java.util.Map)
*/
public MatchModel resourceMatch(Resource leftResource, Resource rightResource,
Map<String, Object> optionMap) throws InterruptedException {
if (optionMap != null && optionMap.size() > 0)
loadOptionMap(optionMap);
MatchModel result = null;
// Creates and sizes progress monitor
final Monitor monitor = createProgressMonitor();
int size = 1;
for (EObject root : leftResource.getContents()) {
final Iterator<EObject> rootContent = root.eAllContents();
while (rootContent.hasNext()) {
rootContent.next();
size++;
}
}
startMonitor(monitor, size);
result = doMatch(leftResource, rightResource, monitor);
return result;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#resourceMatch(org.eclipse.emf.ecore.resource.Resource,
* org.eclipse.emf.ecore.resource.Resource, org.eclipse.emf.ecore.resource.Resource, java.util.Map)
*/
public MatchModel resourceMatch(Resource leftResource, Resource rightResource, Resource ancestorResource,
Map<String, Object> optionMap) throws InterruptedException {
if (optionMap != null && optionMap.size() > 0)
loadOptionMap(optionMap);
MatchModel result = null;
// Creates and sizes progress monitor
final Monitor monitor = createProgressMonitor();
int size = 1;
for (EObject root : leftResource.getContents()) {
final Iterator<EObject> rootContent = root.eAllContents();
while (rootContent.hasNext()) {
rootContent.next();
size++;
}
}
startMonitor(monitor, size * 2);
result = doMatch(leftResource, rightResource, ancestorResource, monitor);
return result;
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#resourceSetMatch(org.eclipse.emf.ecore.resource.ResourceSet,
* org.eclipse.emf.ecore.resource.ResourceSet, java.util.Map)
*/
public MatchModel resourceSetMatch(ResourceSet leftResourceSet, ResourceSet rightResourceSet,
Map<String, Object> optionMap) {
// TODO this should be implemented. It will break both match and diff
// MMs so wait till 0.9/1.0.
throw new UnsupportedOperationException("Not implemented yet."); //$NON-NLS-1$
}
/**
* {@inheritDoc}
*
* @see org.eclipse.emf.compare.match.api.IMatchEngine#resourceSetMatch(org.eclipse.emf.ecore.resource.ResourceSet,
* org.eclipse.emf.ecore.resource.ResourceSet, org.eclipse.emf.ecore.resource.ResourceSet,
* java.util.Map)
*/
public MatchModel resourceSetMatch(ResourceSet leftResourceSet, ResourceSet rightResourceSet,
ResourceSet ancestorResourceSet, Map<String, Object> optionMap) {
// TODO this should be implemented. It will break both match and diff
// MMs so wait till 0.9/1.0.
throw new UnsupportedOperationException("Not implemented yet."); //$NON-NLS-1$
}
/**
* This will compute the similarity between two {@link EObject}s' contents.
*
* @param obj1
* First of the two {@link EObject}s.
* @param obj2
* Second of the two {@link EObject}s.
* @return <code>double</code> representing the similarity between the two {@link EObject}s' contents.
* 0 < value < 1.
* @throws FactoryException
* Thrown if we cannot compute the {@link EObject}s' contents similarity metrics.
* @see NameSimilarity#contentValue(EObject, MetamodelFilter)
*/
protected double contentSimilarity(EObject obj1, EObject obj2) throws FactoryException {
double similarity = 0d;
final Double value = getSimilarityFromCache(obj1, obj2, VALUE_SIMILARITY);
if (value != null) {
similarity = value;
} else {
similarity = NameSimilarity.nameSimilarityMetric(NameSimilarity.contentValue(obj1, filter),
NameSimilarity.contentValue(obj2, filter));
setSimilarityInCache(obj1, obj2, VALUE_SIMILARITY, similarity);
}
return similarity;
}
/**
* This will iterate through the given {@link List} and return its element which is most similar (as given
* by {@link #absoluteMetric(EObject, EObject)}) to the given {@link EObject}.
*
* @param eObj
* {@link EObject} we're searching a similar item for in the list.
* @param list
* {@link List} in which we are to find an object similar to <code>eObj</code>.
* @return The element from <code>list</code> which is the most similar to <code>eObj</code>.
* @throws FactoryException
* Thrown if we cannot compute the {@link #absoluteMetric(EObject, EObject) absolute metric}
* between <code>eObj</code> and one of the list's objects.
*/
protected EObject findMostSimilar(EObject eObj, List<EObject> list) throws FactoryException {
double max = 0d;
EObject resultObject = null;
final Iterator<EObject> it = list.iterator();
while (it.hasNext() && max != 1.0d) {
final EObject next = it.next();
if (this.<Boolean> getOption(MatchOptions.OPTION_DISTINCT_METAMODELS)
|| eObj.eClass() == next.eClass()) {
final double similarity = absoluteMetric(eObj, next);
if (similarity > max) {
max = similarity;
resultObject = next;
}
}
}
return resultObject;
}
/**
* This will return the value associated to the given key in the options map.
* <p>
* NOTE : Misuses of this method will easily throw {@link ClassCastException}s.
* </p>
*
* @param <T>
* Expected type of the value associated to <code>key</code>.
* @param key
* Key of the value to retrieve.
* @return Value associated to the given key in the options map.
* @throws ClassCastException
* If the value isn't assignment compatible with the expected type.
*/
@SuppressWarnings("unchecked")
protected <T> T getOption(String key) throws ClassCastException {
return (T)options.get(key);
}
/**
* This will lookup in the {@link #matchedByID} map and check if the two given objects have indeed been
* matched by their ID.
*
* @param left
* Left of the two objects to check.
* @param right
* right of the two objects to check.
* @return <code>True</code> these objects haven't been matched by their ID, <code>False</code>
* otherwise.
* @throws FactoryException
* Thrown if we cannot compute the key for the object to match.
*/
protected boolean haveDistinctID(EObject left, EObject right) throws FactoryException {
boolean result = false;
final StringBuilder leftKey = new StringBuilder();
leftKey.append(NameSimilarity.findName(left));
leftKey.append(left.hashCode());
final EObject matched = matchedByID.get(leftKey.toString());
// must be the same instance
if (matched != null)
result = matched != right;
else
// we didn't match a single element with this ID.
// This could be because no IDs are defined.
result = EcoreUtil.getID(left) != null;
return result;
}
/**
* This will lookup in the {@link #matchedByXMIID} map and check if the two given objects have indeed been
* matched by their XMI ID.
*
* @param left
* Left of the two objects to check.
* @param right
* right of the two objects to check.
* @return <code>True</code> these objects haven't been matched by their XMI ID, <code>False</code>
* otherwise.
* @throws FactoryException
* Thrown if we cannot compute the key for the object to match.
*/
protected boolean haveDistinctXMIID(EObject left, EObject right) throws FactoryException {
boolean result = false;
final StringBuilder leftKey = new StringBuilder();
leftKey.append(NameSimilarity.findName(left));
leftKey.append(left.hashCode());
final EObject matched = matchedByXMIID.get(leftKey.toString());
// must be the same instance
if (matched != null)
result = matched != right;
else
// we didn't match a single element with this ID.
// This could be because no IDs are defined.
result = left.eResource() instanceof XMIResource
&& ((XMIResource)left.eResource()).getID(left) != null;
return result;
}
/**
* Returns <code>True</code> if the 2 given {@link EObject}s are considered similar.
*
* @param obj1
* The first {@link EObject} to compare.
* @param obj2
* Second of the {@link EObject}s to compare.
* @return <code>True</code> if both elements have the same serialization ID, <code>False</code>
* otherwise.
* @throws FactoryException
* Thrown if we cannot compute one of the needed similarity.
*/
protected boolean isSimilar(EObject obj1, EObject obj2) throws FactoryException {
boolean similar = false;
// Defines threshold constants to assume objects' similarity
final double nameOnlyMetricThreshold = 0.7d;
final double fewerAttributesNameThreshold = 0.8d;
final double relationsThreshold = 0.3d;
final double nameThreshold = 0.2d;
final double contentThreshold = 0.9d;
final double triWayThreshold = 0.9d;
final double generalThreshold = GENERAL_THRESHOLD;
// Computes some of the required metrics
final double nameSimilarity = nameSimilarity(obj1, obj2);
final boolean hasSameUri = hasSameUri(obj1, obj2);
final int obj1NonNullFeatures = nonNullFeaturesCount(obj1);
final int obj2NonNullFeatures = nonNullFeaturesCount(obj2);
if (!this.<Boolean> getOption(MatchOptions.OPTION_DISTINCT_METAMODELS)
&& obj1.eClass() != obj2.eClass()) {
similar = false;
} else if (!this.<Boolean> getOption(MatchOptions.OPTION_IGNORE_ID) && haveDistinctID(obj1, obj2)) {
similar = false;
} else if (!this.<Boolean> getOption(MatchOptions.OPTION_IGNORE_XMI_ID)
&& haveDistinctXMIID(obj1, obj2)) {
similar = false;
} else if (nameSimilarity == 1) {
similar = true;
// softer tests if we don't have enough attributes to compare the
// objects
} else if (obj1NonNullFeatures == 1 && obj2NonNullFeatures == 1) {
similar = nameSimilarity > nameOnlyMetricThreshold;
} else if (nameSimilarity > fewerAttributesNameThreshold
&& obj1NonNullFeatures <= MIN_ATTRIBUTES_COUNT && obj2NonNullFeatures <= MIN_ATTRIBUTES_COUNT
&& typeSimilarity(obj1, obj2) > generalThreshold) {
similar = true;
} else {
final double contentSimilarity = contentSimilarity(obj1, obj2);
final double relationsSimilarity = relationsSimilarity(obj1, obj2);
if (relationsSimilarity == 1 && hasSameUri && nameSimilarity > nameThreshold) {
similar = true;
} else if (contentSimilarity == 1 && relationsSimilarity == 1) {
similar = true;
} else if (contentSimilarity > generalThreshold && relationsSimilarity > relationsThreshold
&& nameSimilarity > nameThreshold) {
similar = true;
} else if (relationsSimilarity > generalThreshold && contentSimilarity > contentThreshold) {
similar = true;
} else if (contentSimilarity > triWayThreshold && nameSimilarity > triWayThreshold
&& relationsSimilarity > triWayThreshold) {
similar = true;
} else if (contentSimilarity > generalThreshold && nameSimilarity > generalThreshold
&& typeSimilarity(obj1, obj2) > generalThreshold) {
similar = true;
}
}
return similar;
}
/**
* This will compute the similarity between two {@link EObject}s' names.
*
* @param obj1
* First of the two {@link EObject}s.
* @param obj2
* Second of the two {@link EObject}s.
* @return <code>double</code> representing the similarity between the two {@link EObject}s' names. 0
* < value < 1.
* @see NameSimilarity#nameSimilarityMetric(String, String)
*/
protected double nameSimilarity(EObject obj1, EObject obj2) {
double similarity = 0d;
try {
final Double value = getSimilarityFromCache(obj1, obj2, NAME_SIMILARITY);
if (value != null) {
similarity = value;
} else {
similarity = NameSimilarity.nameSimilarityMetric(NameSimilarity.findName(obj1),
NameSimilarity.findName(obj2));
setSimilarityInCache(obj1, obj2, NAME_SIMILARITY, similarity);
}
} catch (FactoryException e) {
// fails silently, will return a similarity of 0d
}
return similarity;
}
/*
* created as package visibility method to allow access from initializer's listener. Shouldn't be further
* opened.
*/
/**
* This will load all the needed options with their default values.
*
* @return Map containing all the needed options with their default values.
*/
/* package */Map<String, Object> loadPreferenceOptionMap() {
final Map<String, Object> optionMap = new EMFCompareMap<String, Object>(17);
optionMap.put(MatchOptions.OPTION_SEARCH_WINDOW, getPreferenceSearchWindow());
optionMap.put(MatchOptions.OPTION_IGNORE_ID, getPreferenceIgnoreID());
optionMap.put(MatchOptions.OPTION_IGNORE_XMI_ID, getPreferenceIgnoreXMIID());
optionMap.put(MatchOptions.OPTION_DISTINCT_METAMODELS, getPreferenceDistinctMetaModel());
optionMap.put(MatchOptions.OPTION_PROGRESS_MONITOR, null);
return optionMap;
}
/**
* Returns an absolute comparison metric between the two given {@link EObject}s.
*
* @param obj1
* The first {@link EObject} to compare.
* @param obj2
* Second of the {@link EObject}s to compare.
* @return An absolute comparison metric. 0 < value < 1.
* @throws FactoryException
* Thrown if we cannot compute the content similarity.
*/
private double absoluteMetric(EObject obj1, EObject obj2) throws FactoryException {
final double nameSimilarity = nameSimilarity(obj1, obj2);
if (nameSimilarity == 1.0d) {
return 1.0;
}
final double relationsSimilarity = relationsSimilarity(obj1, obj2);
double sameUri = 0d;
if (hasSameUri(obj1, obj2))
sameUri = 1;
final double positionSimilarity = relationsSimilarity / 2d + sameUri / 2d;
final double contentWeight = 0.5d;
if (nonNullFeaturesCount(obj1) > MIN_ATTRIBUTES_COUNT
&& nonNullFeaturesCount(obj2) > MIN_ATTRIBUTES_COUNT) {
final double nameWeight = 0.8d;
final double positionWeight = 0.4d;
final double contentSimilarity = contentSimilarity(obj1, obj2);
// Computing type similarity really is time expensive
// double typeSimilarity = typeSimilarity(obj1, obj2);
return (contentSimilarity * contentWeight + nameSimilarity * nameWeight + positionSimilarity
* positionWeight)
/ (contentWeight + nameWeight + positionWeight);
}
// we didn't have enough features to compute an accurate metric
final double nameWeight = 0.4d;
final double positionWeight = 0.2d;
return (nameSimilarity * nameWeight + positionSimilarity * positionWeight)
/ (nameWeight + positionWeight);
}
/**
* Returns an absolute comparison metric between the three given {@link EObject}s.
*
* @param obj1
* The first {@link EObject} to compare.
* @param obj2
* Second of the {@link EObject}s to compare.
* @param obj3
* Second of the {@link EObject}s to compare.
* @return An absolute comparison metric
* @throws FactoryException
* Thrown if we cannot compute the content similarity.
*/
private double absoluteMetric(EObject obj1, EObject obj2, EObject obj3) throws FactoryException {
final double metric1 = absoluteMetric(obj1, obj2);
final double metric2 = absoluteMetric(obj1, obj3);
final double metric3 = absoluteMetric(obj2, obj3);
return (metric1 + metric2 + metric3) / 3;
}
/**
* This will recursively create three-way submatches and add them under the given {@link MatchModel}. The
* two {@link Match2Elements} we consider as parameters are the result of the two-way comparisons between :
* <ul>
* <li>The left and origin model.</li>
* <li>The right and origin model.</li>
* </ul>
* <br/><br/>We can then consider that a {@link Match3Element} would be :
*
* <pre>
* match.leftElement = left.getLeftElement();
* match.originElement = left.getRightElement() = right.getRightElement();
* match.rightElement = right.getLeftElement();
* </pre>
*
* @param root
* {@link MatchModel} under which to add our {@link Match3Element}s.
* @param matchElementRoot
* Root of the {@link Match3Element}s' hierarchy for the current element to be created.
* @param left
* Left {@link Match2Elements} to consider.
* @param right
* Right {@link Match2Elements} to consider.
* @throws FactoryException
* Thrown if we cannot compute the {@link #absoluteMetric(EObject, EObject, EObject) absolute
* metric} between the three elements or if we cannot add a {@link Match3Element} under the
* given <code>matchElementRoot</code>.
*/
private void createSub3Match(MatchModel root, Match3Elements matchElementRoot, Match2Elements left,
Match2Elements right) throws FactoryException {
final List<MatchElement> leftSubMatches = left.getSubMatchElements();
final List<MatchElement> rightSubMatches = right.getSubMatchElements();
final List<MatchElement> leftNotFound = new ArrayList<MatchElement>(leftSubMatches);
final List<MatchElement> rightNotFound = new ArrayList<MatchElement>(rightSubMatches);
for (MatchElement nextLeft : leftSubMatches) {
final Match2Elements nextLeftMatch = (Match2Elements)nextLeft;
Match2Elements correspondingMatch = null;
for (MatchElement nextRight : rightNotFound) {
final Match2Elements nextRightMatch = (Match2Elements)nextRight;
if (nextRightMatch.getRightElement().equals(nextLeftMatch.getRightElement())) {
correspondingMatch = nextRightMatch;
break;
}
}
if (correspondingMatch != null) {
final Match3Elements match = MatchFactory.eINSTANCE.createMatch3Elements();
match.setSimilarity(absoluteMetric(nextLeftMatch.getLeftElement(), correspondingMatch
.getLeftElement(), correspondingMatch.getRightElement()));
match.setLeftElement(nextLeftMatch.getLeftElement());
match.setRightElement(correspondingMatch.getLeftElement());
match.setOriginElement(correspondingMatch.getRightElement());
redirectedAdd(matchElementRoot, SUBMATCH_ELEMENT_NAME, match);
createSub3Match(root, matchElementRoot, nextLeftMatch, correspondingMatch);
leftNotFound.remove(nextLeftMatch);
rightNotFound.remove(correspondingMatch);
}
}
for (MatchElement nextLeftNotFound : leftNotFound) {
stillToFindFromModel1.add(nextLeftNotFound);
}
for (MatchElement nextRightNotFound : rightNotFound) {
stillToFindFromModel2.add(nextRightNotFound);
}
}
/**
* Creates the {@link Match2Elements submatch elements} corresponding to the mapping of objects from the
* two given {@link List}s.
*
* @param root
* Root of the {@link MatchModel} where to insert all these mappings.
* @param list1
* First of the lists used to compute mapping.
* @param list2
* Second of the lists used to compute mapping.
* @param monitor
* {@link CompareProgressMonitor progress monitor} to display while the comparison lasts. Might
* be <code>null</code>, in which case we won't monitor progress.
* @throws FactoryException
* Thrown if we cannot match the elements of the two lists or add submatch elements to
* <code>root</code>.
* @throws InterruptedException
* Thrown if the operation is cancelled or fails somehow.
*/
private void createSubMatchElements(EObject root, List<EObject> list1, List<EObject> list2,
Monitor monitor) throws FactoryException, InterruptedException {
stillToFindFromModel1.clear();
stillToFindFromModel2.clear();
final List<Match2Elements> mappings = mapLists(list1, list2, this
.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW), monitor);
final Iterator<Match2Elements> it = mappings.iterator();
while (it.hasNext()) {
final Match2Elements map = it.next();
final Match2Elements match = recursiveMappings(map.getLeftElement(), map.getRightElement(),
monitor);
redirectedAdd(root, SUBMATCH_ELEMENT_NAME, match);
}
}
/**
* Creates {@link UnmatchElement}s and {@link RemoteUnmatchElement}s wrapped around all the elements of
* the given {@link List}.
*
* @param root
* Root of the {@link MatchModel} under which to insert all these elements.
* @param unMatchedElements
* {@link List} containing all the elements we haven't been able to match.
* @throws FactoryException
* Thrown if we cannot add elements under the given {@link MatchModel root}.
*/
private void createThreeWayUnmatchElements(MatchModel root, Map<EObject, Boolean> unMatchedElements)
throws FactoryException {
for( Map.Entry<EObject, Boolean> entry : unMatchedElements.entrySet()) {
// We will only consider the highest level of an unmatched element
// hierarchy
if (!unMatchedElements.containsKey(entry.getKey().eContainer())) {
final UnmatchElement unMap;
if( entry.getValue()) {
unMap = MatchFactory.eINSTANCE.createUnmatchElement();
unMap.setRemote(true);
}
else
unMap = MatchFactory.eINSTANCE.createUnmatchElement();
unMap.setElement( entry.getKey());
redirectedAdd(root, UNMATCH_ELEMENT_NAME, unMap);
}
}
unMatchedElements.clear();
}
/**
* Creates {@link UnmatchElement}s wrapped around all the elements of the given {@link List}.
*
* @param root
* Root of the {@link MatchModel} under which to insert all these {@link UnmatchElement}s.
* @param unMatchedElements
* {@link Set} containing all the elements we haven't been able to match.
* @throws FactoryException
* Thrown if we cannot add elements under the given {@link MatchModel root}.
*/
private void createUnmatchElements(MatchModel root, Set<EObject> unMatchedElements, Side side)
throws FactoryException {
for (EObject element : unMatchedElements) {
final UnmatchElement unMap = MatchFactory.eINSTANCE.createUnmatchElement();
unMap.setElement(element);
if (side != null)
unMap.setSide(side);
redirectedAdd(root, UNMATCH_ELEMENT_NAME, unMap);
}
unMatchedElements.clear();
}
/**
* This method handles the creation and returning of a two way model match.
*
* @param leftResource
* Left model for the comparison.
* @param rightResource
* Right model for the comparison.
* @param monitor
* Progress monitor to display while the comparison lasts.
* @return The corresponding {@link MatchModel}.
* @throws InterruptedException
* Thrown if the comparison is interrupted somehow.
*/
private MatchModel doMatch(Resource leftResource, Resource rightResource, Monitor monitor)
throws InterruptedException {
final MatchModel root = MatchFactory.eINSTANCE.createMatchModel();
setModelRoots(root, leftResource, rightResource);
// filters unused features
filterUnused(leftResource);
filterUnused(rightResource);
// navigate through both models at the same time and realize mappings..
try {
if (!this.<Boolean> getOption(MatchOptions.OPTION_IGNORE_XMI_ID))
if (leftResource instanceof XMIResource && rightResource instanceof XMIResource)
matchByXMIID((XMIResource)leftResource, (XMIResource)rightResource);
if (!this.<Boolean> getOption(MatchOptions.OPTION_IGNORE_ID))
matchByID(leftResource, rightResource);
monitor.subTask("Matching roots"); //$NON-NLS-1$
final List<Match2Elements> matchedRoots = mapLists(leftResource.getContents(), rightResource
.getContents(), this.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW), monitor);
stillToFindFromModel1.clear();
stillToFindFromModel2.clear();
final List<EObject> unMatchedLeftRoots = new ArrayList<EObject>(leftResource.getContents());
final List<EObject> unMatchedRightRoots = new ArrayList<EObject>(rightResource.getContents());
// These sets will help us in keeping track of the yet to be found
// elements
final Set<EObject> still1 = new HashSet<EObject>();
final Set<EObject> still2 = new HashSet<EObject>();
// If one of the resources has no roots, considers it as deleted
if (leftResource.getContents().size() > 0 && rightResource.getContents().size() > 0) {
Match2Elements matchModelRoot = MatchFactory.eINSTANCE.createMatch2Elements();
// We haven't found any similar roots, we then consider the
// firsts to be similar.
if (matchedRoots.size() == 0) {
final Match2Elements rootMapping = MatchFactory.eINSTANCE.createMatch2Elements();
rootMapping.setLeftElement(leftResource.getContents().get(0));
EObject rightElement = findMostSimilar(leftResource.getContents().get(0),
unMatchedRightRoots);
if (rightElement == null)
rightElement = unMatchedRightRoots.get(0);
rootMapping.setRightElement(rightElement);
matchedRoots.add(rootMapping);
}
monitor.subTask("Processing matched roots' contents"); //$NON-NLS-1$
for (Match2Elements matchedRoot : matchedRoots) {
List<EObject> rightContentsWithChildren = getContentsWithChildren(matchedRoot.getRightElement());
final Match2Elements rootMapping = myRecursiveMappings(matchedRoot.getLeftElement(),
matchedRoot.getRightElement(), rightContentsWithChildren, monitor);
stillToFindFromModel2.addAll(rightContentsWithChildren);
// final Match2Elements rootMapping = recursiveMappings(matchedRoot.getLeftElement(),
// matchedRoot.getRightElement(), monitor);
// this is the first passage
if (matchModelRoot.getLeftElement() == null) {
matchModelRoot = rootMapping;
redirectedAdd(root, MATCH_ELEMENT_NAME, matchModelRoot);
} else {
redirectedAdd(matchModelRoot, SUBMATCH_ELEMENT_NAME, rootMapping);
}
// Synchronizes the two lists to avoid multiple elements
still1.removeAll(stillToFindFromModel1);
still2.removeAll(stillToFindFromModel2);
// checks for matches within the yet to found elements lists
createSubMatchElements(rootMapping, new ArrayList<EObject>(stillToFindFromModel1),
new ArrayList<EObject>(stillToFindFromModel2), monitor);
// Adds all unfound elements to the sets
still1.addAll(stillToFindFromModel1);
still2.addAll(stillToFindFromModel2);
unMatchedLeftRoots.remove(matchedRoot.getLeftElement());
unMatchedRightRoots.remove(matchedRoot.getRightElement());
}
// We'll iterate through the unMatchedRoots all contents
monitor.subTask("Processing unmatched roots"); //$NON-NLS-1$
createSubMatchElements(matchModelRoot, unMatchedLeftRoots, unMatchedRightRoots, monitor);
} else {
// Roots are unmatched, this is either a file addition or
// deletion
still1.addAll(unMatchedLeftRoots);
still2.addAll(unMatchedRightRoots);
}
// Now takes care of remaining unfound elements
still1.addAll(stillToFindFromModel1);
still2.addAll(stillToFindFromModel2);
createUnmatchElements(root, still1, Side.LEFT);
createUnmatchElements(root, still2, Side.RIGHT);
} catch (FactoryException e) {
EMFComparePlugin.log(e, false);
}
return root;
}
/**
* This method handles the creation and returning of a three way model match.
*
* @param leftResource
* Left model for the comparison.
* @param rightResource
* Right model for the comparison.
* @param ancestorResource
* Common ancestor of the right and left models.
* @param monitor
* Progress monitor to display while the comparison lasts.
* @return The corresponding {@link MatchModel}.
* @throws InterruptedException
* Thrown if the comparison is interrupted somehow.
*/
private MatchModel doMatch(Resource leftResource, Resource rightResource, Resource ancestorResource,
Monitor monitor) throws InterruptedException {
final MatchModel root = MatchFactory.eINSTANCE.createMatchModel();
setModelRoots(root, leftResource, rightResource, ancestorResource);
final MatchModel root1AncestorMatch = doMatch(leftResource, ancestorResource, monitor);
final MatchModel root2AncestorMatch = doMatch(rightResource, ancestorResource, monitor);
final List<MatchElement> root1MatchedElements = new ArrayList<MatchElement>(root1AncestorMatch
.getMatchedElements());
final List<MatchElement> root2MatchedElements = new ArrayList<MatchElement>(root2AncestorMatch
.getMatchedElements());
// populates the unmatched elements list for later use
for (Object unMatch : root1AncestorMatch.getUnmatchedElements())
remainingUnMatchedElements.add(((UnmatchElement)unMatch).getElement());
for (Object unMatch : root2AncestorMatch.getUnmatchedElements())
remainingUnMatchedElements.add(((UnmatchElement)unMatch).getElement());
try {
final Match3Elements subMatchRoot = MatchFactory.eINSTANCE.createMatch3Elements();
if (root2MatchedElements.size() > 0) {
final Match2Elements root1Match = (Match2Elements)root1MatchedElements.get(0);
final Match2Elements root2Match = (Match2Elements)root2MatchedElements.get(0);
subMatchRoot.setSimilarity(absoluteMetric(root1Match.getLeftElement(), root2Match
.getLeftElement(), root2Match.getRightElement()));
subMatchRoot.setLeftElement(root1Match.getLeftElement());
subMatchRoot.setRightElement(root2Match.getLeftElement());
subMatchRoot.setOriginElement(root2Match.getRightElement());
redirectedAdd(root, MATCH_ELEMENT_NAME, subMatchRoot);
createSub3Match(root, subMatchRoot, root1Match, root2Match);
} else if (root1MatchedElements.size() > 0) {
stillToFindFromModel1.add(root1MatchedElements.get(0));
}
// We will now check through the unmatched object for matches. This
// will allow for a more accurate detection
// for models with multiple roots.
processUnmatchedElements(root, subMatchRoot);
// #processUnmatchedElements(MatchModel, Match3Element)
// will have updated "remainingUnMatchedElements"
final Set<EObject> remainingLeft = new HashSet<EObject>();
final Set<EObject> remainingRight = new HashSet<EObject>();
for (EObject unMatched : remainingUnMatchedElements) {
if (unMatched.eResource() == leftResource) {
remainingLeft.add(unMatched);
final TreeIterator<EObject> iterator = unMatched.eAllContents();
while (iterator.hasNext())
remainingLeft.add(iterator.next());
} else if (unMatched.eResource() == rightResource) {
remainingRight.add(unMatched);
final TreeIterator<EObject> iterator = unMatched.eAllContents();
while (iterator.hasNext())
remainingRight.add(iterator.next());
}
}
stillToFindFromModel1.clear();
stillToFindFromModel2.clear();
final List<Match2Elements> mappings = mapLists(new ArrayList<EObject>(remainingLeft),
new ArrayList<EObject>(remainingRight), this
.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW), monitor);
for (Match2Elements map : mappings) {
final Match3Elements subMatch = MatchFactory.eINSTANCE.createMatch3Elements();
subMatch.setLeftElement(map.getLeftElement());
subMatch.setRightElement(map.getRightElement());
redirectedAdd(subMatchRoot, SUBMATCH_ELEMENT_NAME, subMatch);
}
final Map<EObject, Boolean> unMatchedElements = new EMFCompareMap<EObject, Boolean>();
for (EObject remoteUnMatch : stillToFindFromModel1) {
unMatchedElements.put(remoteUnMatch, true);
}
for (EObject unMatch : stillToFindFromModel2) {
unMatchedElements.put(unMatch, false);
}
createThreeWayUnmatchElements(root, unMatchedElements);
} catch (FactoryException e) {
EMFComparePlugin.log(e, false);
}
return root;
}
/**
* Filters unused features of the resource.
*
* @param resource
* Resource to be apply filter on.
*/
private void filterUnused(Resource resource) {
for (EObject root : resource.getContents())
filter.analyseModel(root);
}
/**
* Workaround for bug #235606 : elements held by a reference with containment=true and derived=true are
* not matched since not returned by {@link EObject#eContents()}. This allows us to return the list of all
* contents from an EObject <u>including</u> those references.
*
* @param eObject
* The EObject we seek the content of.
* @return The list of all the content of a given EObject, derived containmnent references included.
*/
@SuppressWarnings("unchecked")
private List<EObject> getContents(EObject eObject) {
// TODO can this be cached (Map<EClass, List<EReference>>)?
final List<EObject> result = new ArrayList(eObject.eContents());
for (EReference reference : eObject.eClass().getEAllReferences()) {
if (reference.isContainment() && reference.isDerived()) {
final Object value = eObject.eGet(reference);
if (value instanceof Collection)
result.addAll((Collection)value);
else if (value instanceof EObject)
result.add((EObject)value);
}
}
return result;
}
/**
* Returns whether we should assume the metamodels of the compared models are distinct.
*
* @return <code>true</code> if the metamodels are to be assumed distinct, <code>false</code>
* otherwise.
*/
private boolean getPreferenceDistinctMetaModel() {
if (EMFPlugin.IS_ECLIPSE_RUNNING && EMFComparePlugin.getDefault() != null)
return EMFComparePlugin.getDefault().getBoolean(
EMFComparePreferenceConstants.PREFERENCES_KEY_DISTINCT_METAMODEL);
return MatchOptions.DEFAULT_DISTINCT_METAMODEL;
}
/**
* Returns whether we should ignore the IDs or compare using them.
*
* @return <code>True</code> if we should ignore ID, <code>False</code> otherwise.
*/
private boolean getPreferenceIgnoreID() {
if (EMFPlugin.IS_ECLIPSE_RUNNING && EMFComparePlugin.getDefault() != null)
return EMFComparePlugin.getDefault().getBoolean(
EMFComparePreferenceConstants.PREFERENCES_KEY_IGNORE_ID);
return MatchOptions.DEFAULT_IGNORE_ID;
}
/**
* Returns whether we should ignore the XMI IDs or compare with them.
*
* @return <code>True</code> if we should ignore XMI ID, <code>False</code> otherwise.
*/
private boolean getPreferenceIgnoreXMIID() {
if (EMFPlugin.IS_ECLIPSE_RUNNING && EMFComparePlugin.getDefault() != null)
return EMFComparePlugin.getDefault().getBoolean(
EMFComparePreferenceConstants.PREFERENCES_KEY_IGNORE_XMIID);
return MatchOptions.DEFAULT_IGNORE_XMI_ID;
}
/**
* Returns the search window corresponding to the number of siblings to consider while matching. Reducing
* this number (on the preferences page) considerably improve performances while reducing precision.
*
* @return An <code>int</code> representing the number of siblings to consider for matching.
*/
private int getPreferenceSearchWindow() {
int searchWindow = MatchOptions.DEFAULT_SEARCH_WINDOW;
if (EMFPlugin.IS_ECLIPSE_RUNNING
&& EMFComparePlugin.getDefault() != null
&& EMFComparePlugin.getDefault().getInt(
EMFComparePreferenceConstants.PREFERENCES_KEY_SEARCH_WINDOW) > 0)
searchWindow = EMFComparePlugin.getDefault().getInt(
EMFComparePreferenceConstants.PREFERENCES_KEY_SEARCH_WINDOW);
if (searchWindow < 0)
searchWindow = 0;
return searchWindow;
}
/**
* Returns the given similarity between the two given {@link EObject}s as it is stored in cache.<br/>
* <p>
* <code>similarityKind</code> must be one of
* <ul>
* <li>{@link #NAME_SIMILARITY}</li>
* <li>{@link #TYPE_SIMILARITY}</li>
* <li>{@link #VALUE_SIMILARITY}</li>
* <li>{@link #RELATION_SIMILARITY}</li>
* </ul>
* </p>
*
* @param obj1
* First of the two {@link EObject}s we seek the similarity for.
* @param obj2
* Second of the two {@link EObject}s we seek the similarity for.
* @param similarityKind
* Kind of similarity to get.
* @return The similarity as described by <code>similarityKind</code> as it is stored in cache for the
* two given {@link EObject}s.
*/
private Double getSimilarityFromCache(EObject obj1, EObject obj2, char similarityKind) {
return metricsCache.get(pairHashCode(obj1, obj2, similarityKind));
}
/**
* Checks wether the two given {@link EObject} have the same URI.
*
* @param obj1
* First of the two {@link EObject} we're comparing.
* @param obj2
* Second {@link EObject} we're comparing.
* @return <code>True</code> if the {@link EObject}s have the same URI, <code>False</code> otherwise.
*/
private boolean hasSameUri(EObject obj1, EObject obj2) {
if (obj1.eResource() != null && obj2.eResource() != null)
return obj1.eResource().getURIFragment(obj1).equals(obj2.eResource().getURIFragment(obj2));
return false;
}
/**
* This replaces the contents of the defaults options map with the options overridden by the given map.
*
* @param map
* Map containing the option given to the match procedure. cannot be <code>null</code>.
*/
private void loadOptionMap(Map<String, Object> map) {
options.putAll(map);
if (this.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW) < 0)
options.put(MatchOptions.OPTION_SEARCH_WINDOW, getPreferenceSearchWindow());
}
/**
* Returns a list containing mappings of the nodes of both given {@link List}s.
*
* @param list1
* First of the lists from which we need to map the elements
* @param list2
* Second list to map the elements from.
* @param window
* Number of siblings to consider for the matching.
* @param monitor
* {@link CompareProgressMonitor Progress monitor} to display while the comparison lasts. Might
* be <code>null</code>, in which case we won't monitor progress.
* @return A {@link List} containing mappings of the nodes of both given {@link List}s.
* @throws FactoryException
* Thrown if the metrics cannot be computed.
* @throws InterruptedException
* Thrown if the matching process is interrupted somehow.
*/
private List<Match2Elements> mapLists(List<EObject> list1, List<EObject> list2, int window,
Monitor monitor) throws FactoryException, InterruptedException {
final List<Match2Elements> result = new ArrayList<Match2Elements>();
int curIndex = 0 - window / 2;
final List<EObject> notFoundList1 = new ArrayList<EObject>(list1);
final List<EObject> notFoundList2 = new ArrayList<EObject>(list2);
final Iterator<EObject> it1 = list1.iterator();
// then iterate over the 2 lists and compare the elements
while (it1.hasNext() && notFoundList2.size() > 0) {
final EObject obj1 = it1.next();
final StringBuilder obj1Key = new StringBuilder();
obj1Key.append(NameSimilarity.findName(obj1));
obj1Key.append(obj1.hashCode());
EObject obj2 = matchedByID.get(obj1Key.toString());
if (obj2 == null) {
// subtracts the difference between the notfound and the
// original list to avoid ArrayOutOfBounds
final int end = Math.min(curIndex + window - (list2.size() - notFoundList2.size()),
notFoundList2.size());
final int index = Math
.min(Math.max(curIndex - (list2.size() - notFoundList2.size()), 0), end);
obj2 = findMostSimilar(obj1, notFoundList2.subList(index, end));
if (obj2 != null) {
// checks if the most similar to obj2 is obj1
final EObject obj1Check = findMostSimilar(obj2, notFoundList1);
if (obj1Check != obj1 && obj1Check != null && isSimilar(obj1Check, obj2)) {
continue;
}
}
}
if (notFoundList1.contains(obj1) && notFoundList2.contains(obj2) && isSimilar(obj1, obj2)) {
final Match2Elements mapping = MatchFactory.eINSTANCE.createMatch2Elements();
final double metric = absoluteMetric(obj1, obj2);
mapping.setLeftElement(obj1);
mapping.setRightElement(obj2);
mapping.setSimilarity(metric);
result.add(mapping);
notFoundList2.remove(obj2);
notFoundList1.remove(obj1);
}
curIndex += 1;
monitor.worked(1);
if (monitor.isCanceled())
throw new InterruptedException();
}
// now putting the not found elements aside for later
stillToFindFromModel2.addAll(notFoundList2);
stillToFindFromModel1.addAll(notFoundList1);
return result;
}
/**
* Returns a list containing mappings of the nodes of both given {@link List}s.
*
* @param list1
* First of the lists from which we need to map the elements
* @param list2
* Second list to map the elements from.
* @param window
* Number of siblings to consider for the matching.
* @param monitor
* {@link CompareProgressMonitor Progress monitor} to display while the comparison lasts. Might
* be <code>null</code>, in which case we won't monitor progress.
* @return A {@link List} containing mappings of the nodes of both given {@link List}s.
* @throws FactoryException
* Thrown if the metrics cannot be computed.
* @throws InterruptedException
* Thrown if the matching process is interrupted somehow.
*/
private List<Match2Elements> myMapLists(List<EObject> list1, List<EObject> list2, int window,
Monitor monitor) throws FactoryException, InterruptedException {
final List<Match2Elements> result = new ArrayList<Match2Elements>();
int curIndex = 0 - window / 2;
final List<EObject> notFoundList1 = new ArrayList<EObject>(list1);
final List<EObject> notFoundList2 = new ArrayList<EObject>(list2);
final Iterator<EObject> it1 = list1.iterator();
// then iterate over the 2 lists and compare the elements
while (it1.hasNext() && notFoundList2.size() > 0) {
final EObject obj1 = it1.next();
final StringBuilder obj1Key = new StringBuilder();
obj1Key.append(NameSimilarity.findName(obj1));
obj1Key.append(obj1.hashCode());
EObject obj2 = matchedByID.get(obj1Key.toString());
if (obj2 == null) {
// subtracts the difference between the notfound and the
// original list to avoid ArrayOutOfBounds
final int end = Math.min(curIndex + window - (list2.size() - notFoundList2.size()),
notFoundList2.size());
final int index = Math
.min(Math.max(curIndex - (list2.size() - notFoundList2.size()), 0), end);
obj2 = findMostSimilar(obj1, notFoundList2.subList(index, end));
if (obj2 != null) {
// checks if the most similar to obj2 is obj1
final EObject obj1Check = findMostSimilar(obj2, notFoundList1);
if (obj1Check != obj1 && obj1Check != null && isSimilar(obj1Check, obj2)) {
continue;
}
}
}
if (notFoundList1.contains(obj1) && notFoundList2.contains(obj2) && isSimilar(obj1, obj2)) {
final Match2Elements mapping = MatchFactory.eINSTANCE.createMatch2Elements();
final double metric = absoluteMetric(obj1, obj2);
mapping.setLeftElement(obj1);
mapping.setRightElement(obj2);
mapping.setSimilarity(metric);
result.add(mapping);
notFoundList2.remove(obj2);
notFoundList1.remove(obj1);
list2.remove(obj2);
}
curIndex += 1;
monitor.worked(1);
if (monitor.isCanceled())
throw new InterruptedException();
}
// now putting the not found elements aside for later
// stillToFindFromModel2.addAll(notFoundList2);
stillToFindFromModel1.addAll(notFoundList1);
return result;
}
/**
* Iterates through both of the given EObjects to find all of their children that can be matched by their
* functional ID, then populates {@link #matchedByID} with those mappings.
* <p>
* Note that this method will perform a check to ensure the two objects' resources are indeed
* XMIResources.
* </p>
*
* @param obj1
* First of the two EObjects to visit.
* @param obj2
* Second of the EObjects to visit.
* @throws FactoryException
* Thrown if we couldn't compute a key to store the items in cache.
*/
private void matchByID(EObject obj1, EObject obj2) throws FactoryException {
matchedByID.clear();
final Iterator<EObject> iterator1 = obj1.eAllContents();
while (iterator1.hasNext()) {
final EObject item1 = iterator1.next();
final String item1ID = EcoreUtil.getID(item1);
if (item1ID != null) {
final Iterator<EObject> iterator2 = obj2.eAllContents();
while (iterator2.hasNext()) {
final EObject item2 = iterator2.next();
final String item2ID = EcoreUtil.getID(item2);
if (item2 != null && item1ID.equals(item2ID)) {
final StringBuilder item1Key = new StringBuilder();
item1Key.append(NameSimilarity.findName(item1));
item1Key.append(item1.hashCode());
matchedByID.put(item1Key.toString(), item2);
break;
}
}
}
}
}
/**
* Iterates through both of the given {@link XMIResource resources} to find all the elements that can be
* matched by their XMI ID, then populates {@link #matchedByID} with those mappings.
*
* @param left
* First of the two {@link XMIResource resources} to visit.
* @param right
* Second of the {@link XMIResource resources} to visit.
* @throws FactoryException
* Thrown if we couldn't compute a key to store the items in cache.
*/
private void matchByID(Resource left, Resource right) throws FactoryException {
matchedByID.clear();
final Iterator<EObject> leftIterator = left.getAllContents();
while (leftIterator.hasNext()) {
final EObject item1 = leftIterator.next();
final String item1ID = EcoreUtil.getID(item1);
if (item1ID != null) {
final Iterator<EObject> rightIterator = right.getAllContents();
while (rightIterator.hasNext()) {
final EObject item2 = rightIterator.next();
final String item2ID = EcoreUtil.getID(item2);
if (item2 != null && item1ID.equals(item2ID)) {
final StringBuilder item1Key = new StringBuilder();
item1Key.append(NameSimilarity.findName(item1));
item1Key.append(item1.hashCode());
matchedByID.put(item1Key.toString(), item2);
break;
}
}
}
}
}
/**
* Iterates through both of the given EObjects to find all of their children that can be matched by their
* XMI ID, then populates {@link #matchedByXMIID} with those mappings.
* <p>
* Note that this method will perform a check to ensure the two objects' resources are indeed
* XMIResources.
* </p>
*
* @param obj1
* First of the two EObjects to visit.
* @param obj2
* Second of the EObjects to visit.
* @throws FactoryException
* Thrown if we couldn't compute a key to store the items in cache.
*/
private void matchByXMIID(EObject obj1, EObject obj2) throws FactoryException {
matchedByXMIID.clear();
if (obj1 != null && obj2 != null && obj1.eResource() instanceof XMIResource
&& obj2.eResource() instanceof XMIResource) {
final XMIResource left = (XMIResource)obj1.eResource();
final XMIResource right = (XMIResource)obj2.eResource();
final Iterator<EObject> iterator = obj1.eAllContents();
while (iterator.hasNext()) {
final EObject item1 = iterator.next();
final String item1ID = left.getID(item1);
if (item1ID != null) {
final EObject item2 = right.getEObject(item1ID);
if (item2 != null) {
final StringBuilder item1Key = new StringBuilder();
item1Key.append(NameSimilarity.findName(item1));
item1Key.append(item1.hashCode());
matchedByXMIID.put(item1Key.toString(), item2);
}
}
}
}
}
/**
* Iterates through both of the given {@link XMIResource resources} to find all the elements that can be
* matched by their XMI ID, then populates {@link #matchedByXMIID} with those mappings.
*
* @param left
* First of the two {@link XMIResource resources} to visit.
* @param right
* Second of the {@link XMIResource resources} to visit.
* @throws FactoryException
* Thrown if we couldn't compute a key to store the items in cache.
*/
private void matchByXMIID(XMIResource left, XMIResource right) throws FactoryException {
matchedByXMIID.clear();
final Iterator<EObject> leftIterator = left.getAllContents();
while (leftIterator.hasNext()) {
final EObject item1 = leftIterator.next();
final String item1ID = left.getID(item1);
if (item1ID != null) {
final EObject item2 = right.getEObject(item1ID);
if (item2 != null) {
final StringBuilder item1Key = new StringBuilder();
item1Key.append(NameSimilarity.findName(item1));
item1Key.append(item1.hashCode());
matchedByXMIID.put(item1Key.toString(), item2);
}
}
}
}
/**
* Counts all the {@link EStructuralFeature features} of the given {@link EObject} that are
* <code>null</code> or initialized to the empty {@link String} "".
*
* @param eobj
* {@link EObject} we need to count the empty features of.
* @return The number of features initialized to <code>null</code> or the empty String.
*/
private int nonNullFeaturesCount(EObject eobj) {
// TODO should probably cache result here
int nonNullFeatures = 0;
final Iterator<EStructuralFeature> features = eobj.eClass().getEAllStructuralFeatures().iterator();
while (features.hasNext()) {
final EStructuralFeature feature = features.next();
if (eobj.eGet(feature) != null && !"".equals(eobj.eGet(feature).toString())) //$NON-NLS-1$
nonNullFeatures++;
}
return nonNullFeatures;
}
/**
* Computes an unique key between to {@link EObject}s to store their similarity in cache.
* <p>
* <code>similarityKind</code> must be one of
* <ul>
* <li>{@link #NAME_SIMILARITY}</li>
* <li>{@link #TYPE_SIMILARITY}</li>
* <li>{@link #VALUE_SIMILARITY}</li>
* <li>{@link #RELATION_SIMILARITY}</li>
* </ul>
* </p>
*
* @param obj1
* First of the two {@link EObject}s.
* @param obj2
* Second of the two {@link EObject}s.
* @param similarityKind
* Kind of similarity this key will represent in cache.
* @return Unique key for the similarity cache.
*/
private String pairHashCode(EObject obj1, EObject obj2, char similarityKind) {
if (similarityKind == NAME_SIMILARITY || similarityKind == TYPE_SIMILARITY
|| similarityKind == VALUE_SIMILARITY || similarityKind == RELATION_SIMILARITY) {
final StringBuilder hash = new StringBuilder();
hash.append(similarityKind).append(obj1.hashCode()).append(obj2.hashCode());
return hash.toString();
}
throw new IllegalArgumentException("DifferencesServices.illegalSimilarityKind"); //$NON-NLS-1$
}
/**
* Allows for a more accurate modifications detection for three way comparison with multiple roots models.
*
* @param root
* Root of the {@link MatchModel}.
* @param subMatchRoot
* Root of the {@link Match3Element}s' hierarchy for the current element to be created.
* @throws FactoryException
* Thrown if we cannot compute {@link EObject}s similarity or if adding elements to either
* <code>root</code> or <code>subMatchRoot</code> fails somehow.
*/
private void processUnmatchedElements(MatchModel root, Match3Elements subMatchRoot)
throws FactoryException {
for (EObject obj1 : new ArrayList<EObject>(stillToFindFromModel1)) {
boolean matchFound = false;
if (obj1 instanceof Match2Elements) {
final Match2Elements match1 = (Match2Elements)obj1;
for (EObject obj2 : new ArrayList<EObject>(stillToFindFromModel2)) {
if (obj2 instanceof Match2Elements) {
final Match2Elements match2 = (Match2Elements)obj2;
if (match1.getRightElement() == match2.getRightElement()) {
matchFound = true;
final Match3Elements match = MatchFactory.eINSTANCE.createMatch3Elements();
match.setSimilarity(absoluteMetric(match1.getLeftElement(), match2
.getLeftElement(), match2.getRightElement()));
match.setLeftElement(match1.getLeftElement());
match.setRightElement(match2.getLeftElement());
match.setOriginElement(match2.getRightElement());
// This will happen if we couldn't match previously
if (subMatchRoot == null) {
redirectedAdd(root, MATCH_ELEMENT_NAME, match);
createSub3Match(root, match, match1, match2);
} else {
redirectedAdd(subMatchRoot, SUBMATCH_ELEMENT_NAME, match);
createSub3Match(root, subMatchRoot, match1, match2);
}
stillToFindFromModel1.remove(match1);
stillToFindFromModel2.remove(match2);
}
}
}
if (!matchFound) {
remainingUnMatchedElements.add(match1.getLeftElement());
}
}
}
for (EObject eObj : new ArrayList<EObject>(stillToFindFromModel1)) {
if (eObj instanceof Match2Elements) {
final Match2Elements nextLeftNotFound = (Match2Elements)eObj;
final UnmatchElement unMatch = MatchFactory.eINSTANCE.createUnmatchElement();
unMatch.setElement(nextLeftNotFound.getLeftElement());
remainingUnMatchedElements.remove(nextLeftNotFound.getLeftElement());
remainingUnMatchedElements.remove(nextLeftNotFound.getRightElement());
redirectedAdd(root, UNMATCH_ELEMENT_NAME, unMatch);
}
}
for (EObject eObj : new ArrayList<EObject>(stillToFindFromModel2)) {
if (eObj instanceof Match2Elements) {
final Match2Elements nextRightNotFound = (Match2Elements)eObj;
final UnmatchElement unMatch = MatchFactory.eINSTANCE.createUnmatchElement();
unMatch.setRemote(true);
unMatch.setElement(nextRightNotFound.getLeftElement());
remainingUnMatchedElements.remove(nextRightNotFound.getLeftElement());
remainingUnMatchedElements.remove(nextRightNotFound.getRightElement());
redirectedAdd(root, UNMATCH_ELEMENT_NAME, unMatch);
}
}
}
/**
* We consider here <code>current1</code> and <code>current2</code> are similar. This method creates
* the mapping for the objects <code>current1</code> and <code>current2</code>, Then submappings for
* these two elements' contents.
*
* @param current1
* First element of the two elements mapping.
* @param current2
* Second of the two elements mapping.
* @param monitor
* {@link CompareProgressMonitor Progress monitor} to display while the comparison lasts. Might
* be <code>null</code>, in which case we won't monitor progress.
* @return The mapping for <code>current1</code> and <code>current2</code> and their content.
* @throws FactoryException
* Thrown when the metrics cannot be computed for <code>current1</code> and
* <code>current2</code>.
* @throws InterruptedException
* Thrown if the matching process is interrupted somehow.
*/
private Match2Elements recursiveMappings(EObject current1, EObject current2,
Monitor monitor) throws FactoryException, InterruptedException {
Match2Elements mapping = null;
mapping = MatchFactory.eINSTANCE.createMatch2Elements();
mapping.setLeftElement(current1);
mapping.setRightElement(current2);
mapping.setSimilarity(absoluteMetric(current1, current2));
final List<Match2Elements> mapList = mapLists(getContents(current1), getContents(current2), this
.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW), monitor);
// We can map other elements with mapLists; we iterate through them.
final Iterator<Match2Elements> it = mapList.iterator();
while (it.hasNext()) {
final Match2Elements subMapping = it.next();
// As we know source and target are similars, we call recursive
// mappings onto these objects
EFactory.eAdd(mapping, SUBMATCH_ELEMENT_NAME, recursiveMappings(subMapping.getLeftElement(),
subMapping.getRightElement(), monitor));
}
return mapping;
}
/**
* We consider here <code>current1</code> and <code>current2</code> are similar. This method creates
* the mapping for the objects <code>current1</code> and <code>current2</code>, Then submappings for
* these two elements' contents.
*
* @param current1
* First element of the two elements mapping.
* @param current2
* Second of the two elements mapping.
* @param monitor
* {@link CompareProgressMonitor Progress monitor} to display while the comparison lasts. Might
* be <code>null</code>, in which case we won't monitor progress.
* @return The mapping for <code>current1</code> and <code>current2</code> and their content.
* @throws FactoryException
* Thrown when the metrics cannot be computed for <code>current1</code> and
* <code>current2</code>.
* @throws InterruptedException
* Thrown if the matching process is interrupted somehow.
*/
private Match2Elements myRecursiveMappings(EObject current1, EObject current2, List<EObject> rightChildren,
Monitor monitor) throws FactoryException, InterruptedException {
Match2Elements mapping = null;
mapping = MatchFactory.eINSTANCE.createMatch2Elements();
mapping.setLeftElement(current1);
mapping.setRightElement(current2);
mapping.setSimilarity(absoluteMetric(current1, current2));
final List<Match2Elements> mapList = myMapLists(getContents(current1), rightChildren, this
.<Integer> getOption(MatchOptions.OPTION_SEARCH_WINDOW), monitor);
// We can map other elements with mapLists; we iterate through them.
final Iterator<Match2Elements> it = mapList.iterator();
while (it.hasNext()) {
final Match2Elements subMapping = it.next();
// As we know source and target are similars, we call recursive
// mappings onto these objects
EFactory.eAdd(mapping, SUBMATCH_ELEMENT_NAME, myRecursiveMappings(subMapping.getLeftElement(),
subMapping.getRightElement(), rightChildren, monitor));
}
return mapping;
}
private List<EObject> getContentsWithChildren(EObject eObject) {
List<EObject> result = new ArrayList<EObject>();
List<EObject> children = getContents(eObject);
result.addAll(children);
for (EObject child : children) {
result.addAll(getContentsWithChildren(child));
}
return result;
}
/**
* This method is an indirection for adding Mappings in the current MappingGroup.
*
* @param object
* {@link EObject} to add a feature value to.
* @param name
* Name of the feature to consider.
* @param value
* Value to add to the feature <code>name</code> of <code>object</code>.
* @throws FactoryException
* Thrown if the value's affectation fails.
*/
private void redirectedAdd(EObject object, String name, Object value) throws FactoryException {
EFactory.eAdd(object, name, value);
}
/**
* This will compute the similarity between two {@link EObject}s' relations.
*
* @param obj1
* First of the two {@link EObject}s.
* @param obj2
* Second of the two {@link EObject}s.
* @return <code>double</code> representing the similarity between the two {@link EObject}s' relations.
* 0 < value < 1.
* @throws FactoryException
* Thrown if we cannot compute the relations' similarity metrics.
* @see StructureSimilarity#relationsSimilarityMetric(EObject, EObject, MetamodelFilter)
*/
private double relationsSimilarity(EObject obj1, EObject obj2) throws FactoryException {
double similarity = 0d;
final Double value = getSimilarityFromCache(obj1, obj2, RELATION_SIMILARITY);
if (value != null) {
similarity = value;
} else {
similarity = StructureSimilarity.relationsSimilarityMetric(obj1, obj2, filter);
setSimilarityInCache(obj1, obj2, RELATION_SIMILARITY, similarity);
}
return similarity;
}
/**
* Sets the values of the {@link MatchModel}'s left and right models.
*
* @param modelRoot
* Root of the {@link MatchModel}.
* @param left
* Element from which to resolve the left model URI.
* @param right
* Element from which to resolve the right model URI.
*/
private void setModelRoots(MatchModel modelRoot, Resource left, Resource right) {
setModelRoots(modelRoot, left, right, null);
}
/**
* Sets the values of the {@link MatchModel}'s left, right and ancestor models.
*
* @param modelRoot
* Root of the {@link MatchModel}.
* @param left
* Element from which to resolve the left model URI.
* @param right
* Element from which to resolve the right model URI.
* @param ancestor
* Element from which to resolve the ancestor model URI. Can be <code>null</code>.
*/
private void setModelRoots(MatchModel modelRoot, Resource left, Resource right, Resource ancestor) {
// Sets values of left, right and ancestor model URIs
if (left != null) {
modelRoot.getLeftRoots().addAll(left.getContents());
}
if (right != null) {
modelRoot.getRightRoots().addAll(right.getContents());
}
if (ancestor != null) {
modelRoot.getAncestorRoots().addAll(ancestor.getContents());
}
}
/**
* Stores in cache the given similarity between the two given {@link EObject}s.<br/>
* <p>
* <code>similarityKind</code> must be one of
* <ul>
* <li>{@link #NAME_SIMILARITY}</li>
* <li>{@link #TYPE_SIMILARITY}</li>
* <li>{@link #VALUE_SIMILARITY}</li>
* <li>{@link #RELATION_SIMILARITY}</li>
* </ul>
* </p>
*
* @param obj1
* First of the two {@link EObject}s we're setting the similarity for.
* @param obj2
* Second of the two {@link EObject}s we're setting the similarity for.
* @param similarityKind
* Kind of similarity to set.
* @param similarity
* Value of the similarity between the two {@link EObject}s.
*/
private void setSimilarityInCache(EObject obj1, EObject obj2, char similarityKind, double similarity) {
metricsCache.put(pairHashCode(obj1, obj2, similarityKind), new Double(similarity));
}
/**
* Starts the monitor for comparison progress. Externalized here to avoid multiple usage of the Strings.
*
* @param monitor
* The monitor that need be started
* @param size
* Size of the monitor
*/
private void startMonitor(Monitor monitor, int size) {
monitor.beginTask("Comparing model", size); //$NON-NLS-1$
monitor.subTask("Browsing model"); //$NON-NLS-1$
}
/**
* This will compute the similarity between two {@link EObject}s' types.
*
* @param obj1
* First of the two {@link EObject}s.
* @param obj2
* Second of the two {@link EObject}s.
* @return <code>double</code> representing the similarity between the two {@link EObject}s' types. 0
* < value < 1.
* @throws FactoryException
* Thrown if we cannot compute the type similarity metrics.
* @see StructureSimilarity#typeSimilarityMetric(EObject, EObject)
*/
private double typeSimilarity(EObject obj1, EObject obj2) throws FactoryException {
double similarity = 0d;
final Double value = getSimilarityFromCache(obj1, obj2, TYPE_SIMILARITY);
if (value != null) {
similarity = value;
} else {
similarity = StructureSimilarity.typeSimilarityMetric(obj1, obj2);
setSimilarityInCache(obj1, obj2, TYPE_SIMILARITY, similarity);
}
return similarity;
}
/**
* Creates the progress monitor that will be displayed to the user while the comparison lasts.
*
* @return The progress monitor that will be displayed to the user while the comparison lasts.
*/
private Monitor createProgressMonitor() {
Monitor monitor = new BasicMonitor();
final Object delegateMonitor = getOption(MatchOptions.OPTION_PROGRESS_MONITOR);
if (delegateMonitor != null && EMFPlugin.IS_ECLIPSE_RUNNING) {
monitor = EclipseModelUtils.createProgressMonitor(delegateMonitor);
}
return monitor;
}
}