| /******************************************************************************* |
| * Copyright (c) 2015 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 |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.rcp.ui.internal.util; |
| |
| import static com.google.common.collect.Iterables.filter; |
| import static java.util.Collections.emptyList; |
| |
| import com.google.common.base.Function; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Sets; |
| |
| import java.util.Collection; |
| import java.util.Map.Entry; |
| |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Match; |
| import org.eclipse.emf.compare.graph.IGraphView; |
| import org.eclipse.emf.compare.match.impl.NotLoadedFragmentMatch; |
| import org.eclipse.emf.compare.rcp.EMFCompareRCPPlugin; |
| import org.eclipse.emf.compare.rcp.ui.internal.mergeviewer.item.impl.MergeViewerItem; |
| import org.eclipse.emf.compare.rcp.ui.mergeviewer.IMergeViewer.MergeViewerSide; |
| import org.eclipse.emf.compare.rcp.ui.mergeviewer.item.IMergeViewerItem; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.edit.tree.TreeNode; |
| |
| /** |
| * This class will be used to provide various utilities aimed at NotLoadedFragment manipulation. |
| * |
| * @author <a href="mailto:axel.richard@obeo.fr">Axel Richard</a> |
| */ |
| public class ResourceUIUtil { |
| |
| /** ID of the graph of EMF resources used by EMFCompare to compute the logical model. */ |
| public static final String RESOURCES_GRAPH_ID = "org.eclipse.emf.compare.resources.graph"; //$NON-NLS-1$ |
| |
| /** |
| * Function that retrieve the data of the given TreeNode. |
| */ |
| private static Function<EObject, EObject> TREE_NODE_DATA = new Function<EObject, EObject>() { |
| public EObject apply(EObject node) { |
| final EObject data; |
| if (node instanceof TreeNode) { |
| data = ((TreeNode)node).getData(); |
| } else { |
| data = node; |
| } |
| return data; |
| } |
| }; |
| |
| /** |
| * Get the graph of resources' URI for the models involved in the current comparison. |
| * |
| * @return the graph if it exists, <code>null</code> otherwise. |
| */ |
| public static IGraphView<URI> getResourcesURIGraph() { |
| return EMFCompareRCPPlugin.getDefault().getGraphView(RESOURCES_GRAPH_ID); |
| } |
| |
| /** |
| * Check if the given URI correspond to the root resource of a model. In this case a root resource is a |
| * piece of a whole model that is not a fragment of the model. |
| * |
| * @param uri |
| * the given URI. |
| * @return <code>true</code> if the given URI is root resource of a model, <code>false</code> otherwise. |
| */ |
| public static boolean isRootResource(URI uri) { |
| return !isFragment(uri); |
| } |
| |
| /** |
| * Check if the given URI correspond to a fragment of model. In this case a fragment is a piece of a whole |
| * model that is not the root resource of the model. |
| * |
| * @param uri |
| * the given URI. |
| * @return <code>true</code> if the given URI is a fragment of a model, <code>false</code> otherwise. |
| */ |
| public static boolean isFragment(URI uri) { |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| if (uri != null && graph != null) { |
| URI parentData = graph.getParentData(uri); |
| if (parentData != null) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Check if the given match is a root match of its comparison model and is a fragment. In this case a |
| * fragment is a piece of a whole model that is not the root resource of the model. |
| * |
| * @param rootMatch |
| * the given match. |
| * @param side |
| * the side for which we want to know if it is a fragment or not. |
| * @return <code>true</code> if the given match is a root match of its comparison model and is a fragment, |
| * <code>false</code> otherwise. |
| */ |
| public static boolean isFragment(Match rootMatch, MergeViewerSide side) { |
| if (rootMatch != null && rootMatch.eContainer() instanceof Comparison) { |
| URI uri = getDataURI(rootMatch, side); |
| return isFragment(uri); |
| } |
| return false; |
| } |
| |
| /** |
| * Check if the given URI corresponds to a fragment of model that is at the first level of the model, in |
| * other words a fragment that is directly under a root resource. In this case a fragment is a piece of a |
| * whole model that is not the root resource of the model. |
| * <p> |
| * If the given fragment (represented by the given URI) has several parents, this method will return |
| * <code>false</code>. |
| * </p> |
| * |
| * @param uri |
| * the given URI. |
| * @return <code>true</code> if the given URI is a fragment of a model, <code>false</code> otherwise. |
| */ |
| public static boolean isFirstLevelFragment(URI uri) { |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| if (uri != null && graph != null) { |
| URI parentData = graph.getParentData(uri); |
| if (parentData != null) { |
| URI parent = parentData.trimFragment(); |
| return !isFragment(parent); |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Get the root resource of the whole model that contains the given fragment (represented by its uri). |
| * <p> |
| * If at some point of the process a fragment has several parents, this method will return |
| * <code>null</code>. |
| * </p> |
| * |
| * @param uri |
| * the given URI. |
| * @return the root resource of the whole model that contains the given fragment if found, |
| * <code>null</code> otherwise. |
| */ |
| public static URI getRootResourceURI(URI uri) { |
| final URI uriRoot; |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| if (uri != null && graph != null) { |
| URI parentData = graph.getParentData(uri); |
| if (parentData == null) { |
| uriRoot = uri; |
| } else { |
| URI parent = parentData.trimFragment(); |
| uriRoot = getRootResourceURI(parent); |
| } |
| } else { |
| uriRoot = null; |
| } |
| return uriRoot; |
| } |
| |
| /** |
| * Get the first loaded parent resource URI of the given resource (represented by its URI) contained in |
| * the given ResourceSet. |
| * <p> |
| * If at some point of the process the current resource (represented by its URI) has several parents, this |
| * method will return <code>null</code>. |
| * |
| * @param rs |
| * the ResourceSet in which the first loaded parent must be found. |
| * @param uri |
| * the URI of the resource for which we want to get its first loaded parent. |
| * @return the URI of the first loaded resource parent if found, <code>null</code> otherwise. |
| */ |
| public static URI getParentResourceURI(ResourceSet rs, URI uri) { |
| final URI parentURI; |
| final Entry<URI, Resource> entry = getResourceParent(rs, uri); |
| if (entry != null) { |
| final Resource resource = entry.getValue(); |
| if (resource != null) { |
| parentURI = entry.getKey().trimFragment(); |
| } else { |
| parentURI = null; |
| } |
| } else { |
| parentURI = null; |
| } |
| return parentURI; |
| } |
| |
| /** |
| * Get the parent of the given resource (represented by its URI) contained in the given ResourceSet. |
| * <p> |
| * If the given resource (represented by its URI) has several parents, this method will return |
| * <code>null</code>. |
| * </p> |
| * |
| * @param rs |
| * the ResourceSet in which the parent must be found. |
| * @param uri |
| * the URI of the resource for which we want to get its parent. |
| * @return the parent of the given resource (represented by its URI) if found, <code>null</code> |
| * otherwise. |
| */ |
| public static Resource getParent(ResourceSet rs, URI uri) { |
| final Resource resource; |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| if (uri != null && graph != null) { |
| URI parentData = graph.getParentData(uri); |
| if (parentData != null) { |
| resource = rs.getResource(parentData.trimFragment(), false); |
| } else { |
| resource = null; |
| } |
| } else { |
| resource = null; |
| } |
| return resource; |
| } |
| |
| /** |
| * Get the first loaded EObject parent of the given resource (represented by its URI) contained in the |
| * given ResourceSet. |
| * <p> |
| * If at some point of the process the current resource (represented by its URI) has several parents, this |
| * method will return <code>null</code>. |
| * |
| * @param rs |
| * the ResourceSet in which the first loaded parent must be found. |
| * @param uri |
| * the URI of the resource for which we want to get its first loaded parent. |
| * @return the first loaded EObject parent of the given resource (represented by its URI) if found, |
| * <code>null</code> otherwise. |
| */ |
| public static EObject getEObjectParent(ResourceSet rs, URI uri) { |
| final EObject eObject; |
| final Entry<URI, Resource> entry = getResourceParent(rs, uri); |
| if (entry != null) { |
| final Resource resource = entry.getValue(); |
| if (resource != null) { |
| eObject = resource.getEObject(entry.getKey().fragment()); |
| } else { |
| eObject = null; |
| } |
| } else { |
| eObject = null; |
| } |
| return eObject; |
| } |
| |
| /** |
| * Get the first loaded parent of the given resource (represented by its URI) contained in the given |
| * ResourceSet. |
| * <p> |
| * If at some point of the process the current resource (represented by its URI) has several parents, this |
| * method will return <code>null</code>. |
| * |
| * @param rs |
| * the ResourceSet in which the first loaded parent must be found. |
| * @param uri |
| * the URI of the resource for which we want to get its first loaded parent. |
| * @return an entry composed with the first loaded EObject parent of the given resource (represented by |
| * its URI) and the Resource associated if found, <code>null</code> otherwise. |
| */ |
| private static Entry<URI, Resource> getResourceParent(ResourceSet rs, URI uri) { |
| Entry<URI, Resource> entry = null; |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| if (uri != null && graph != null) { |
| URI parentData = graph.getParentData(uri); |
| if (parentData != null) { |
| URI parent = parentData.trimFragment(); |
| Resource resourceParent = rs.getResource(parent, false); |
| if (resourceParent != null) { |
| entry = Maps.immutableEntry(parentData, resourceParent); |
| } else { |
| entry = getResourceParent(rs, parent); |
| } |
| } |
| } |
| return entry; |
| } |
| |
| /** |
| * Search from the given list of TreeNodes (and recursively on its children), the one that is associated |
| * to the given Match. |
| * |
| * @param nodes |
| * the given list of TreeNodes. |
| * @param match |
| * the given Match. |
| * @return the TreeNode that is associated to the given Match. |
| */ |
| public static TreeNode getTreeNode(Collection<TreeNode> nodes, Match match) { |
| for (TreeNode treeNode : nodes) { |
| EObject data = TREE_NODE_DATA.apply(treeNode); |
| if (data.equals(match)) { |
| return treeNode; |
| } |
| } |
| for (TreeNode treeNode : nodes) { |
| TreeNode treeNode2 = getTreeNode(treeNode.getChildren(), match); |
| if (treeNode2 != null) { |
| return treeNode2; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Get from the given list of TreeNodes, the one that has its data's resource's URI (TreeNode -> Match -> |
| * EObject -> Resource -> URI) corresponding to the given URI. |
| * |
| * @param nodes |
| * the given list of TreeNodes. |
| * @param uri |
| * the given URI. |
| * @return the TreeNode that has its data's resource's URI corresponding to the given URI, or null if no |
| * one match. |
| */ |
| public static TreeNode getTreeNodeFromURI(Collection<TreeNode> nodes, URI uri) { |
| for (TreeNode treeNode : nodes) { |
| EObject data = TREE_NODE_DATA.apply(treeNode); |
| URI dataURI = getDataURI((Match)data); |
| if (uri.equals(dataURI)) { |
| return treeNode; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Get the Resource's URI of the data associated to the given Match |
| * |
| * @param match |
| * the given Match. |
| * @return the Resource's URI of the data associated to the given Match. |
| */ |
| public static URI getDataURI(Match match) { |
| final URI uri; |
| final Resource resource; |
| if (match.getLeft() != null) { |
| resource = match.getLeft().eResource(); |
| } else if (match.getRight() != null) { |
| resource = match.getRight().eResource(); |
| } else if (match.getOrigin() != null) { |
| resource = match.getOrigin().eResource(); |
| } else { |
| resource = null; |
| } |
| if (resource != null) { |
| uri = resource.getURI(); |
| } else { |
| uri = null; |
| } |
| return uri; |
| } |
| |
| /** |
| * Get the Resource's URIs of the data associated to the given list of Matches. |
| * |
| * @param matches |
| * the given list of Matches. |
| * @param side |
| * the given side of the comparison. |
| * @return the Resource's URIs of the data associated to the given list of Matches. |
| */ |
| public static Collection<URI> getDataURIs(Collection<Match> matches, MergeViewerSide side) { |
| final Collection<URI> uris = Lists.newArrayList(); |
| for (Match match : matches) { |
| URI dataURI = getDataURI(match, side); |
| if (dataURI != null) { |
| uris.add(dataURI); |
| } |
| } |
| return uris; |
| } |
| |
| /** |
| * Get the Resource's URI of the data associated to the given Match, and for the given side of the |
| * comparison. . |
| * |
| * @param match |
| * the given Match. |
| * @param side |
| * the given side of the comparison. |
| * @return the Resource's URI of the data associated to the given Match. |
| */ |
| public static URI getDataURI(Match match, MergeViewerSide side) { |
| final URI uri; |
| final Resource resource; |
| if (MergeViewerSide.LEFT == side && match.getLeft() != null) { |
| resource = match.getLeft().eResource(); |
| } else if (MergeViewerSide.RIGHT == side && match.getRight() != null) { |
| resource = match.getRight().eResource(); |
| } else if (MergeViewerSide.ANCESTOR == side && match.getOrigin() != null) { |
| resource = match.getOrigin().eResource(); |
| } else { |
| resource = null; |
| } |
| if (resource != null) { |
| uri = resource.getURI(); |
| } else { |
| uri = null; |
| } |
| return uri; |
| } |
| |
| /** |
| * Get the Resource's ResourceSet of the data associated to the given Match. |
| * |
| * @param match |
| * the given Match. |
| * @return the Resource's ResourceSet of the data associated to the given Match. |
| */ |
| public static ResourceSet getDataResourceSet(Match match) { |
| final ResourceSet rs; |
| final Resource resource; |
| if (match.getLeft() != null) { |
| resource = match.getLeft().eResource(); |
| } else if (match.getRight() != null) { |
| resource = match.getRight().eResource(); |
| } else if (match.getOrigin() != null) { |
| resource = match.getOrigin().eResource(); |
| } else { |
| resource = null; |
| } |
| if (resource != null) { |
| rs = resource.getResourceSet(); |
| } else { |
| rs = null; |
| } |
| return rs; |
| } |
| |
| /** |
| * Get the Resource's ResourceSet of the data associated to the given Match, and for the given side of the |
| * comparison. |
| * |
| * @param match |
| * the given Match. |
| * @param side |
| * the given side of the comparison. |
| * @return the Resource's ResourceSet of the data associated to the given Match. |
| */ |
| public static ResourceSet getDataResourceSet(Match match, MergeViewerSide side) { |
| final ResourceSet rs; |
| final Resource resource; |
| if (MergeViewerSide.LEFT == side && match != null && match.getLeft() != null) { |
| resource = match.getLeft().eResource(); |
| } else if (MergeViewerSide.RIGHT == side && match != null && match.getRight() != null) { |
| resource = match.getRight().eResource(); |
| } else if (MergeViewerSide.ANCESTOR == side && match != null && match.getOrigin() != null) { |
| resource = match.getOrigin().eResource(); |
| } else { |
| resource = null; |
| } |
| if (resource != null) { |
| rs = resource.getResourceSet(); |
| } else { |
| rs = null; |
| } |
| return rs; |
| } |
| |
| /** |
| * Check if the given list of TreeNodes contains at least two nodes that have NotLoadedFragmentMatch for |
| * data. |
| * |
| * @param nodes |
| * the given list of TreeNodes. |
| * @return <code>true</code> if the given list of TreeNodes contains at least two nodes that have |
| * NotLoadedFragmentMatch for data, false otherwise. |
| */ |
| public static boolean containsNotLoadedFragmentNodes(Collection<TreeNode> nodes) { |
| int notLoadedFragments = 0; |
| for (TreeNode node : nodes) { |
| EObject data = TREE_NODE_DATA.apply(node); |
| if (data instanceof NotLoadedFragmentMatch) { |
| notLoadedFragments++; |
| } |
| } |
| return notLoadedFragments > 1; |
| } |
| |
| /** |
| * Get from the given list of {@link IMergeViewerItem}s, the NotLoadedFragmentMatchs. |
| * |
| * @param items |
| * the given list of IMergeViewerItems. |
| * @return a list of Match. |
| */ |
| public static Collection<Match> getNotLoadedFragmentMatches(Collection<IMergeViewerItem> items) { |
| final Collection<Match> notLoadedFragmentMatches = Lists.newArrayList(); |
| for (IMergeViewerItem item : items) { |
| // If an IMergeViewerItem contains NotLoadedFragmentMatch, this is the same NotLoadedFragmentMatch |
| // on left, right and ancestor sides. |
| Object left = item.getLeft(); |
| if (left instanceof NotLoadedFragmentMatch) { |
| notLoadedFragmentMatches.add((NotLoadedFragmentMatch)left); |
| } |
| } |
| return notLoadedFragmentMatches; |
| } |
| |
| /** |
| * Get the resource's name associated with the data of the given NotLoadedFragmentMatch. If it is a |
| * NotLoadedFragmentMatch containing others NotLoadedFragmentMatch, then it returns an empty string. |
| * |
| * @param match |
| * the given NotLoadedFragmentMatch. |
| * @return the resource's name associated with the data of the given NotLoadedFragmentMatch. |
| */ |
| public static String getResourceName(NotLoadedFragmentMatch match) { |
| final String name; |
| Collection<? extends Match> children = match.getChildren(); |
| if (Iterables.size(children) == 1) { |
| URI uri = getDataURI(children.iterator().next()); |
| name = uri.lastSegment(); |
| } else { |
| name = ""; //$NON-NLS-1$ |
| } |
| return name; |
| } |
| |
| /** |
| * Filters, from the root matches of the given comparison, those who will children matches of the given |
| * match if all fragments of the whole models involved in comparison had been loaded, for the given side |
| * of the comparison. |
| * |
| * @param comparison |
| * the given comparison, cannot be <code>null</code>. |
| * @param match |
| * the given match, can be <code>null</code>. |
| * @param side |
| * the given side of the comparison. |
| * @return a list of Matches. |
| */ |
| public static Collection<Match> getChildrenMatchWithNotLoadedParent(Comparison comparison, Match match, |
| MergeViewerSide side) { |
| if (match == null) { |
| return emptyList(); |
| } |
| final Collection<Match> childrenMatches = Sets.newLinkedHashSet(); |
| final Collection<Match> matches = comparison.getMatches(); |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| if (graph == null) { |
| return childrenMatches; |
| } |
| ResourceSet rs = getDataResourceSet(match, side); |
| if (rs == null) { |
| return childrenMatches; |
| } |
| for (Match rootMatch : matches) { |
| if (isFragment(rootMatch, side)) { |
| URI uri = getDataURI(rootMatch, side); |
| Resource resourceParent = getParent(rs, uri); |
| URI parentData = graph.getParentData(uri); |
| boolean _continue = true; |
| while (resourceParent == null && _continue == true) { |
| if (parentData != null) { |
| resourceParent = getParent(rs, parentData.trimFragment()); |
| parentData = graph.getParentData(parentData.trimFragment()); |
| } else { |
| _continue = false; |
| } |
| } |
| if (resourceParent != null && parentData != null) { |
| EObject eObjectParent = resourceParent.getEObject(parentData.fragment()); |
| Match matchParent = match.getComparison().getMatch(eObjectParent); |
| if (matchParent != null && matchParent.equals(match)) { |
| childrenMatches.add(rootMatch); |
| } |
| } |
| } |
| } |
| return childrenMatches; |
| } |
| |
| /** |
| * Check if the given URI is a child (directly or not) of one of the given list of URIs. |
| * |
| * @param uri |
| * the given URI. |
| * @param uris |
| * the given list of URIs. |
| * @return true if the given URI is a child (directly or not) of one of the given list of URIs, false |
| * otherwise. |
| */ |
| public static boolean isChildOf(URI uri, Collection<URI> uris) { |
| final IGraphView<URI> graph = getResourcesURIGraph(); |
| URI parentData = graph.getParentData(uri); |
| while (parentData != null) { |
| URI parent = parentData.trimFragment(); |
| if (uris.contains(parent)) { |
| return true; |
| } |
| parentData = graph.getParentData(parent); |
| } |
| return false; |
| } |
| |
| /** |
| * Constructs a {@link org.eclipse.emf.compare.match.impl.NotLoadedFragmentMatch} from the given |
| * {@link org.eclipse.emf.compare.Match} and then return the |
| * {@link org.eclipse.emf.compare.rcp.ui.mergeviewer.item.IMergeViewerItem} corresponding to this |
| * NotLoadedFragmentMatch. |
| * |
| * @param match |
| * the given Match. |
| * @param side |
| * the side of the Match. |
| * @param comparison |
| * the comparison object that contains the Match. |
| * @param adapterFactory |
| * the adapter factory used to create the merge viewer item. |
| * @return an IMergeViewerItem. |
| */ |
| public static IMergeViewerItem createItemForNotLoadedFragmentMatch(Match match, MergeViewerSide side, |
| Comparison comparison, AdapterFactory adapterFactory) { |
| final MergeViewerItem.Container container; |
| ResourceSet rs = getDataResourceSet(match, side); |
| URI uri = getDataURI(match, side); |
| EObject firstLoadedParent = getEObjectParent(rs, uri); |
| if (firstLoadedParent == null) { |
| NotLoadedFragmentMatch notLoadedFragmentMatch = new NotLoadedFragmentMatch(match); |
| container = new MergeViewerItem.Container(comparison, null, notLoadedFragmentMatch, |
| notLoadedFragmentMatch, notLoadedFragmentMatch, side, adapterFactory); |
| } else if (isRootResource(firstLoadedParent.eResource().getURI())) { |
| Match matchParent = comparison.getMatch(firstLoadedParent); |
| if (matchParent != null) { |
| if (!comparison.getMatches().contains(matchParent)) { |
| container = new MergeViewerItem.Container(comparison, null, match.getLeft(), |
| match.getRight(), match.getOrigin(), side, adapterFactory); |
| } else { |
| container = null; |
| } |
| } else { |
| NotLoadedFragmentMatch notLoadedFragmentMatch = new NotLoadedFragmentMatch(match); |
| container = new MergeViewerItem.Container(comparison, null, notLoadedFragmentMatch, |
| notLoadedFragmentMatch, notLoadedFragmentMatch, side, adapterFactory); |
| } |
| } else { |
| container = null; |
| } |
| return container; |
| } |
| |
| /** |
| * Adds a new parent container to the given list of IMergeViewerItems if needed and returns it. If the |
| * given items don't need a new parent, return null. |
| * |
| * @param items |
| * the given IMergeViewerItems. |
| * @param side |
| * the side of the Match. |
| * @param comparison |
| * the comparison object that contains the Match. |
| * @param adapterFactory |
| * the adapter factory used to create the merge viewer item. |
| * @return an IMergeViewerItem, or null. |
| */ |
| public static IMergeViewerItem addNewContainerForNotLoadedFragmentMatches( |
| Collection<IMergeViewerItem> items, MergeViewerSide side, Comparison comparison, |
| AdapterFactory adapterFactory) { |
| final MergeViewerItem.Container newContainer; |
| final Collection<Match> notLoadedFragmentMatches = getNotLoadedFragmentMatches(items); |
| if (notLoadedFragmentMatches.size() > 1) { |
| // Need to replace by top-container NotLoadedFragment item |
| NotLoadedFragmentMatch notLoadedFragmentMatch = new NotLoadedFragmentMatch( |
| notLoadedFragmentMatches); |
| for (NotLoadedFragmentMatch match : filter(notLoadedFragmentMatches, |
| NotLoadedFragmentMatch.class)) { |
| match.setName(getResourceName(match)); |
| } |
| newContainer = new MergeViewerItem.Container(comparison, null, notLoadedFragmentMatch, |
| notLoadedFragmentMatch, notLoadedFragmentMatch, side, adapterFactory); |
| } else { |
| newContainer = null; |
| } |
| return newContainer; |
| } |
| } |