Find/replace: keep find/replace input state in FindReplaceLogic

The FindReplaceLogic is a stateful representation of a search context
for a search target. It currently already has a state of the used search
options. Still, the find and replace string used for performing
operations on the target are passed to each operation instead of keeping
it in the logic object itself. Keeping this information in the logic
object simplifies its interface and allows to encapsulate more of the
incremental logic in the logic class, as it then has the information
about when the search input changes. In addition, it works towards a
clear model (logic) and view (dialog/overlay) separation.

This change adds the find and replace input string state to the
FindReplaceLogic class and simplifies its interface accordingly.

Author: HeikoKlare

bundles/org.eclipse.ui.workbench.texteditor/src/org/eclipse/ui/internal/findandreplace/FindReplaceLogic.java

@@ -17,6 +17,7 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -54,6 +55,22 @@ public class FindReplaceLogic implements IFindReplaceLogic {
 	private boolean isTargetEditable;
 	private Set<SearchOptions> searchOptions = new HashSet<>();
 
+	private String findString = ""; //$NON-NLS-1$
+	private String replaceString = ""; //$NON-NLS-1$
+
+	@Override
+	public void setFindString(String findString) {
+		this.findString = Objects.requireNonNull(findString);
+		if (isIncrementalSearchAvailable() && isActive(SearchOptions.INCREMENTAL)) {
+			performSearch(true);
+		}
+	}
+
+	@Override
+	public void setReplaceString(String replaceString) {
+		this.replaceString = Objects.requireNonNull(replaceString);
+	}
+
 	@Override
 	public void activate(SearchOptions searchOption) {
 		if (!searchOptions.add(searchOption)) {
@@ -118,7 +135,7 @@ public boolean isIncrementalSearchAvailable() {
 	}
 
 	@Override
-	public boolean isWholeWordSearchAvailable(String findString) {
+	public boolean isWholeWordSearchAvailable() {
 		return !isRegExSearchAvailableAndActive() && isWord(findString);
 	}
 	/**
@@ -213,12 +230,12 @@ private IEditorStatusLine getStatusLineManager() {
 	}
 
 	@Override
-	public void performReplaceAll(String findString, String replaceString) {
+	public void performReplaceAll() {
 		resetStatus();
 
 		if (findString != null && !findString.isEmpty()) {
 			try {
-				int replaceCount = replaceAll(findString, replaceString == null ? "" : replaceString); //$NON-NLS-1$
+				int replaceCount = replaceAll();
 				if (replaceCount != 0) {
 					if (replaceCount == 1) { // not plural
 						statusLineMessage(FindReplaceMessages.FindReplace_Status_replacement_label);
@@ -243,12 +260,12 @@ public void performReplaceAll(String findString, String replaceString) {
 	}
 
 	@Override
-	public void performSelectAll(String findString) {
+	public void performSelectAll() {
 		resetStatus();
 
 		if (findString != null && !findString.isEmpty()) {
 			try {
-				int selectCount = selectAll(findString);
+				int selectCount = selectAll();
 				if (selectCount != 0) {
 					if (selectCount == 1) { // not plural
 						statusLineMessage(FindReplaceMessages.FindReplace_Status_selection_label);
@@ -293,43 +310,12 @@ private boolean prepareTargetForEditing() {
 		return isEditable();
 	}
 
-	/**
-	 * Replaces the current selection of the target with the user's replace string.
-	 *
-	 * @param replaceString the String to replace the selection with
-	 *
-	 * @return <code>true</code> if the operation was successful
-	 */
-	private boolean replaceSelection(String replaceString) {
-
-		if (!prepareTargetForEditing()) {
-			return false;
-		}
-
-		if (replaceString == null) {
-			replaceString = ""; //$NON-NLS-1$
-		}
-
-		boolean replaced;
-		try {
-			replaceSelection(replaceString, isRegExSearchAvailableAndActive());
-			replaced = true;
-		} catch (PatternSyntaxException ex) {
-			status = new InvalidRegExStatus(ex);
-			replaced = false;
-		} catch (IllegalStateException ex) {
-			replaced = false;
-		}
-
-		return replaced;
-	}
-
 	@Override
-	public boolean performSearch(String findString) {
-		return performSearch(findString, true);
+	public boolean performSearch() {
+		return performSearch(true);
 	}
 
-	private boolean performSearch(String findString, boolean validateSearchOptions) {
+	private boolean performSearch(boolean validateSearchOptions) {
 		resetStatus();
 
 		if (validateSearchOptions && (isActive(SearchOptions.INCREMENTAL) && !isIncrementalSearchAvailable())) {
@@ -340,7 +326,7 @@ private boolean performSearch(String findString, boolean validateSearchOptions)
 		if (findString != null && !findString.isEmpty()) {
 
 			try {
-				somethingFound = findNext(findString);
+				somethingFound = findNext();
 			} catch (PatternSyntaxException ex) {
 				status = new InvalidRegExStatus(ex);
 			} catch (IllegalStateException ex) {
@@ -354,13 +340,10 @@ private boolean performSearch(String findString, boolean validateSearchOptions)
 	 * Replaces all occurrences of the user's findString with the replace string.
 	 * Returns the number of replacements that occur.
 	 *
-	 * @param findString    the string to search for
-	 * @param replaceString the replacement string
-	 *                      expression
 	 * @return the number of occurrences
 	 *
 	 */
-	private int replaceAll(String findString, String replaceString) {
+	private int replaceAll() {
 		if (!prepareTargetForEditing()) {
 			return 0;
 		}
@@ -369,8 +352,8 @@ private int replaceAll(String findString, String replaceString) {
 		executeInForwardMode(() -> {
 			executeWithReplaceAllEnabled(() -> {
 				Point currentSelection = new Point(0, 0);
-				while (findAndSelect(currentSelection.x + currentSelection.y, findString) != -1) {
-					currentSelection = replaceSelection(replaceString, isRegExSearchAvailableAndActive());
+				while (findAndSelect(currentSelection.x + currentSelection.y) != -1) {
+					currentSelection = replaceSelection();
 					replacements.add(currentSelection);
 				}
 			});
@@ -405,14 +388,13 @@ private void executeWithReplaceAllEnabled(Runnable runnable) {
 	}
 
 	/**
-	 * @param findString the string to select as part of the search
 	 * @return the number of selected elements
 	 */
-	private int selectAll(String findString) {
+	private int selectAll() {
 		List<Point> selections = new ArrayList<>();
 		executeInForwardMode(() -> {
 			Point currentSeletion = new Point(0, 0);
-			while (findAndSelect(currentSeletion.x + currentSeletion.y, findString) != -1) {
+			while (findAndSelect(currentSeletion.x + currentSeletion.y) != -1) {
 				currentSeletion = target.getSelection();
 				selections.add(currentSeletion);
 			}
@@ -429,26 +411,25 @@ private int selectAll(String findString) {
 	 * Returns the position of the specified search string, or <code>-1</code> if
 	 * the string can not be found when searching using the given options.
 	 *
-	 * @param findString    the string to search for
 	 * @param startPosition the position at which to start the search
 	 * @return the occurrence of the find string following the options or
 	 *         <code>-1</code> if nothing found
 	 */
-	private int findIndex(String findString, int startPosition) {
+	private int findIndex(int startPosition) {
 		int index = 0;
 		if (isActive(SearchOptions.FORWARD)) {
-			index = findAndSelect(startPosition, findString);
+			index = findAndSelect(startPosition);
 		} else {
 			index = startPosition == 0 ? -1
-				: findAndSelect(startPosition - 1, findString);
+					: findAndSelect(startPosition - 1);
 		}
 
 		if (index == -1) {
 
 			if (isActive(SearchOptions.WRAP)) {
 				statusLineMessage(FindReplaceMessages.FindReplace_Status_wrapped_label);
 				status = new FindStatus(FindStatus.StatusCode.WRAPPED);
-				index = findAndSelect(-1, findString);
+				index = findAndSelect(-1);
 			} else {
 				status = new FindStatus(FindStatus.StatusCode.NO_MATCH);
 			}
@@ -457,8 +438,8 @@ private int findIndex(String findString, int startPosition) {
 	}
 
 	@Override
-	public int findAndSelect(int offset, String findString) {
-		boolean wholeWordSearch = isActive(SearchOptions.WHOLE_WORD) && isWholeWordSearchAvailable(findString);
+	public int findAndSelect(int offset) {
+		boolean wholeWordSearch = isActive(SearchOptions.WHOLE_WORD) && isWholeWordSearchAvailable();
 		boolean forwardSearch = isActive(SearchOptions.FORWARD);
 		boolean caseSensitiveSearch = isActive(SearchOptions.CASE_SENSITIVE);
 		boolean regexSearch = isActive(SearchOptions.REGEX);
@@ -473,20 +454,17 @@ public int findAndSelect(int offset, String findString) {
 	}
 
 	/**
-	 * Replaces the selection with <code>replaceString</code>. If
-	 * <code>regExReplace</code> is <code>true</code>, <code>replaceString</code> is
-	 * a regex replace pattern which will get expanded if the underlying target
-	 * supports it. Returns the region of the inserted text; note that the returned
-	 * selection covers the expanded pattern in case of regex replace.
+	 * Replaces the selection with the current replace string. If the regex search
+	 * option has been activated, the replace string is considered as regex replace
+	 * pattern which will get expanded if the underlying target supports it. Returns
+	 * the region of the inserted text; note that the returned selection covers the
+	 * expanded pattern in case of regex replace.
 	 *
-	 * @param replaceString the replace string (or a regex pattern)
-	 * @param regExReplace  <code>true</code> if <code>replaceString</code> is a
-	 *                      pattern
 	 * @return the selection after replacing, i.e. the inserted text
 	 */
-	private Point replaceSelection(String replaceString, boolean regExReplace) {
+	private Point replaceSelection() {
 		if (target instanceof IFindReplaceTargetExtension3)
-			((IFindReplaceTargetExtension3) target).replaceSelection(replaceString, regExReplace);
+			((IFindReplaceTargetExtension3) target).replaceSelection(replaceString, isRegExSearchAvailableAndActive());
 		else
 			target.replaceSelection(replaceString);
 
@@ -497,20 +475,19 @@ private Point replaceSelection(String replaceString, boolean regExReplace) {
 	 * Returns whether the specified search string can be found using the given
 	 * options.
 	 *
-	 * @param findString             the string to search for
 	 * @return <code>true</code> if the search string can be found using the given
 	 *         options
 	 *
 	 */
-	private boolean findNext(String findString) {
+	private boolean findNext() {
 
 		if (target == null) {
 			return false;
 		}
 
 		int findReplacePosition = calculateFindBeginningOffset();
 
-		int index = findIndex(findString, findReplacePosition);
+		int index = findIndex(findReplacePosition);
 
 		if (index == -1) {
 			String msg = NLSUtility.format(FindReplaceMessages.FindReplace_Status_noMatchWithValue_label, findString);
@@ -544,28 +521,37 @@ private int calculateFindBeginningOffset() {
 	}
 
 	@Override
-	public boolean performReplaceAndFind(String findString, String replaceString) {
+	public boolean performReplaceAndFind() {
 		resetStatus();
-		if (performSelectAndReplace(findString, replaceString)) {
-			performSearch(findString, false);
+		if (performSelectAndReplace()) {
+			performSearch(false);
 			return true;
 		}
 		return false;
 	}
 
 	@Override
-	public boolean performSelectAndReplace(String findString, String replaceString) {
+	public boolean performSelectAndReplace() {
 		resetStatus();
-		if (!isFindStringSelected(findString)) {
-			performSearch(findString, false);
+		if (!isFindStringSelected()) {
+			performSearch(false);
 		}
 		if (getStatus().wasSuccessful()) {
-			return replaceSelection(replaceString);
+			if (!prepareTargetForEditing()) {
+				return false;
+			}
+			try {
+				replaceSelection();
+				return true;
+			} catch (PatternSyntaxException ex) {
+				status = new InvalidRegExStatus(ex);
+			} catch (IllegalStateException ex) {
+			}
 		}
 		return false;
 	}
 
-	private boolean isFindStringSelected(String findString) {
+	private boolean isFindStringSelected() {
 		String selectedString = getCurrentSelection();
 		if (isRegExSearchAvailableAndActive()) {
 			int patternFlags = 0;