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.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

This class is not intended to be subclassed by clients.

Since:
1.2
@noextend
This class is not intended to be subclassed by clients./**
 * 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 Parameter are used to describe the new parameters after a change method signature refactoring. /**
	 * 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 Parameter. 
Params:
oldIndex – the index of the parameter in the original method or -1 if the parameter is a new parameter.
newName – the new name of the parameter.
newSignature – the new type of the parameter in signature notation (See Signature).
defaultValue – the default value for new parameters or null./**
		 * 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 -1 if the parameter
has been added.
Returns:
the index of the parameter in the original method or -1 if the parameter
has been added/**
		 * 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.
Returns:
the new parameter name/**
		 * 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 Signature). If the type has not been changed by the refactoring, the original type signature is returned. 
Returns:
the the new type/**
		 * 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 null.
Returns:
returns the default value for new parameters or null./**
		 * 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;
		}

		@Override
		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 ThrownException are used to describe the new thrown exceptions after a change method signature refactoring. /**
	 * 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 ThrownException. 
Params:
oldIndex – the index of the thrown exception in the original method
                            or -1 if the thrown exception is a new thrown exception.
newSignature – the new type of the thrown exception in signature notation (See Signature)./**
		 * 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 -1 if the thrown exception
has been added.
Returns:
the index of the parameter in the original method or -1 if the thrown exception
has been added./**
		 * 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 Signature). 
Returns:
the the new type/**
		 * Returns the new type of the thrown exception in signature notation (See {@link Signature}).
		 *
		 * @return the the new type
		 */
		public String getType() {
			return fType;
		}

		@Override
		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.
Params:
newName – the new name of the element to be changed
newReturnType – the new method return type in signature notation (see Signature).
newVisibility – the new visibility; one of Flags.AccPublic, Flags.AccProtected, Flags.AccPrivate or 0 for the default visibility.
newParameters – the new parameters of this method
thrownExceptions – the new exceptions thrown by this method
keepOriginal – true if the original method is kept as a delegate to the new one,
false otherwise/**
	 * 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.
Returns:
the method name/**
	 * 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.
Returns:
the new return type/**
	 * 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 Flags.AccPublic, Flags.AccProtected, Flags.AccPrivate or 0 for the default visibility. If the visibility has not been changed by the
refactoring, the original visibility is returned.
Returns:
the visibility of the method/**
	 * 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.
Returns:
the new parameters of this method/**
	 * 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.
Returns:
new thrown exceptions of this method/**
	 * 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.
Returns:
returns true if the original method is kept false otherwise/**
	 * 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;
	}

	@Override
	public String toString() {
		StringBuilder buf= new StringBuilder("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();
	}
}