Performance - use streams instead of guava iterations/concatenation

Change-Id: I7164c42ddd79d0a0061ff70ea01899da75bcf429

7 files changed, 72 insertions, 118 deletions

diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/EMFCompareStructureMergeViewer.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/EMFCompareStructureMergeViewer.java
index 0f3f2a2e3..e541a1129 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/EMFCompareStructureMergeViewer.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/EMFCompareStructureMergeViewer.java
@@ -22,7 +22,6 @@ import static org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.EMFCo
 
 import com.google.common.base.Function;
 import com.google.common.base.Objects;
-import com.google.common.base.Predicate;
 import com.google.common.base.Throwables;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Iterators;
@@ -43,6 +42,7 @@ import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
+import java.util.function.Predicate;
 
 import org.eclipse.compare.CompareUI;
 import org.eclipse.compare.CompareViewerPane;
@@ -662,7 +662,7 @@ public class EMFCompareStructureMergeViewer extends AbstractStructuredViewerWrap
 	private void addMergeNonConflictingActions(IMenuManager manager, EnumSet<MergeMode> modes,
 			IMerger.Registry mergerRegistry) {
 		final Predicate<TreeNode> filterPredicate = new Predicate<TreeNode>() {
-			public boolean apply(TreeNode input) {
+			public boolean test(TreeNode input) {
 				return input != null && JFaceUtil.isFiltered(getViewer(), input, input.getParent());
 			}
 		};
@@ -689,7 +689,7 @@ public class EMFCompareStructureMergeViewer extends AbstractStructuredViewerWrap
 	private void addMergeConflictingActions(IMenuManager manager, EnumSet<MergeMode> modes,
 			IMerger.Registry mergerRegistry) {
 		final Predicate<TreeNode> filterPredicate = new Predicate<TreeNode>() {
-			public boolean apply(TreeNode input) {
+			public boolean test(TreeNode input) {
 				return input != null && JFaceUtil.isFiltered(getViewer(), input, input.getParent());
 			}
 		};
@@ -715,7 +715,7 @@ public class EMFCompareStructureMergeViewer extends AbstractStructuredViewerWrap
 	private void addMergeAllActions(IMenuManager manager, EnumSet<MergeMode> modes,
 			IMerger.Registry mergerRegistry) {
 		final Predicate<TreeNode> filterPredicate = new Predicate<TreeNode>() {
-			public boolean apply(TreeNode input) {
+			public boolean test(TreeNode input) {
 				return input != null && JFaceUtil.isFiltered(getViewer(), input, input.getParent());
 			}
 		};
@@ -2245,11 +2245,12 @@ public class EMFCompareStructureMergeViewer extends AbstractStructuredViewerWrap
 		public TitleBuilder(EMFCompareConfiguration configuration) {
 			comparison = configuration.getComparison();
 			groupProvider = configuration.getStructureMergeViewerGrouper().getProvider();
-			filterPredicate = configuration.getStructureMergeViewerFilter().getAggregatedPredicate();
+			filterPredicate = EMFComparePredicates
+					.guavaToJava(configuration.getStructureMergeViewerFilter().getAggregatedPredicate());
 		}
 
 		void visit(TreeNode node, boolean parentApplies) {
-			boolean applies = parentApplies && filterPredicate.apply(node);
+			boolean applies = parentApplies && filterPredicate.test(node);
 			EObject data = node.getData();
 			if (data instanceof Diff) {
 				// If we haven't visited it before...
diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/AbstractMergeContainedAction.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/AbstractMergeContainedAction.java
index 1d1e9d0cd..1cc16e721 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/AbstractMergeContainedAction.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/AbstractMergeContainedAction.java
@@ -10,28 +10,20 @@
  *******************************************************************************/
 package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions;
 
-import static com.google.common.collect.Iterables.concat;
-import static com.google.common.collect.Iterables.filter;
-import static com.google.common.collect.Iterables.transform;
-
-import com.google.common.base.Function;
-import com.google.common.base.Predicate;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableList.Builder;
-import com.google.common.collect.Lists;
-
 import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.eclipse.compare.INavigatable;
 import org.eclipse.emf.common.notify.Adapter;
-import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.common.util.TreeIterator;
 import org.eclipse.emf.compare.Diff;
 import org.eclipse.emf.compare.internal.merge.MergeMode;
 import org.eclipse.emf.compare.merge.IMerger.Registry;
 import org.eclipse.emf.compare.rcp.ui.internal.configuration.IEMFCompareConfiguration;
 import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.provider.GroupItemProviderAdapter;
-import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroup;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.edit.tree.TreeNode;
 import org.eclipse.jface.viewers.IStructuredSelection;
@@ -47,18 +39,17 @@ public abstract class AbstractMergeContainedAction extends MergeAction {
 	/**
 	 * Function for transforming a tree node into all non-filtered leaf differences.
 	 */
-	private static Function<TreeNode, Iterable<Diff>> treeNodesToLeafDiffs(
+	private static Function<TreeNode, Stream<Diff>> treeNodesToLeafDiffs(
 			final Predicate<TreeNode> isFiltered) {
-		return new Function<TreeNode, Iterable<Diff>>() {
-			public Iterable<Diff> apply(TreeNode input) {
+		return new Function<TreeNode, Stream<Diff>>() {
+			public Stream<Diff> apply(TreeNode input) {
 				final TreeIterator<EObject> allContents = input.eAllContents();
-				final Builder<Diff> builder = new ImmutableList.Builder<Diff>();
+				final Stream.Builder<Diff> builder = Stream.builder();
 				while (allContents.hasNext()) {
 					final EObject eObject = allContents.next();
-					if (eObject instanceof TreeNode) {
-						final TreeNode treeNode = (TreeNode)eObject;
-						final EObject data = IDifferenceGroup.TREE_NODE_DATA.apply(treeNode);
-						if (data instanceof Diff && !isFiltered.apply(treeNode)) {
+					if (eObject instanceof TreeNode && !isFiltered.test((TreeNode)eObject)) {
+						final EObject data = ((TreeNode)eObject).getData();
+						if (data instanceof Diff) {
 							builder.add((Diff)data);
 						}
 					}
@@ -101,22 +92,21 @@ public abstract class AbstractMergeContainedAction extends MergeAction {
 	}
 
 	@Override
-	protected Iterable<Diff> getSelectedDifferences(IStructuredSelection selection) {
-		final List<?> selectedObjects = selection.toList();
+	protected List<Diff> getSelectedDifferences(IStructuredSelection selection) {
 		Object firstElement = selection.getFirstElement();
-		if (selection.getFirstElement() instanceof GroupItemProviderAdapter) {
-			final List<Object> effectiveSelectedObjects = Lists.newArrayList();
-			effectiveSelectedObjects
-					.addAll(((GroupItemProviderAdapter)firstElement).getChildren(firstElement));
-			final Iterable<TreeNode> selectedTreeNodes = filter(effectiveSelectedObjects, TreeNode.class);
-			Iterable<Diff> diffs = concat(transform(selectedTreeNodes, treeNodesToLeafDiffs(isFiltered)));
-			return filter(getSelectedDifferences(diffs), getDiffPredicate());
+		if (firstElement instanceof GroupItemProviderAdapter) {
+			Stream<Diff> diffs = ((GroupItemProviderAdapter)firstElement).getChildren(firstElement).stream()
+					.filter(TreeNode.class::isInstance).map(TreeNode.class::cast)
+					.flatMap(treeNodesToLeafDiffs(isFiltered));
+			return getSelectedDifferences(diffs).stream().filter(getDiffPredicate())
+					.collect(Collectors.toList());
 		} else {
-			final Iterable<Adapter> selectedAdapters = filter(selectedObjects, Adapter.class);
-			final Iterable<Notifier> selectedNotifiers = transform(selectedAdapters, ADAPTER__TARGET);
-			final Iterable<TreeNode> selectedTreeNodes = filter(selectedNotifiers, TreeNode.class);
-			Iterable<Diff> diffs = concat(transform(selectedTreeNodes, treeNodesToLeafDiffs(isFiltered)));
-			return filter(getSelectedDifferences(diffs), getDiffPredicate());
+			final List<?> selectedObjects = selection.toList();
+			Stream<Diff> diffs = selectedObjects.stream().filter(Adapter.class::isInstance)
+					.map(adapter -> ((Adapter)adapter).getTarget()).filter(TreeNode.class::isInstance)
+					.map(TreeNode.class::cast).flatMap(treeNodesToLeafDiffs(isFiltered));
+			return getSelectedDifferences(diffs).stream().filter(getDiffPredicate())
+					.collect(Collectors.toList());
 		}
 	}
 
diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAction.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAction.java
index 9bf5b7b36..f3dd0ab0c 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAction.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAction.java
@@ -13,11 +13,6 @@
  *******************************************************************************/
 package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions;
 
-import static com.google.common.collect.Iterables.addAll;
-import static com.google.common.collect.Iterables.any;
-import static com.google.common.collect.Iterables.filter;
-import static com.google.common.collect.Iterables.isEmpty;
-import static com.google.common.collect.Iterables.transform;
 import static com.google.common.collect.Lists.newArrayList;
 import static org.eclipse.emf.compare.DifferenceSource.LEFT;
 import static org.eclipse.emf.compare.DifferenceSource.RIGHT;
@@ -28,18 +23,17 @@ import static org.eclipse.emf.compare.internal.merge.MergeMode.LEFT_TO_RIGHT;
 import static org.eclipse.emf.compare.internal.merge.MergeMode.REJECT;
 import static org.eclipse.emf.compare.internal.merge.MergeMode.RIGHT_TO_LEFT;
 
-import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
-import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -48,7 +42,6 @@ import org.eclipse.emf.common.command.Command;
 import org.eclipse.emf.common.command.CompoundCommand;
 import org.eclipse.emf.common.notify.Adapter;
 import org.eclipse.emf.common.notify.AdapterFactory;
-import org.eclipse.emf.common.notify.Notifier;
 import org.eclipse.emf.compare.Diff;
 import org.eclipse.emf.compare.DifferenceSource;
 import org.eclipse.emf.compare.DifferenceState;
@@ -70,8 +63,6 @@ import org.eclipse.emf.compare.merge.IMerger;
 import org.eclipse.emf.compare.merge.IMerger.Registry;
 import org.eclipse.emf.compare.provider.ITooltipLabelProvider;
 import org.eclipse.emf.compare.rcp.ui.internal.configuration.IEMFCompareConfiguration;
-import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.groups.IDifferenceGroup;
-import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.edit.tree.TreeNode;
 import org.eclipse.jface.dialogs.MessageDialog;
 import org.eclipse.jface.viewers.IStructuredSelection;
@@ -87,24 +78,6 @@ import org.eclipse.ui.plugin.AbstractUIPlugin;
  */
 public class MergeAction extends BaseSelectionListenerAction {
 
-	private static final Predicate<Diff> IS_IN_TERMINAL_STATE = new Predicate<Diff>() {
-		public boolean apply(Diff diff) {
-			return AbstractMerger.isInTerminalState(diff);
-		}
-	};
-
-	private static final Predicate<Diff> IS_NOT_IN_TERMINAL_STATE = new Predicate<Diff>() {
-		public boolean apply(Diff diff) {
-			return !AbstractMerger.isInTerminalState(diff);
-		}
-	};
-
-	protected static final Function<? super Adapter, ? extends Notifier> ADAPTER__TARGET = new Function<Adapter, Notifier>() {
-		public Notifier apply(Adapter adapter) {
-			return adapter.getTarget();
-		}
-	};
-
 	protected final Registry mergerRegistry;
 
 	protected ICompareEditingDomain editingDomain;
@@ -282,7 +255,8 @@ public class MergeAction extends BaseSelectionListenerAction {
 				// If selected diffs are still in the terminal state we seem to be unable to process them.
 				// This should really never happen, but if some command doesn't support undo, it's possible to
 				// get in this situation.
-				if (any(selectedDifferences, IS_IN_TERMINAL_STATE)) {
+
+				if (selectedDifferences.stream().anyMatch(AbstractMerger::isInTerminalState)) {
 					managedCmdStack.restoreCommandStack();
 					return;
 				}
@@ -347,7 +321,7 @@ public class MergeAction extends BaseSelectionListenerAction {
 	 */
 	private class ManagedCommandStack {
 
-		private List<Multimap<DifferenceState, Diff>> diffChangesList = Lists.newArrayList();
+		private List<Multimap<DifferenceState, Diff>> diffChangesList = new ArrayList<>();
 
 		private Map<Multimap<DifferenceState, Diff>, EditCommand> editCommands = new IdentityHashMap<Multimap<DifferenceState, Diff>, EditCommand>();
 
@@ -403,7 +377,7 @@ public class MergeAction extends BaseSelectionListenerAction {
 		}
 
 		public void undoUntilDiffsAreInTerminalState(List<Diff> diffs) {
-			while (commandStack.canUndo() && any(diffs, IS_IN_TERMINAL_STATE)) {
+			while (commandStack.canUndo() && diffs.stream().anyMatch(AbstractMerger::isInTerminalState)) {
 				Command undoCommand = commandStack.getUndoCommand();
 
 				// Keep track of undone changes
@@ -478,8 +452,8 @@ public class MergeAction extends BaseSelectionListenerAction {
 			if (!diffsToRestore.values().isEmpty()) {
 				undoIfNotUndoneYet();
 
-				List<Diff> diffsToMerge = Lists.newArrayList(diffsToRestore.get(MERGED));
-				List<Diff> diffsToDiscard = Lists.newArrayList(diffsToRestore.get(DISCARDED));
+				List<Diff> diffsToMerge = new ArrayList<>(diffsToRestore.get(MERGED));
+				List<Diff> diffsToDiscard = new ArrayList<>(diffsToRestore.get(DISCARDED));
 
 				if (mode == ACCEPT || mode == REJECT) {
 					redoDiffs(diffsToMerge, diffsToDiscard, ACCEPT, REJECT);
@@ -567,13 +541,14 @@ public class MergeAction extends BaseSelectionListenerAction {
 	 */
 	@Override
 	protected boolean updateSelection(IStructuredSelection selection) {
-		addAll(selectedDifferences, getSelectedDifferences(selection));
+		getSelectedDifferences().addAll(getSelectedDifferences(selection));
 		if (this.adapterFactory != null) {
 			contextualizeTooltip();
 		}
 		// The action is enabled only if all the elements in the selection are diffs that will change state
 		// when this action is applied.
-		return !selectedDifferences.isEmpty() && selection.toList().size() == selectedDifferences.size();
+		return !getSelectedDifferences().isEmpty()
+				&& selection.toList().size() == getSelectedDifferences().size();
 	}
 
 	/**
@@ -586,22 +561,17 @@ public class MergeAction extends BaseSelectionListenerAction {
 		selectedDifferences.clear();
 	}
 
-	protected Iterable<Diff> getSelectedDifferences(IStructuredSelection selection) {
+	protected List<Diff> getSelectedDifferences(IStructuredSelection selection) {
 		List<?> selectedObjects = selection.toList();
-		Iterable<Adapter> selectedAdapters = filter(selectedObjects, Adapter.class);
-		Iterable<Notifier> selectedNotifiers = transform(selectedAdapters, ADAPTER__TARGET);
-		Iterable<TreeNode> selectedTreeNode = filter(selectedNotifiers, TreeNode.class);
-		Iterable<EObject> selectedEObjects = transform(selectedTreeNode, IDifferenceGroup.TREE_NODE_DATA);
-		Iterable<Diff> diffs = filter(selectedEObjects, Diff.class);
-		if (isEmpty(diffs)) {
-			diffs = filter(selectedObjects, Diff.class);
-		}
-		return getSelectedDifferences(diffs);
+		Stream<Diff> selectedDiffs = selectedObjects.stream().filter(Adapter.class::isInstance)
+				.map(adapter -> ((Adapter)adapter).getTarget()).filter(TreeNode.class::isInstance)
+				.map(node -> ((TreeNode)node).getData()).filter(Diff.class::isInstance).map(Diff.class::cast);
+		return getSelectedDifferences(selectedDiffs);
 	}
 
 	protected Predicate<Diff> getStatePredicate() {
 		return new Predicate<Diff>() {
-			public boolean apply(Diff diff) {
+			public boolean test(Diff diff) {
 				switch (diff.getState()) {
 					case DISCARDED:
 						switch (getSelectedMode()) {
@@ -633,18 +603,18 @@ public class MergeAction extends BaseSelectionListenerAction {
 		};
 	}
 
-	protected Iterable<Diff> getSelectedDifferences(Iterable<Diff> diffs) {
+	protected List<Diff> getSelectedDifferences(Stream<Diff> diffs) {
 		ICompareCommandStack commandStack = editingDomain.getCommandStack();
 
 		// We can only re-process diffs in the terminal state if we have a command stack that supports
 		// suspending the delivery of notifications. So filter out diffs that are already in the terminal
 		// state.
 		if (!(commandStack instanceof TransactionalDualCompareCommandStack)) {
-			return filter(diffs, IS_NOT_IN_TERMINAL_STATE);
+			return diffs.filter(diff -> !AbstractMerger.isInTerminalState(diff)).collect(Collectors.toList());
 		}
 
 		// Filter out diffs whose state would not be changed by this actions's selected mode.
-		return filter(diffs, getStatePredicate());
+		return diffs.filter(getStatePredicate()).collect(Collectors.toList());
 	}
 
 	/**
@@ -681,7 +651,7 @@ public class MergeAction extends BaseSelectionListenerAction {
 	 * 
 	 * @return The cached selected differences.
 	 */
-	public List<Diff> getSelectedDifferences() {
+	protected List<Diff> getSelectedDifferences() {
 		return selectedDifferences;
 	}
 
diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAllNonConflictingAction.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAllNonConflictingAction.java
index 588d1560c..bd80f6c08 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAllNonConflictingAction.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeAllNonConflictingAction.java
@@ -13,14 +13,13 @@
  *******************************************************************************/
 package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions;
 
-import static com.google.common.collect.Iterables.addAll;
-import static com.google.common.collect.Iterables.filter;
 import static org.eclipse.emf.compare.ConflictKind.REAL;
-
-import com.google.common.base.Predicate;
+import static org.eclipse.emf.compare.utils.EMFComparePredicates.guavaToJava;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
@@ -47,10 +46,6 @@ import org.eclipse.ui.plugin.AbstractUIPlugin;
  */
 public class MergeAllNonConflictingAction extends MergeAction {
 
-	@SuppressWarnings("unchecked")
-	private static final Predicate<Diff> NON_CONFLICTING_DIFFS = (Predicate<Diff>)EMFComparePredicates
-			.hasNoDirectOrIndirectConflict(REAL);
-
 	private Comparison comparison;
 
 	private List<Diff> differences;
@@ -135,15 +130,17 @@ public class MergeAllNonConflictingAction extends MergeAction {
 	 */
 	@Override
 	protected boolean updateSelection(IStructuredSelection selection) {
-		addAll(getSelectedDifferences(), getSelectedDifferences(differences));
-		// The action is enabled only there are any selected differences that will change state when this
+		getSelectedDifferences().addAll(getSelectedDifferences(differences.stream()));
+		// The action is enabled only if there are any selected differences that will change state when this
 		// action is applied.
 		return !getSelectedDifferences().isEmpty();
 	}
 
 	@Override
-	protected Iterable<Diff> getSelectedDifferences(Iterable<Diff> diffs) {
-		return filter(super.getSelectedDifferences(diffs), NON_CONFLICTING_DIFFS);
+	protected List<Diff> getSelectedDifferences(Stream<Diff> diffs) {
+		return super.getSelectedDifferences(diffs).stream()
+				.filter(guavaToJava(EMFComparePredicates.hasNoDirectOrIndirectConflict(REAL)))
+				.collect(Collectors.toList());
 	}
 
 }
diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedAction.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedAction.java
index d6a2ead64..88b10ed0b 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedAction.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedAction.java
@@ -15,7 +15,7 @@ import static org.eclipse.emf.compare.DifferenceSource.RIGHT;
 import static org.eclipse.emf.compare.internal.merge.MergeMode.ACCEPT;
 import static org.eclipse.emf.compare.internal.merge.MergeMode.LEFT_TO_RIGHT;
 
-import com.google.common.base.Predicate;
+import java.util.function.Predicate;
 
 import org.eclipse.compare.INavigatable;
 import org.eclipse.emf.compare.Diff;
@@ -78,7 +78,7 @@ public class MergeContainedAction extends AbstractMergeContainedAction {
 	@Override
 	protected Predicate<Diff> getDiffPredicate() {
 		return new Predicate<Diff>() {
-			public boolean apply(Diff input) {
+			public boolean test(Diff input) {
 				final DifferenceSource sourceSide;
 				if (LEFT_TO_RIGHT.equals(getSelectedMode()) || ACCEPT.equals(getSelectedMode())) {
 					sourceSide = LEFT;
diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedConflictingAction.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedConflictingAction.java
index a15b808bc..127e3b854 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedConflictingAction.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedConflictingAction.java
@@ -11,8 +11,9 @@
 package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions;
 
 import static org.eclipse.emf.compare.ConflictKind.REAL;
+import static org.eclipse.emf.compare.utils.EMFComparePredicates.guavaToJava;
 
-import com.google.common.base.Predicate;
+import java.util.function.Predicate;
 
 import org.eclipse.compare.INavigatable;
 import org.eclipse.emf.compare.Diff;
@@ -38,10 +39,6 @@ import org.eclipse.ui.plugin.AbstractUIPlugin;
  */
 public class MergeContainedConflictingAction extends AbstractMergeContainedAction {
 
-	@SuppressWarnings("unchecked")
-	private static final Predicate<Diff> CONFLICTING_DIFFS = (Predicate<Diff>)EMFComparePredicates
-			.hasDirectOrIndirectConflict(REAL);
-
 	/**
 	 * {@inheritDoc}
 	 * 
@@ -97,15 +94,16 @@ public class MergeContainedConflictingAction extends AbstractMergeContainedActio
 		return new MergeConflictingRunnable(isLeftEditable, isRightEditable, mode, relationshipComputer);
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	protected Predicate<Diff> getDiffPredicate() {
-		return CONFLICTING_DIFFS;
+		return (Predicate<Diff>)guavaToJava(EMFComparePredicates.hasDirectOrIndirectConflict(REAL));
 	}
 
 	@Override
 	protected Predicate<Diff> getStatePredicate() {
 		return new Predicate<Diff>() {
-			public boolean apply(Diff diff) {
+			public boolean test(Diff diff) {
 				switch (diff.getState()) {
 					case DISCARDED:
 						switch (getSelectedMode()) {
diff --git a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedNonConflictingAction.java b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedNonConflictingAction.java
index fcc30700b..2c80e1d94 100644
--- a/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedNonConflictingAction.java
+++ b/plugins/org.eclipse.emf.compare.ide.ui/src/org/eclipse/emf/compare/ide/ui/internal/structuremergeviewer/actions/MergeContainedNonConflictingAction.java
@@ -12,8 +12,9 @@
 package org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions;
 
 import static org.eclipse.emf.compare.ConflictKind.REAL;
+import static org.eclipse.emf.compare.utils.EMFComparePredicates.guavaToJava;
 
-import com.google.common.base.Predicate;
+import java.util.function.Predicate;
 
 import org.eclipse.compare.INavigatable;
 import org.eclipse.emf.compare.Diff;
@@ -38,10 +39,6 @@ import org.eclipse.ui.plugin.AbstractUIPlugin;
  */
 public class MergeContainedNonConflictingAction extends AbstractMergeContainedAction {
 
-	@SuppressWarnings("unchecked")
-	private static final Predicate<Diff> NON_CONFLICTING_DIFFS = (Predicate<Diff>)EMFComparePredicates
-			.hasNoDirectOrIndirectConflict(REAL);
-
 	/**
 	 * {@inheritDoc}
 	 * 
@@ -94,8 +91,9 @@ public class MergeContainedNonConflictingAction extends AbstractMergeContainedAc
 		return new MergeNonConflictingRunnable(isLeftEditable, isRightEditable, mode, relationshipComputer);
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	protected Predicate<Diff> getDiffPredicate() {
-		return NON_CONFLICTING_DIFFS;
+		return (Predicate<Diff>)guavaToJava(EMFComparePredicates.hasNoDirectOrIndirectConflict(REAL));
 	}
 }