org.eclipse.jdt/org.eclipse.jdt.core.manipulation/1.13.0 : org/eclipse/jdt/core/refactoring/descriptors/IntroduceParameterObjectDescriptor.java

IntroduceParameterObjectDescriptor
http://www.eclipse.org/jdt: Java Code Manipulation Functionality (Eclipse Foundation)
Eclipse Public License - v 2.0
Copyright (c) 2005, 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) 2005, 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.core.refactoring.descriptors;

import java.util.Map;

import org.eclipse.ltk.core.refactoring.RefactoringContribution;
import org.eclipse.ltk.core.refactoring.RefactoringCore;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;

import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.refactoring.IJavaRefactorings;

import org.eclipse.jdt.internal.core.refactoring.descriptors.JavaRefactoringDescriptorUtil;

Refactoring descriptor for the introduce parameter object refactoring.
 An instance of this refactoring descriptor may be obtained by calling RefactoringContribution.createDescriptor() on a refactoring contribution requested by invoking RefactoringCore.getRefactoringContribution(String) with the appropriate refactoring id. 
Since: 1.2
@noinstantiate This class is not intended to be instantiated by clients.
@noextend This class is not intended to be subclassed by clients./**
 * Refactoring descriptor for the introduce parameter object refactoring.
 * <p>
 * An instance of this refactoring descriptor may be obtained by calling
 * {@link RefactoringContribution#createDescriptor()} on a refactoring
 * contribution requested by invoking
 * {@link RefactoringCore#getRefactoringContribution(String)} with the
 * appropriate refactoring id.
 * </p>
 *
 * @since 1.2
 *
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public class IntroduceParameterObjectDescriptor extends JavaRefactoringDescriptor {

	Instances of Parameter are used to describe the position of parameter and fields.
/**
	 * Instances of Parameter are used to describe the position of parameter and fields.
	 */
	public static class Parameter {

		private boolean fCreateField= false;

		private String fFieldName= null;

		private final int fIndex;

		Creates a new parameter object. It is not recommended to call this constructor directly. Use IntroduceParameterObjectDescriptor.createParameters(IMethod) instead. 
Params: index – the index of the parameter in the method/**
		 * Creates a new parameter object. It is not recommended to call this constructor directly.
		 * Use {@link IntroduceParameterObjectDescriptor#createParameters(IMethod)} instead.
		 * @param index the index of the parameter in the method
		 */
		public Parameter(int index) {
			super();
			fIndex= index;
		}

		The name of the field that will be created if isCreateField() is true
See Also: isCreateField()
setFieldName(String)
Returns: the field name/**
		 * The name of the field that will be created if {@link #isCreateField()} is <code>true</code>
		 *
		 * @return the field name
		 * @see #isCreateField()
		 * @see #setFieldName(String)
		 */
		public String getFieldName() {
			return fFieldName;
		}

		The index of the parameter in the original method signature. The parameter object has the special index IntroduceParameterObjectDescriptor.PARAMETER_OBJECT_IDX. The position in the new method signature depends on the position in the array passed to IntroduceParameterObjectDescriptor.setParameters(Parameter[]) 
See Also: IntroduceParameterObjectDescriptor.PARAMETER_OBJECT
IntroduceParameterObjectDescriptor.PARAMETER_OBJECT_IDX
IntroduceParameterObjectDescriptor.setParameters(Parameter[])
Returns: returns the index of the parameter in the original method signature or IntroduceParameterObjectDescriptor.PARAMETER_OBJECT_IDX for the parameter object/**
		 * The index of the parameter in the original method signature. The parameter object has the special index {@link IntroduceParameterObjectDescriptor#PARAMETER_OBJECT_IDX}.
		 * The position in the new method signature depends on the position in the array passed to {@link IntroduceParameterObjectDescriptor#setParameters(IntroduceParameterObjectDescriptor.Parameter[])}
		 *
		 * @return returns the index of the parameter in the original method signature or {@link IntroduceParameterObjectDescriptor#PARAMETER_OBJECT_IDX}
		 * for the parameter object
		 *
		 * @see IntroduceParameterObjectDescriptor#PARAMETER_OBJECT
		 * @see IntroduceParameterObjectDescriptor#PARAMETER_OBJECT_IDX
		 * @see IntroduceParameterObjectDescriptor#setParameters(IntroduceParameterObjectDescriptor.Parameter[])
		 */
		public int getIndex() {
			return fIndex;
		}

		If true the parameter will be removed from the method's signature and will be added
to the parameter object. The default is false
Returns: true if the parameter will be created as field, false if
			it will remain in the method/**
		 * If <code>true</code> the parameter will be removed from the method's signature and will be added
		 * to the parameter object. The default is <code>false</code>
		 *
		 * @return <code>true</code> if the parameter will be created as field, <code>false</code> if
		 * 			it will remain in the method
		 */
		public boolean isCreateField() {
			return fCreateField;
		}

		Sets whether the parameter will be removed from the method's signature or will be added to the parameter object. The
default is false. Changing the creatField property of the parameter object will throw a IllegalArgumentException 
Params: createField – true if the parameter should be created as field, false
						if it will remain in the method/**
		 * Sets whether the parameter will be removed from the method's signature or will be added to the parameter object. The
		 * default is <code>false</code>. Changing the creatField property of the parameter object will throw a {@link IllegalArgumentException}
		 *
		 * @param createField <code>true</code> if the parameter should be created as field, <code>false</code>
		 * 						if it will remain in the method
		 */
		public void setCreateField(boolean createField) {
			if (fIndex == PARAMETER_OBJECT_IDX)
				throw new IllegalArgumentException("You can not set create field for the parameter object"); //$NON-NLS-1$
			fCreateField= createField;
		}


		Sets the name of the field that will be created in the parameter object if isCreateField() is true. Changing the fieldName of the parameter object will throw a IllegalArgumentException 
Params: fieldName – the new name of the field. A null indicates that the field name should be automatically derived
See Also: isCreateField()/**
		 * Sets the name of the field that will be created in the parameter object if {@link #isCreateField()}
		 *  is <code>true</code>. Changing the fieldName of the parameter object will throw a {@link IllegalArgumentException}
		 *
		 * @param fieldName the new name of the field. A <code>null</code> indicates that the field name should be automatically derived
		 * @see #isCreateField()
		 */
		public void setFieldName(String fieldName) {
			if (fIndex == PARAMETER_OBJECT_IDX)
				throw new IllegalArgumentException("You can not set the field name of the parameter object"); //$NON-NLS-1$
			fFieldName= fieldName;
		}
	}

	private static final String PARAMETER_COUNT= "PARAMETER_COUNT"; //$NON-NLS-1$

	private static final String PARAMETER_IDX= "PARAMETER_IDX"; //$NON-NLS-1$

	private static final String PARAMETER_CREATE_FIELD= "PARAMETER_CREATE_FIELD"; //$NON-NLS-1$

	private static final String PARAMETER_FIELD_NAME= "PARAMETER_FIELD_NAME"; //$NON-NLS-1$

	private static final String CLASS_NAME= "class_name"; //$NON-NLS-1$

	private static final String DELEGATE= "delegate"; //$NON-NLS-1$

	private static final String DEPRECATE_DELEGATE= "deprecate_delegate"; //$NON-NLS-1$

	private static final String GETTERS= "getters"; //$NON-NLS-1$

	private static final String PACKAGE_NAME= "package_name"; //$NON-NLS-1$

	private static final String PARAMETER_NAME= "parameter_name"; //$NON-NLS-1$

	private static final String SETTERS= "setters"; //$NON-NLS-1$

	private static final String TOP_LEVEL= "top_level"; //$NON-NLS-1$

	The parameter index of the special parameter object. The value is "-1".
/**
	 * The parameter index of the special parameter object. The value is "-1".
	 */
	public static final int PARAMETER_OBJECT_IDX= -1;

	Singleton instance that represents the parameter object
/**
	 * Singleton instance that represents the parameter object
	 */
	public static final Parameter PARAMETER_OBJECT= new Parameter(PARAMETER_OBJECT_IDX);


	Creates the parameters for this method. The first object is the parameter object.
By default all parameters are marked for field creation
Params: method – derive parameter from this method
Returns: an array of parameter corresponding to the parameter declared in the method. The first object
			will be the parameter object. All parameter are marked for field creation/**
	 * Creates the parameters for this method. The first object is the parameter object.
	 * By default all parameters are marked for field creation
	 *
	 * @param method derive parameter from this method
	 * @return an array of parameter corresponding to the parameter declared in the method. The first object
	 * 			will be the parameter object. All parameter are marked for field creation
	 */
	public static Parameter[] createParameters(IMethod method) {
		int length= method.getNumberOfParameters();
		Parameter[] result= new Parameter[length + 1];
		result[0]= PARAMETER_OBJECT;
		for (int i= 0; i < length; i++) {
			result[i + 1]= new Parameter(i);
			result[i + 1].setCreateField(true);
		}
		return result;
	}

	private String fClassName;

	private boolean fDelegate= false;

	private boolean fDeprecateDelegate= true;

	private boolean fGetters= false;

	private IMethod fMethod;

	private String fPackageName;

	private String fParameterName;

	private Parameter[] fParameters;

	private boolean fSetters= false;

	If true the class will be created as top level class. Default true
/**
	 * If <code>true</code> the class will be created as top level class. Default true
	 */
	private boolean fTopLevel= true;

	Creates a new refactoring descriptor.
/**
	 * Creates a new refactoring descriptor.
	 */
	public IntroduceParameterObjectDescriptor() {
		super(IJavaRefactorings.INTRODUCE_PARAMETER_OBJECT);
	}

	Creates a new refactoring descriptor.
Params: project – 
           the non-empty name of the project associated with this
           refactoring, or null for a workspace
           refactoring
description – 
           a non-empty human-readable description of the particular
           refactoring instance
comment – 
           the human-readable comment of the particular refactoring
           instance, or null for no comment
arguments – 
			  a map of arguments that will be persisted and describes
			  all settings for this refactoring
flags – 
           the flags of the refactoring descriptor
Throws: IllegalArgumentException – if the argument map contains invalid keys/values/**
	 * Creates a new refactoring descriptor.
	 *
	 * @param project
	 *            the non-empty name of the project associated with this
	 *            refactoring, or <code>null</code> for a workspace
	 *            refactoring
	 * @param description
	 *            a non-empty human-readable description of the particular
	 *            refactoring instance
	 * @param comment
	 *            the human-readable comment of the particular refactoring
	 *            instance, or <code>null</code> for no comment
	 * @param arguments
	 * 			  a map of arguments that will be persisted and describes
	 * 			  all settings for this refactoring
	 * @param flags
	 *            the flags of the refactoring descriptor
	 * @throws IllegalArgumentException if the argument map contains invalid keys/values
	 */
	public IntroduceParameterObjectDescriptor(final String project, final String description, final String comment, final Map<String, String> arguments, final int flags) throws IllegalArgumentException {
		super(IJavaRefactorings.INTRODUCE_PARAMETER_OBJECT, project, description, comment, arguments, flags);
		initializeFromMap(arguments);
	}

	The name of the class that will be generated. If null the refactoring will automatically choose a class name.
Returns: the name of the class that will be generated or null if the name will be automatically chosen/**
	 * The name of the class that will be generated. If <code>null</code> the refactoring will automatically choose a class name.
	 *
	 * @return the name of the class that will be generated or <code>null</code> if the name will be automatically chosen
	 */
	public String getClassName() {
		return fClassName;
	}

	The method the refactoring will operate on. Can be set using setMethod(IMethod). 
Returns: the method that the refactoring will operate on./**
	 * The method the refactoring will operate on. Can be set using {@link #setMethod(IMethod)}.
	 *
	 * @return the method that the refactoring will operate on.
	 */
	public IMethod getMethod() {
		return fMethod;
	}

	The parameter object class will be created in this package if the top level is true. Can be set using setPackageName(String). If the package name was null and the method has already been set this method returns
the package where the method is declared in.
Returns: the package name that has been set or the package where the method is declared. Can return null
			if neither the package nor the method has been set/**
	 * The parameter object class will be created in this package if the top level is <code>true</code>. Can be set using
	 * {@link #setPackageName(String)}. If the package name was <code>null</code> and the method has already been set this method returns
	 * the package where the method is declared in.
	 *
	 * @return the package name that has been set or the package where the method is declared. Can return <code>null</code>
	 * 			if neither the package nor the method has been set
	 */
	public String getPackageName() {
		if (fPackageName == null && fMethod != null) {
			IType type= fMethod.getDeclaringType();
			if (type != null)
				return type.getPackageFragment().getElementName();
		}
		return fPackageName;
	}

	Returns the name of the parameter. Can return null in which case the refactoring chooses a name. Default is null
Returns: the name of the parameter. Can return null in which case the refactoring chooses a name. Default is null/**
	 * Returns the name of the parameter. Can return <code>null</code> in which case the refactoring chooses a name. Default is <code>null</code>
	 *
	 * @return the name of the parameter. Can return <code>null</code> in which case the refactoring chooses a name. Default is <code>null</code>
	 */
	public String getParameterName() {
		return fParameterName;
	}

	Returns the parameters. Can return null if all parameters should be converted to fields. Default is null.
Returns: the parameters. Can return null if all parameters should be converted to fields. Default is null/**
	 * Returns the parameters. Can return <code>null</code> if all parameters should be converted to fields. Default is <code>null</code>.
	 *
	 * @return the parameters. Can return <code>null</code> if all parameters should be converted to fields. Default is <code>null</code>
	 */
	public Parameter[] getParameters() {
		return fParameters;
	}

	Returns true if delegates will be kept. Default is false.
Returns: true if delegates will be kept. Default is false/**
	 * Returns <code>true</code> if delegates will be kept. Default is <code>false</code>.
	 *
	 * @return <code>true</code> if delegates will be kept. Default is <code>false</code>
	 */
	public boolean isDelegate() {
		return fDelegate;
	}

	Returns true if delegates will be marked as deprecated. Default is false.
Returns: true if delegates will be marked as deprecated. Default is false/**
	 * Returns <code>true</code> if delegates will be marked as deprecated. Default is <code>false</code>.
	 *
	 * @return <code>true</code> if delegates will be marked as deprecated. Default is <code>false</code>
	 */
	public boolean isDeprecateDelegate() {
		return fDeprecateDelegate;
	}

	Returns true if getters are generated for fields. Default is false.
Returns: true if getters are generated for fields. Default is false/**
	 * Returns <code>true</code> if getters are generated for fields. Default is <code>false</code>.
	 *
	 * @return <code>true</code> if getters are generated for fields. Default is <code>false</code>
	 */
	public boolean isGetters() {
		return fGetters;
	}

	Returns true if setters are generated for fields. Default is false.
Returns: true if setters are generated for fields. Default is false/**
	 * Returns <code>true</code> if setters are generated for fields. Default is <code>false</code>.
	 *
	 * @return <code>true</code> if setters are generated for fields. Default is <code>false</code>
	 */
	public boolean isSetters() {
		return fSetters;
	}

	Returns true if the new type is created as top level type.
false is returned when the type is created as enclosing type
of the type declaring the method declaration to be changed. Default is true.
Returns: true if the new type is created as top level type.
		   false is returned when the type is created as enclosing
		   type of the type declaring the method declaration to be changed. Default is true/**
	 * Returns <code>true</code> if the new type is created as top level type.
	 * <code>false</code> is returned when the type is created as enclosing type
	 * of the type declaring the method declaration to be changed. Default is <code>true</code>.
	 *
	 * @return <code>true</code> if the new type is created as top level type.
	 * 		   <code>false</code> is returned when the type is created as enclosing
	 * 		   type of the type declaring the method declaration to be changed. Default is <code>true</code>
	 */
	public boolean isTopLevel() {
		return fTopLevel;
	}

	@Override
	protected void populateArgumentMap() {
		super.populateArgumentMap();
		JavaRefactoringDescriptorUtil.setJavaElement(fArguments, ATTRIBUTE_INPUT, getProject(), fMethod);
		Parameter[] parameters= fParameters;
		if (parameters == null) {
			parameters= createParameters(fMethod);
		}
		JavaRefactoringDescriptorUtil.setInt(fArguments, PARAMETER_COUNT, parameters.length);
		for (int i= 0; i < parameters.length; i++) {
			Parameter param= parameters[i];
			JavaRefactoringDescriptorUtil.setInt(fArguments, JavaRefactoringDescriptorUtil.getAttributeName(PARAMETER_IDX, i), param.getIndex());
			JavaRefactoringDescriptorUtil.setBoolean(fArguments, JavaRefactoringDescriptorUtil.getAttributeName(PARAMETER_CREATE_FIELD, i), param.isCreateField());
			if (param.isCreateField())
				JavaRefactoringDescriptorUtil.setString(fArguments, JavaRefactoringDescriptorUtil.getAttributeName(PARAMETER_FIELD_NAME, i), param.getFieldName());
		}
		JavaRefactoringDescriptorUtil.setString(fArguments, CLASS_NAME, fClassName);
		JavaRefactoringDescriptorUtil.setString(fArguments, PACKAGE_NAME, fPackageName);
		JavaRefactoringDescriptorUtil.setString(fArguments, PARAMETER_NAME, fParameterName);
		JavaRefactoringDescriptorUtil.setBoolean(fArguments, DELEGATE, fDelegate);
		JavaRefactoringDescriptorUtil.setBoolean(fArguments, DEPRECATE_DELEGATE, fDeprecateDelegate);
		JavaRefactoringDescriptorUtil.setBoolean(fArguments, GETTERS, fGetters);
		JavaRefactoringDescriptorUtil.setBoolean(fArguments, SETTERS, fSetters);
		JavaRefactoringDescriptorUtil.setBoolean(fArguments, TOP_LEVEL, fTopLevel);
	}

	private void initializeFromMap(Map<String, String> map) throws IllegalArgumentException {
		IMethod method= (IMethod) JavaRefactoringDescriptorUtil.getJavaElement(map, ATTRIBUTE_INPUT, getProject());
		setMethod(method);
		initializeParameter(map);
		setClassName(JavaRefactoringDescriptorUtil.getString(map, CLASS_NAME, true));
		setPackageName(JavaRefactoringDescriptorUtil.getString(map, PACKAGE_NAME, true));
		setParameterName(JavaRefactoringDescriptorUtil.getString(map, PARAMETER_NAME, true));
		setDelegate(JavaRefactoringDescriptorUtil.getBoolean(map, DELEGATE, fDelegate));
		setDeprecateDelegate(JavaRefactoringDescriptorUtil.getBoolean(map, DEPRECATE_DELEGATE, fDeprecateDelegate));
		setGetters(JavaRefactoringDescriptorUtil.getBoolean(map, GETTERS, fGetters));
		setSetters(JavaRefactoringDescriptorUtil.getBoolean(map, SETTERS, fSetters));
		setTopLevel(JavaRefactoringDescriptorUtil.getBoolean(map, TOP_LEVEL, fTopLevel));
	}

	private void initializeParameter(Map<String, String> map) throws IllegalArgumentException {
		int[] idx= JavaRefactoringDescriptorUtil.getIntArray(map, PARAMETER_COUNT, PARAMETER_IDX);
		boolean[] createField= JavaRefactoringDescriptorUtil.getBooleanArray(map, PARAMETER_COUNT, PARAMETER_CREATE_FIELD, 0);
		Parameter[] result=new Parameter[idx.length];
		for (int i= 0; i < idx.length; i++) {
			int index= idx[i];
			if (index == PARAMETER_OBJECT_IDX) {
				result[i]= new Parameter(PARAMETER_OBJECT_IDX);
			} else {
				Parameter parameter= new Parameter(index);
				result[i]= parameter;
				parameter.setCreateField(createField[i]);
				if (createField[i])
					parameter.setFieldName(JavaRefactoringDescriptorUtil.getString(map, JavaRefactoringDescriptorUtil.getAttributeName(PARAMETER_FIELD_NAME, i)));
			}
		}
		setParameters(result);
	}

	Sets the name of the class for the generated parameter object. The name can be null to
indicate that the refactoring should chose one.
Params: className – the name of the generated class or null. Default is null/**
	 * Sets the name of the class for the generated parameter object. The name can be <code>null</code> to
	 * indicate that the refactoring should chose one.
	 *
	 * @param className the name of the generated class or <code>null</code>. Default is <code>null</code>
	 */
	public void setClassName(String className) {
		fClassName= className;
	}

	Sets delegate keeping. If true delegates will be kept.
Params: delegate – true to keep delegates. Default is false/**
	 * Sets delegate keeping. If <code>true</code> delegates will be kept.
	 *
	 * @param delegate <code>true</code> to keep delegates. Default is <code>false</code>
	 */
	public void setDelegate(boolean delegate) {
		fDelegate= delegate;
	}

	Sets deprecate delegate. If true generated delegates will be marked as deprecated.
Params: deprecateDelegate – true to deprecate kept delegates. Default is false/**
	 * Sets deprecate delegate. If <code>true</code> generated delegates will be marked as deprecated.
	 *
	 * @param deprecateDelegate <code>true</code> to deprecate kept delegates. Default is <code>false</code>
	 */
	public void setDeprecateDelegate(boolean deprecateDelegate) {
		fDeprecateDelegate= deprecateDelegate;
	}

	Sets whether getters will be created for all fields.
Params: getters – true to create getters. Default is false./**
	 * Sets whether getters will be created for all fields.
	 *
	 * @param getters <code>true</code> to create getters. Default is <code>false</code>.
	 */
	public void setGetters(boolean getters) {
		fGetters= getters;
	}

	Sets the method. The method may not be null, has to exist, and has to be
in a Java project.
Params: method – the method. May not be null/**
	 * Sets the method. The method may not be <code>null</code>, has to exist, and has to be
	 * in a Java project.
	 *
	 * @param method the method. May not be <code>null</code>
	 */
	public void setMethod(IMethod method) {
		if (method == null)
			throw new IllegalArgumentException("The method must not be null"); //$NON-NLS-1$
		if (!method.exists())
			throw new IllegalArgumentException("The method must exist"); //$NON-NLS-1$
		if (method.getJavaProject() == null)
			throw new IllegalArgumentException("The method has to be in a Java project"); //$NON-NLS-1$
		fMethod= method;
	}

	Sets the package where the parameter object will be created in if it is created as top level class.
The package can be null to indicate that the package of the method should be used.
Params: packageName – the package for the top level class or null. Default is null./**
	 * Sets the package where the parameter object will be created in if it is created as top level class.
	 * The package can be <code>null</code> to indicate that the package of the method should be used.
	 *
	 * @param packageName the package for the top level class or <code>null</code>. Default is <code>null</code>.
	 */
	public void setPackageName(String packageName) {
		fPackageName= packageName;
	}

	Sets the name of the parameter object as it will appear in the method signature.
The name can be null to indicate that the refactoring will choose a name.
Params: parameterName – the name of the parameter or null. Default is null./**
	 * Sets the name of the parameter object as it will appear in the method signature.
	 * The name can be <code>null</code> to indicate that the refactoring will choose a name.
	 *
	 * @param parameterName the name of the parameter or <code>null</code>. Default is <code>null</code>.
	 */
	public void setParameterName(String parameterName) {
		fParameterName= parameterName;
	}

	Sets the parameters. The parameters can be null to indicate that all parameter
should be used as fields. If not null, the number of parameters passed has to be the number of parameter of the method + 1. One element has to be the PARAMETER_OBJECT. Each parameter may only appear once. 
Params: parameters – the parameters or null. Default is null/**
	 * Sets the parameters. The parameters can be <code>null</code> to indicate that all parameter
	 * should be used as fields. If not <code>null</code>, the number of parameters passed has to be
	 * the number of parameter of the method + 1. One element has to be the {@link #PARAMETER_OBJECT}.
	 * Each parameter may only appear once.
	 *
	 * @param parameters the parameters or <code>null</code>. Default is <code>null</code>
	 */
	public void setParameters(Parameter[] parameters) {
		fParameters= parameters;
	}

	Sets whether setters will be created for all fields.
Params: setters – true to create setters. Default is false/**
	 * Sets whether setters will be created for all fields.
	 *
	 * @param setters <code>true</code> to create setters. Default is <code>false</code>
	 */
	public void setSetters(boolean setters) {
		fSetters= setters;
	}

	Sets whether the parameter object class will be created as top level class.
if true the class will be created as top level class in the package returned by getPackageName(). If false the class will be
 created as as nested class in the class containing the method
Params: topLevel – true to create the parameter object as top level. Default is true/**
	 * Sets whether the parameter object class will be created as top level class.
	 * if <code>true</code> the class will be created as top level class in the package
	 * returned by {@link #getPackageName()}. If <code>false</code> the class will be
	 *  created as as nested class in the class containing the method
	 *
	 * @param topLevel <code>true</code> to create the parameter object as top level. Default is <code>true</code>
	 */
	public void setTopLevel(boolean topLevel) {
		fTopLevel= topLevel;
	}

	@Override
	public RefactoringStatus validateDescriptor() {
		RefactoringStatus result= super.validateDescriptor();
		if (!result.isOK())
			return result;
		if (fMethod == null) {
			result.addFatalError("The method must not be null"); //$NON-NLS-1$
			return result;
		}
		IJavaProject javaProject= fMethod.getJavaProject();
		if (javaProject == null) {
			result.addFatalError("Can not derive Java project from method"); //$NON-NLS-1$
			return result;
		}
		String sourceLevel= javaProject.getOption(JavaCore.COMPILER_SOURCE, true);
		String complianceLevel= javaProject.getOption(JavaCore.COMPILER_COMPLIANCE, true);
		if (fParameters != null) {
			if (fParameters.length - 1 != fMethod.getNumberOfParameters()) {
				result.addFatalError("The number of parameters does not match the number of parameters of the method"); //$NON-NLS-1$
			}
			boolean hasParameterObject= false;
			for (int i= 0; i < fParameters.length; i++) {
				Parameter parameter= fParameters[i];
				if (parameter.isCreateField()) {
					String fieldName= parameter.getFieldName();
					if (fieldName == null)
						result.addError("The parameter " + parameter.getIndex() + " is marked for field creation but does not have a field name"); //$NON-NLS-1$ //$NON-NLS-2$
					else {
						result.merge(RefactoringStatus.create(JavaConventions.validateFieldName(fieldName, sourceLevel, complianceLevel)));
					}
				}
				if (parameter == PARAMETER_OBJECT) {
					if (hasParameterObject)
						result.addError("Can not have more than one parameter object"); //$NON-NLS-1$
					else
						hasParameterObject= true;
				}
			}
		}
		if (fClassName != null) {
			result.merge(RefactoringStatus.create(JavaConventions.validateIdentifier(fClassName, sourceLevel, complianceLevel)));
		}
		if (fParameterName != null) {
			result.merge(RefactoringStatus.create(JavaConventions.validateIdentifier(fParameterName, sourceLevel, complianceLevel)));
		}
		if (fPackageName != null && !"".equals(fPackageName)) { //$NON-NLS-1$
			result.merge(RefactoringStatus.create(JavaConventions.validatePackageName(fPackageName, sourceLevel, complianceLevel)));
		}
		return result;
	}
}
Since:	1.2
@noinstantiate	This class is not intended to be instantiated by clients.
@noextend	This class is not intended to be subclassed by clients.
See Also:	isCreateField() setFieldName(String)
Returns:	the field name
See Also:	IntroduceParameterObjectDescriptor.PARAMETER_OBJECT IntroduceParameterObjectDescriptor.PARAMETER_OBJECT_IDX IntroduceParameterObjectDescriptor.setParameters(Parameter[])
Returns:	returns the index of the parameter in the original method signature or `IntroduceParameterObjectDescriptor.PARAMETER_OBJECT_IDX` for the parameter object
Params:	fieldName – the new name of the field. A `null` indicates that the field name should be automatically derived
See Also:	isCreateField()
Params:	method – derive parameter from this method
Returns:	an array of parameter corresponding to the parameter declared in the method. The first object will be the parameter object. All parameter are marked for field creation
/

org.eclipse.jdt/ org.eclipse.jdt.core.manipulation/ 1.13.0/ org/eclipse/jdt/core/refactoring/descriptors/IntroduceParameterObjectDescriptor.java
