* Character constant indicating a capture of a wildcard type in a 

	 * signature.Value is <code>'!'</code>.

	 * @since 3.1

	 */

	public static final char C_CAPTURE	= '!';

	/**

	/**

	 * Kind constant for the capture of a wildcard type signature.

	 * @see #getTypeSignatureKind(String)

	 * @since 3.1

	 */

	public static final int CAPTURE_TYPE_SIGNATURE = 6;

	private static final char[] CAPTURE = "capture-of".toCharArray(); //$NON-NLS-1$

		case 'c':

		    checkPos = checkName(CHAR, typeName, pos, length);

		    if (checkPos > 0) {

		        pos = encodeArrayDimension(typeName, checkPos, length, buffer);

			    buffer.append(C_CHAR);

			    return pos;

			} else {

				checkPos = checkName(CAPTURE, typeName, pos, length);

				if (checkPos > 0) {

					pos = consumeWhitespace(typeName, checkPos, length);

					if (typeName[pos] != '?') {

						break;

					}

				} else {

					break;

				}

			}

			buffer.append(C_CAPTURE);

			// fall-thru for wildcard part of capture typecheckPos

		case C_CAPTURE :

			return CAPTURE_TYPE_SIGNATURE;

		case C_CAPTURE :

			return CAPTURE_TYPE_SIGNATURE;			

/**

 * Returns new method signature without capture information or

 * method signature itself if no specific capture information was present.

 * <p>

 * For example:

 * <pre>

 * <code>

 * removeCaptureFromMethod({'L','T','e','s','t','<','!','+','L','j','a','v','a','.','l','a','n','g','.','T','h','r','o','w','a','b','l','e',';','>',';'})

 * will return: {'L','T','e','s','t','<','+','L','j','a','v','a','.','l','a','n','g','.','T','h','r','o','w','a','b','l','e',';','>',';'}

 * </code>

 * </pre>

 * </p>

 *

 * @param captureSignature the signature which may have been captured

 * @return new signature without capture information or siganture itself

 * 	if no specific capture information was there

 * @exception NullPointerException if name is null

 * @since 3.1

 * TODO (frederic) Create remove(char[], char) method on CharOperation and call it from here

 */

public static char[] removeCaptureFromMethod(char[] captureSignature) {

	char[] result = null;

	int count = 0;

	for (int i = 0, length = captureSignature.length; i < length; i++) {

		char c = captureSignature[i];

		if (c == C_CAPTURE) {

			if (result == null) {

				result = new char[length];

				System.arraycopy(captureSignature, 0, result, 0, i);

				count = i;

			}

		} else if (result != null) {

			result[count++] = c;

		}

	}

	if (result == null) return captureSignature;

	System.arraycopy(result, 0, result = new char[count], 0, count);

	return result;

}

/**

 * Returns new method signature without capture information or

 * method signature itself if no specific capture information was present.

 * <p>

 * For example:

 * <pre>

 * <code>

 * removeCaptureFromMethod("LTest<!+Ljava.lang.Throwable;>;")

 * will return: "LTest<+Ljava.lang.Throwable;>;"

 * </code>

 * </pre>

 * </p>

 *

 * @param captureSignature the signature which may have been captured

 * @return new signature without capture information or siganture itself

 * 	if no specific capture information was there

 * @exception NullPointerException if name is null

 * @since 3.1

 */

public static String removeCaptureFromMethod(String captureSignature) {

		char[] array = captureSignature.toCharArray();

		char[] result = removeCaptureFromMethod(array);

		if (array == result) return captureSignature;

		return new String(result);

}

			case C_CAPTURE:

			case C_CAPTURE :

				return appendCaptureTypeSignature(string, start, fullyQualifyTypeNames, buffer);

 * @return the 0-based character index of the last character

 * @exception IllegalArgumentException if this is not an array type signature

 * @see Util#scanArrayTypeSignature(char[], int)

 */

private static int appendCaptureTypeSignature(char[] string, int start, boolean fullyQualifyTypeNames, StringBuffer buffer) {

	// need a minimum 2 char

	if (start >= string.length - 1) {

		throw new IllegalArgumentException();

	}

	char c = string[start];

	if (c != C_CAPTURE) { //$NON-NLS-1$

		throw new IllegalArgumentException();

	}

	buffer.append(CAPTURE).append(' ');

	return appendTypeArgumentSignature(string, start + 1, fullyQualifyTypeNames, buffer);

}

/**

 * Scans the given string for an array type signature starting at the given

 * index and appends it to the given buffer, and returns the index of the last

 * character.

 * 

 * @param string the signature string

 * @param start the 0-based character index of the first character

 * @param fullyQualifyTypeNames <code>true</code> if type names should be fully

 *   qualified, and <code>false</code> to use only simple names