| /******************************************************************************* |
| * Copyright (c) 2005, 2012 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.debug.core.refactoring; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.model.IBreakpoint; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.debug.core.IJavaBreakpoint; |
| import org.eclipse.jdt.debug.core.IJavaClassPrepareBreakpoint; |
| import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint; |
| import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; |
| import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint; |
| import org.eclipse.jdt.debug.core.IJavaWatchpoint; |
| import org.eclipse.ltk.core.refactoring.Change; |
| import org.eclipse.ltk.core.refactoring.CompositeChange; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext; |
| import org.eclipse.ltk.core.refactoring.participants.RenameParticipant; |
| |
| /** |
| * Breakpoint participant for a rename refactoring. |
| * |
| * @since 3.2 |
| */ |
| public abstract class BreakpointRenameParticipant extends RenameParticipant { |
| |
| /** |
| * Element being renamed |
| */ |
| private IJavaElement fElement; |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant#initialize(java.lang.Object) |
| */ |
| @Override |
| protected boolean initialize(Object element) { |
| if (element instanceof IJavaElement && accepts((IJavaElement)element)) { |
| fElement = (IJavaElement) element; |
| } else { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Returns the element this refactoring is operating on. |
| * |
| * @return to original {@link IJavaElement} |
| */ |
| protected IJavaElement getOriginalElement() { |
| return fElement; |
| } |
| |
| /** |
| * Returns whether this given element is a valid target for this operation. |
| * |
| * @param element the Java element context |
| * @return whether this given element is a valid target for this operation |
| */ |
| protected abstract boolean accepts(IJavaElement element); |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant#getName() |
| */ |
| @Override |
| public String getName() { |
| return RefactoringMessages.BreakpointRenameParticipant_0; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant#checkConditions(org.eclipse.core.runtime.IProgressMonitor, org.eclipse.ltk.core.refactoring.participants.CheckConditionsContext) |
| */ |
| @Override |
| public RefactoringStatus checkConditions(IProgressMonitor pm, CheckConditionsContext context) throws OperationCanceledException { |
| return new RefactoringStatus(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ltk.core.refactoring.participants.RefactoringParticipant#createChange(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException { |
| List<Change> changes = new ArrayList<>(); |
| IResource resource = getBreakpointContainer(); |
| IMarker[] markers= resource.findMarkers(IBreakpoint.BREAKPOINT_MARKER, true, IResource.DEPTH_INFINITE); |
| gatherChanges(markers, changes, getArguments().getNewName()); |
| if (changes.size() > 1) { |
| return new CompositeChange(RefactoringMessages.BreakpointRenameParticipant_1, changes.toArray(new Change[changes.size()])); |
| } else if (changes.size() == 1) { |
| return changes.get(0); |
| } |
| return null; |
| } |
| |
| /** |
| * Gathers refactoring specific changes. Subclasses must override. |
| * |
| * @param markers the markers |
| * @param changes the list of changes |
| * @param destName the destination name |
| * @throws CoreException if creating the changes fails |
| * @throws OperationCanceledException if the operation was cancelled |
| */ |
| protected abstract void gatherChanges(IMarker[] markers, List<Change> changes, String destName) throws CoreException, OperationCanceledException; |
| |
| /** |
| * Returns the resource that should be considered when searching for affected breakpoints. |
| * |
| * @return resource to search for breakpoint markers. |
| */ |
| protected IResource getBreakpointContainer() { |
| return fElement.getResource(); |
| } |
| |
| /** |
| * Returns the breakpoint associated with the given marker. |
| * |
| * @param marker breakpoint marker |
| * @return breakpoint or <code>null</code> |
| */ |
| protected IBreakpoint getBreakpoint(IMarker marker) { |
| return DebugPlugin.getDefault().getBreakpointManager().getBreakpoint(marker); |
| } |
| |
| /** |
| * Creates a specific type of change for a breakpoint that is changing types. |
| * @param breakpoint the breakpoint to create the change for |
| * @param destType the destination type name |
| * @param originalType the original type name |
| * |
| * @return type change or <code>null</code> |
| * @throws CoreException if creating the change fails |
| */ |
| protected Change createTypeChange(IJavaBreakpoint breakpoint, IType destType, IType originalType) throws CoreException { |
| if (breakpoint instanceof IJavaWatchpoint) { |
| return new WatchpointTypeChange((IJavaWatchpoint) breakpoint, destType, originalType); |
| } else if (breakpoint instanceof IJavaClassPrepareBreakpoint) { |
| return new ClassPrepareBreakpointTypeChange((IJavaClassPrepareBreakpoint) breakpoint, destType); |
| } else if (breakpoint instanceof IJavaMethodBreakpoint) { |
| return new MethodBreakpointTypeChange((IJavaMethodBreakpoint) breakpoint, destType); |
| } else if (breakpoint instanceof IJavaExceptionBreakpoint) { |
| return new ExceptionBreakpointTypeChange((IJavaExceptionBreakpoint) breakpoint, destType); |
| } else if (breakpoint instanceof IJavaLineBreakpoint) { |
| return new LineBreakpointTypeChange((IJavaLineBreakpoint) breakpoint, destType); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns whether the given target type is contained in the specified container type. |
| * |
| * @param container the container |
| * @param type the type |
| * @return if the type is contained in the given container |
| */ |
| protected boolean isContained(IJavaElement container, IType type) { |
| IJavaElement parent = type; |
| while (parent != null) { |
| if (parent.equals(container)) { |
| return true; |
| } |
| parent = parent.getParent(); |
| } |
| return false; |
| } |
| } |