Copyright (c) 2007, 2008 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
/*******************************************************************************
* Copyright (c) 2007, 2008 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.corext.refactoring;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jdt.internal.core.manipulation.JavaElementLabelsCore;
import org.eclipse.jdt.internal.corext.util.Messages;
public class JavaRefactoringDescriptorUtil {
/* TODO: share implementation with
* org.eclipse.jdt.internal.core.refactoring.descriptors.JavaRefactoringDescriptorUtil
*/
private JavaRefactoringDescriptorUtil(){}
Predefined argument called element<Number>
.
This argument should be used to describe the elements being refactored.
The value of this argument does not necessarily have to uniquely identify
the elements. However, it must be possible to uniquely identify the
elements using the value of this argument in conjunction with the values
of the other user-defined attributes.
The element arguments are simply distinguished by appending a number to
the argument name, e.g. element1. The indices of this argument are non
zero-based.
/**
* Predefined argument called <code>element<Number></code>.
* <p>
* This argument should be used to describe the elements being refactored.
* The value of this argument does not necessarily have to uniquely identify
* the elements. However, it must be possible to uniquely identify the
* elements using the value of this argument in conjunction with the values
* of the other user-defined attributes.
* </p>
* <p>
* The element arguments are simply distinguished by appending a number to
* the argument name, e.g. element1. The indices of this argument are non
* zero-based.
* </p>
*/
public static final String ATTRIBUTE_ELEMENT= "element"; //$NON-NLS-1$
Predefined argument called input
.
This argument should be used to describe the element being refactored.
The value of this argument does not necessarily have to uniquely identify
the input element. However, it must be possible to uniquely identify the
input element using the value of this argument in conjunction with the
values of the other user-defined attributes.
/**
* Predefined argument called <code>input</code>.
* <p>
* This argument should be used to describe the element being refactored.
* The value of this argument does not necessarily have to uniquely identify
* the input element. However, it must be possible to uniquely identify the
* input element using the value of this argument in conjunction with the
* values of the other user-defined attributes.
* </p>
*/
public static final String ATTRIBUTE_INPUT= "input"; //$NON-NLS-1$
Predefined argument called name
.
This argument should be used to name the element being refactored. The
value of this argument may be shown in the user interface.
/**
* Predefined argument called <code>name</code>.
* <p>
* This argument should be used to name the element being refactored. The
* value of this argument may be shown in the user interface.
* </p>
*/
public static final String ATTRIBUTE_NAME= "name"; //$NON-NLS-1$
Predefined argument called references
.
This argument should be used to describe whether references to the
elements being refactored should be updated as well.
/**
* Predefined argument called <code>references</code>.
* <p>
* This argument should be used to describe whether references to the
* elements being refactored should be updated as well.
* </p>
*/
public static final String ATTRIBUTE_REFERENCES= "references"; //$NON-NLS-1$
Predefined argument called selection
.
This argument should be used to describe user input selections within a
text file. The value of this argument has the format "offset length".
/**
* Predefined argument called <code>selection</code>.
* <p>
* This argument should be used to describe user input selections within a
* text file. The value of this argument has the format "offset length".
* </p>
*/
public static final String ATTRIBUTE_SELECTION= "selection"; //$NON-NLS-1$
Converts the specified element to an input handle.
Params: - project –
the project, or
null
for the workspace - element –
the element
Returns: a corresponding input handle
Note: if the given project is not the element's project, then the full handle is returned
/**
* Converts the specified element to an input handle.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param element
* the element
* @return a corresponding input handle
* Note: if the given project is not the element's project, then the full handle is returned
*/
public static String elementToHandle(final String project, final IJavaElement element) {
final String handle= element.getHandleIdentifier();
if (project != null && ! (element instanceof IJavaProject)) {
IJavaProject javaProject= element.getJavaProject();
if (project.equals(javaProject.getElementName())) {
final String id= javaProject.getHandleIdentifier();
return handle.substring(id.length());
}
}
return handle;
}
Converts an input handle back to the corresponding java element.
Params: - project –
the project, or
null
for the workspace - handle –
the input handle
Returns: the corresponding java element, or null
if no such
element exists
/**
* Converts an input handle back to the corresponding java element.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
* @return the corresponding java element, or <code>null</code> if no such
* element exists
*/
public static IJavaElement handleToElement(final String project, final String handle) {
return handleToElement(project, handle, true);
}
Converts an input handle back to the corresponding java element.
Params: - project –
the project, or
null
for the workspace - handle –
the input handle
- check –
true
to check for existence of the element,
false
otherwise
Returns: the corresponding java element, or null
if no such
element exists
/**
* Converts an input handle back to the corresponding java element.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
* @param check
* <code>true</code> to check for existence of the element,
* <code>false</code> otherwise
* @return the corresponding java element, or <code>null</code> if no such
* element exists
*/
public static IJavaElement handleToElement(final String project, final String handle, final boolean check) {
return handleToElement(null, project, handle, check);
}
Converts an input handle back to the corresponding java element.
Params: - owner –
the working copy owner
- project –
the project, or
null
for the workspace - handle –
the input handle
- check –
true
to check for existence of the element,
false
otherwise
Returns: the corresponding java element, or null
if no such
element exists
/**
* Converts an input handle back to the corresponding java element.
*
* @param owner
* the working copy owner
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
* @param check
* <code>true</code> to check for existence of the element,
* <code>false</code> otherwise
* @return the corresponding java element, or <code>null</code> if no such
* element exists
*/
public static IJavaElement handleToElement(final WorkingCopyOwner owner, final String project, final String handle, final boolean check) {
IJavaElement element= null;
if (owner != null)
element= JavaCore.create(handle, owner);
else
element= JavaCore.create(handle);
if (element == null && project != null) {
final IJavaProject javaProject= JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProject(project);
final String identifier= javaProject.getHandleIdentifier();
if (owner != null)
element= JavaCore.create(identifier + handle, owner);
else
element= JavaCore.create(identifier + handle);
}
if (check && element instanceof IMethod) {
/*
* Resolve the method based on simple names of parameter types
* (to accommodate for different qualifications when refactoring is e.g.
* recorded in source but applied on binary method):
*/
final IMethod method= (IMethod) element;
final IMethod[] methods= method.getDeclaringType().findMethods(method);
if (methods != null && methods.length > 0)
element= methods[0];
}
if (element != null && (!check || element.exists()))
return element;
return null;
}
Converts an input handle with the given prefix back to the corresponding
resource.
Params: - project –
the project, or
null
for the workspace - handle –
the input handle
Returns: the corresponding resource, or null
if no such
resource exists.
Note: if the given handle is absolute, the project is not used to resolve.
/**
* Converts an input handle with the given prefix back to the corresponding
* resource.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param handle
* the input handle
*
* @return the corresponding resource, or <code>null</code> if no such
* resource exists.
* Note: if the given handle is absolute, the project is not used to resolve.
*/
public static IResource handleToResource(final String project, final String handle) {
final IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
if ("".equals(handle)) //$NON-NLS-1$
return null;
final IPath path= Path.fromPortableString(handle);
if (path == null)
return null;
if (project != null && !"".equals(project) && ! path.isAbsolute()) //$NON-NLS-1$
return root.getProject(project).findMember(path);
return root.findMember(path);
}
Converts the specified resource to an input handle.
Params: - project –
the project, or
null
for the workspace - resource –
the resource
Returns: the input handle.
Note: if the given project is not the resource's project, then the full handle is returned.
/**
* Converts the specified resource to an input handle.
*
* @param project
* the project, or <code>null</code> for the workspace
* @param resource
* the resource
*
* @return the input handle.
* Note: if the given project is not the resource's project, then the full handle is returned.
*/
public static String resourceToHandle(final String project, final IResource resource) {
if (project != null && !"".equals(project) && project.equals(resource.getProject().getName())) //$NON-NLS-1$
return resource.getProjectRelativePath().toPortableString();
return resource.getFullPath().toPortableString();
}
Creates a fatal error status telling that the input element does not
exist.
Params: - element –
the input element, or
null
- name –
the name of the refactoring
- id –
the id of the refactoring
Returns: the refactoring status
/**
* Creates a fatal error status telling that the input element does not
* exist.
*
* @param element
* the input element, or <code>null</code>
* @param name
* the name of the refactoring
* @param id
* the id of the refactoring
* @return the refactoring status
*/
public static RefactoringStatus createInputFatalStatus(final Object element, final String name, final String id) {
Assert.isNotNull(name);
Assert.isNotNull(id);
if (element != null)
return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_input_not_exists, new String[] { JavaElementLabelsCore.getTextLabel(element, JavaElementLabelsCore.ALL_FULLY_QUALIFIED), name, id}));
else
return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_inputs_do_not_exist, new String[] { name, id}));
}
Creates a warning status telling that the input element does not exist.
Params: - element –
the input element, or
null
- name –
the name of the refactoring
- id –
the id of the refactoring
Returns: the refactoring status
/**
* Creates a warning status telling that the input element does not exist.
*
* @param element
* the input element, or <code>null</code>
* @param name
* the name of the refactoring
* @param id
* the id of the refactoring
* @return the refactoring status
*/
public static RefactoringStatus createInputWarningStatus(final Object element, final String name, final String id) {
Assert.isNotNull(name);
Assert.isNotNull(id);
if (element != null)
return RefactoringStatus.createWarningStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_input_not_exists, new String[] { JavaElementLabelsCore.getTextLabel(element, JavaElementLabelsCore.ALL_FULLY_QUALIFIED), name, id}));
else
return RefactoringStatus.createWarningStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_inputs_do_not_exist, new String[] { name, id}));
}
}