org.eclipse.jdt.core.manipulation/refactoring/org/eclipse/jdt/core/refactoring/participants/ChangeMethodSignatureArguments.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2008 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.core.refactoring.participants;

 import org.eclipse.core.runtime.Assert;

 import org.eclipse.ltk.core.refactoring.participants.RefactoringArguments;

 import org.eclipse.jdt.core.Flags;
 import org.eclipse.jdt.core.Signature;

 /**
  * Change method signature arguments describe the data that a processor
  * provides to its change signature participants
  * <p>
  * This class is not intended to be subclassed by clients.
  * </p>
  *
  * @since 1.2
  *
  * @noextend This class is not intended to be subclassed by clients.
  */
 public class ChangeMethodSignatureArguments extends RefactoringArguments {

 	/**
 	 * Instances of {@link ChangeMethodSignatureArguments.Parameter} are used to describe the new parameters
 	 * after a change method signature refactoring.
 	 */
 	public final static class Parameter {

 		private final int fOldIndex;
 		private final String fNewName;
 		private final String fNewSignature;
 		private final String fDefaultValue;

 		/**
 		 * Creates a {@link ChangeMethodSignatureArguments.Parameter}.
 		 *
 		 * @param oldIndex the index of the parameter in the original method or <code>-1</code> if the parameter is a new parameter.
 		 * @param newName the new name of the parameter.
 		 * @param newSignature the new type of the parameter in signature notation (See {@link Signature}).
 		 * @param defaultValue the default value for new parameters or <code>null</code>.
 		 */
 		public Parameter(int oldIndex, String newName, String newSignature, String defaultValue) {
 			fOldIndex= oldIndex;
 			fNewName= newName;
 			fNewSignature= newSignature;
 			fDefaultValue= defaultValue;
 		}

 		/**
 		 * Returns the index of the parameter in the original method or <code>-1</code> if the parameter
 		 * has been added.
 		 *
 		 * @return the index of the parameter in the original method or <code>-1</code> if the parameter
 		 * has been added
 		 */
 		public int getOldIndex() {
 			return fOldIndex;
 		}

 		/**
 		 * Returns the new name of the parameter. If the name has not been changed by the refactoring,
 		 * the original parameter name is returned.
 		 *
 		 * @return the new parameter name
 		 */
 		public String getName() {
 			return fNewName;
 		}

 		/**
 		 * Returns the new type of the parameter in signature notation (See {@link Signature}).
 		 * If the type has not been changed by the refactoring, the original type signature is returned.
 		 *
 		 * @return the the new type
 		 */
 		public String getType() {
 			return fNewSignature;
 		}

 		/**
 		 * The default value for new parameters or <code>null</code>.
 		 *
 		 * @return returns the default value for new parameters or <code>null</code>.
 		 */
 		public String getDefaultValue() {
 			return fDefaultValue;
 		}

 		/* (non-Javadoc)
 		 * @see java.lang.Object#toString()
 		 */
 		public String toString() {
 			return "name: " + fNewName + ", type: " + fNewSignature + ", oldIndex: " + fOldIndex + ", defaultValue: " + fDefaultValue; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
 		}

 	}

 	/**
 	 * Instances of {@link ChangeMethodSignatureArguments.ThrownException} are used to describe the new thrown
 	 * exceptions after a change method signature refactoring.
 	 */
 	public final static class ThrownException {

 		private final int fOldIndex;
 		private final String fType;

 		/**
 		 * Creates a {@link ChangeMethodSignatureArguments.ThrownException}.
 		 *
 		 * @param oldIndex the index of the thrown exception in the original method
 		 *                             or <code>-1</code> if the thrown exception is a new thrown exception.
 		 * @param newSignature the new type of the thrown exception in signature notation
 		 *                             (See {@link Signature}).
 		 */
 		public ThrownException(int oldIndex, String newSignature) {
 			fOldIndex= oldIndex;
 			fType= newSignature;
 		}

 		/**
 		 * Returns the index of the thrown exception in the original method or <code>-1</code> if the thrown exception
 		 * has been added.
 		 *
 		 * @return the index of the parameter in the original method or <code>-1</code> if the thrown exception
 		 * has been added.
 		 */
 		public int getOldIndex() {
 			return fOldIndex;
 		}

 		/**
 		 * Returns the new type of the thrown exception in signature notation (See {@link Signature}).
 		 *
 		 * @return the the new type
 		 */
 		public String getType() {
 			return fType;
 		}

 		/* (non-Javadoc)
 		 * @see java.lang.Object#toString()
 		 */
 		public String toString() {
 			return "type: " + fType + ", oldIndex: " + fOldIndex; //$NON-NLS-1$ //$NON-NLS-2$
 		}
 	}

 	private String fNewName;
 	private String fNewReturnType;

 	private final int fNewVisibility;
 	private final Parameter[] fNewParameters;
 	private final ThrownException[] fThrownExceptions;
 	private final boolean fKeepOriginal;

 	/**
 	 * Creates new change method signature arguments.
 	 *
 	 * @param newName the new name of the element to be changed
 	 * @param newReturnType the new method return type in signature notation (see {@link Signature}).
 	 * @param newVisibility the new visibility; one of {@link Flags#AccPublic}, {@link Flags#AccProtected},
 	 * {@link Flags#AccPrivate} or <code>0</code> for the default visibility.
 	 * @param newParameters the new parameters of this method
 	 * @param thrownExceptions the new exceptions thrown by this method
 	 * @param keepOriginal <code>true</code> if the original method is kept as a delegate to the new one,
 	 * <code>false</code> otherwise
 	 */
 	public ChangeMethodSignatureArguments(String newName, String newReturnType, int newVisibility, Parameter[] newParameters, ThrownException[] thrownExceptions, boolean keepOriginal) {
 		Assert.isNotNull(newName);
 		fNewName= newName;
 		fNewReturnType= newReturnType;
 		fNewVisibility= newVisibility;
 		fNewParameters= newParameters;
 		fThrownExceptions= thrownExceptions;
 		fKeepOriginal= keepOriginal;
 	}

 	/**
 	 * Returns the new method name. If the name has not been changed by the refactoring, the original
 	 * parameter name is returned.
 	 *
 	 * @return the method name
 	 */
 	public String getNewName() {
 		return fNewName;
 	}

 	/**
 	 * Returns the type signature of the new return type of this method.
 	 * For constructors, this returns the signature for void.
 	 * If the return type has not been changed by the refactoring, the original
 	 * return type signature is returned.
 	 *
 	 * @return the new return type
 	 */
 	public String getNewReturnType() {
 		return fNewReturnType;
 	}

 	/**
 	 * Returns the new visibility of this method. The visibility is one of {@link Flags#AccPublic}, {@link Flags#AccProtected},
 	 * {@link Flags#AccPrivate} or <code>0</code> for the default visibility. If the visibility has not been changed by the
 	 * refactoring, the original visibility is returned.
 	 *
 	 * @return the visibility of the method
 	 */
 	public int getNewVisibility() {
 		return fNewVisibility;
 	}

 	/**
 	 * Returns the new parameters of this method.
 	 *
 	 * @return the new parameters of this method
 	 */
 	public Parameter[] getNewParameters() {
 		return fNewParameters;
 	}

 	/**
 	 * Returns the new thrown exceptions of this method.
 	 *
 	 * @return new thrown exceptions of this method
 	 */
 	public ThrownException[] getThrownExceptions() {
 		return fThrownExceptions;
 	}

 	/**
 	 * Returns whether the original method is kept as a delegate to the new one.
 	 *
 	 * @return returns <code>true</code> if the original method is kept <code>false</code> otherwise
 	 */
 	public boolean getKeepOriginal() {
 		return fKeepOriginal;
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	public String toString() {
 		StringBuffer buf= new StringBuffer("change signature to "); //$NON-NLS-1$
 		buf.append("\n\tvisibility: ").append(Flags.toString(fNewVisibility)); //$NON-NLS-1$
 		buf.append("\n\treturn type sig: ").append(fNewReturnType); //$NON-NLS-1$
 		buf.append("\n\tnew name: ").append(fNewName); //$NON-NLS-1$
 		buf.append("\n\tkeep original: ").append(fKeepOriginal); //$NON-NLS-1$
 		for (int i= 0; i < fNewParameters.length; i++) {
 			buf.append("\n\tparameter ").append(i).append(": ").append(fNewParameters[i]); //$NON-NLS-1$ //$NON-NLS-2$
 		}
 		for (int i= 0; i < fThrownExceptions.length; i++) {
 			buf.append("\n\texception ").append(i).append(": ").append(fThrownExceptions[i]); //$NON-NLS-1$ //$NON-NLS-2$
 		}
 		return buf.toString();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2008 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.core.refactoring.participants;

	import org.eclipse.core.runtime.Assert;

	import org.eclipse.ltk.core.refactoring.participants.RefactoringArguments;

	import org.eclipse.jdt.core.Flags;
	import org.eclipse.jdt.core.Signature;

	/**
	* Change method signature arguments describe the data that a processor
	* provides to its change signature participants
	* <p>
	* This class is not intended to be subclassed by clients.
	* </p>
	*
	* @since 1.2
	*
	* @noextend This class is not intended to be subclassed by clients.
	*/
	public class ChangeMethodSignatureArguments extends RefactoringArguments {

	/**
	* Instances of {@link ChangeMethodSignatureArguments.Parameter} are used to describe the new parameters
	* after a change method signature refactoring.
	*/
	public final static class Parameter {

	private final int fOldIndex;
	private final String fNewName;
	private final String fNewSignature;
	private final String fDefaultValue;

	/**
	* Creates a {@link ChangeMethodSignatureArguments.Parameter}.
	*
	* @param oldIndex the index of the parameter in the original method or <code>-1</code> if the parameter is a new parameter.
	* @param newName the new name of the parameter.
	* @param newSignature the new type of the parameter in signature notation (See {@link Signature}).
	* @param defaultValue the default value for new parameters or <code>null</code>.
	*/
	public Parameter(int oldIndex, String newName, String newSignature, String defaultValue) {
	fOldIndex= oldIndex;
	fNewName= newName;
	fNewSignature= newSignature;
	fDefaultValue= defaultValue;
	}

	/**
	* Returns the index of the parameter in the original method or <code>-1</code> if the parameter
	* has been added.
	*
	* @return the index of the parameter in the original method or <code>-1</code> if the parameter
	* has been added
	*/
	public int getOldIndex() {
	return fOldIndex;
	}

	/**
	* Returns the new name of the parameter. If the name has not been changed by the refactoring,
	* the original parameter name is returned.
	*
	* @return the new parameter name
	*/
	public String getName() {
	return fNewName;
	}

	/**
	* Returns the new type of the parameter in signature notation (See {@link Signature}).
	* If the type has not been changed by the refactoring, the original type signature is returned.
	*
	* @return the the new type
	*/
	public String getType() {
	return fNewSignature;
	}

	/**
	* The default value for new parameters or <code>null</code>.
	*
	* @return returns the default value for new parameters or <code>null</code>.
	*/
	public String getDefaultValue() {
	return fDefaultValue;
	}

	/* (non-Javadoc)
	* @see java.lang.Object#toString()
	*/
	public String toString() {
	return "name: " + fNewName + ", type: " + fNewSignature + ", oldIndex: " + fOldIndex + ", defaultValue: " + fDefaultValue; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
	}

	}

	/**
	* Instances of {@link ChangeMethodSignatureArguments.ThrownException} are used to describe the new thrown
	* exceptions after a change method signature refactoring.
	*/
	public final static class ThrownException {

	private final int fOldIndex;
	private final String fType;

	/**
	* Creates a {@link ChangeMethodSignatureArguments.ThrownException}.
	*
	* @param oldIndex the index of the thrown exception in the original method
	* or <code>-1</code> if the thrown exception is a new thrown exception.
	* @param newSignature the new type of the thrown exception in signature notation
	* (See {@link Signature}).
	*/
	public ThrownException(int oldIndex, String newSignature) {
	fOldIndex= oldIndex;
	fType= newSignature;
	}

	/**
	* Returns the index of the thrown exception in the original method or <code>-1</code> if the thrown exception
	* has been added.
	*
	* @return the index of the parameter in the original method or <code>-1</code> if the thrown exception
	* has been added.
	*/
	public int getOldIndex() {
	return fOldIndex;
	}

	/**
	* Returns the new type of the thrown exception in signature notation (See {@link Signature}).
	*
	* @return the the new type
	*/
	public String getType() {
	return fType;
	}

	/* (non-Javadoc)
	* @see java.lang.Object#toString()
	*/
	public String toString() {
	return "type: " + fType + ", oldIndex: " + fOldIndex; //$NON-NLS-1$ //$NON-NLS-2$
	}
	}

	private String fNewName;
	private String fNewReturnType;

	private final int fNewVisibility;
	private final Parameter[] fNewParameters;
	private final ThrownException[] fThrownExceptions;
	private final boolean fKeepOriginal;

	/**
	* Creates new change method signature arguments.
	*
	* @param newName the new name of the element to be changed
	* @param newReturnType the new method return type in signature notation (see {@link Signature}).
	* @param newVisibility the new visibility; one of {@link Flags#AccPublic}, {@link Flags#AccProtected},
	* {@link Flags#AccPrivate} or <code>0</code> for the default visibility.
	* @param newParameters the new parameters of this method
	* @param thrownExceptions the new exceptions thrown by this method
	* @param keepOriginal <code>true</code> if the original method is kept as a delegate to the new one,
	* <code>false</code> otherwise
	*/
	public ChangeMethodSignatureArguments(String newName, String newReturnType, int newVisibility, Parameter[] newParameters, ThrownException[] thrownExceptions, boolean keepOriginal) {
	Assert.isNotNull(newName);
	fNewName= newName;
	fNewReturnType= newReturnType;
	fNewVisibility= newVisibility;
	fNewParameters= newParameters;
	fThrownExceptions= thrownExceptions;
	fKeepOriginal= keepOriginal;
	}

	/**
	* Returns the new method name. If the name has not been changed by the refactoring, the original
	* parameter name is returned.
	*
	* @return the method name
	*/
	public String getNewName() {
	return fNewName;
	}

	/**
	* Returns the type signature of the new return type of this method.
	* For constructors, this returns the signature for void.
	* If the return type has not been changed by the refactoring, the original
	* return type signature is returned.
	*
	* @return the new return type
	*/
	public String getNewReturnType() {
	return fNewReturnType;
	}

	/**
	* Returns the new visibility of this method. The visibility is one of {@link Flags#AccPublic}, {@link Flags#AccProtected},
	* {@link Flags#AccPrivate} or <code>0</code> for the default visibility. If the visibility has not been changed by the
	* refactoring, the original visibility is returned.
	*
	* @return the visibility of the method
	*/
	public int getNewVisibility() {
	return fNewVisibility;
	}

	/**
	* Returns the new parameters of this method.
	*
	* @return the new parameters of this method
	*/
	public Parameter[] getNewParameters() {
	return fNewParameters;
	}

	/**
	* Returns the new thrown exceptions of this method.
	*
	* @return new thrown exceptions of this method
	*/
	public ThrownException[] getThrownExceptions() {
	return fThrownExceptions;
	}

	/**
	* Returns whether the original method is kept as a delegate to the new one.
	*
	* @return returns <code>true</code> if the original method is kept <code>false</code> otherwise
	*/
	public boolean getKeepOriginal() {
	return fKeepOriginal;
	}

	/**
	* {@inheritDoc}
	*/
	public String toString() {
	StringBuffer buf= new StringBuffer("change signature to "); //$NON-NLS-1$
	buf.append("\n\tvisibility: ").append(Flags.toString(fNewVisibility)); //$NON-NLS-1$
	buf.append("\n\treturn type sig: ").append(fNewReturnType); //$NON-NLS-1$
	buf.append("\n\tnew name: ").append(fNewName); //$NON-NLS-1$
	buf.append("\n\tkeep original: ").append(fKeepOriginal); //$NON-NLS-1$
	for (int i= 0; i < fNewParameters.length; i++) {
	buf.append("\n\tparameter ").append(i).append(": ").append(fNewParameters[i]); //$NON-NLS-1$ //$NON-NLS-2$
	}
	for (int i= 0; i < fThrownExceptions.length; i++) {
	buf.append("\n\texception ").append(i).append(": ").append(fThrownExceptions[i]); //$NON-NLS-1$ //$NON-NLS-2$
	}
	return buf.toString();
	}
	}